multithreading - intrinsic - synchronization in java oracle
¿Qué es un punto muerto? (15)
Al escribir aplicaciones de subprocesos múltiples, uno de los problemas más comunes experimentados son los interbloqueos.
Mis preguntas a la comunidad son:
¿Qué es un punto muerto?
¿Cómo los detecta?
¿Los manejas?
Y finalmente, ¿cómo evitas que ocurran?
El bloqueo se produce cuando dos hilos adquieren bloqueos que impiden que cualquiera de ellos progrese. La mejor forma de evitarlos es con un desarrollo cuidadoso. Muchos sistemas incorporados protegen contra ellos mediante el uso de un temporizador de vigilancia (un temporizador que reinicia el sistema siempre que se cuelgue durante un cierto período de tiempo).
El punto muerto es un problema común en problemas de multiprocesamiento / multiprogramación en SO. Supongamos que hay dos procesos P1, P2 y dos recursos compartibles a nivel mundial, R1, R2, y en la sección crítica, se debe acceder a ambos recursos.
Inicialmente, el sistema operativo asigna R1 para procesar P1 y R2 para procesar P2. Como ambos procesos se ejecutan simultáneamente, pueden comenzar a ejecutar su código, pero el PROBLEMA surge cuando un proceso llega a la sección crítica. Entonces, el proceso R1 esperará a que el proceso P2 libere R2 y viceversa ... Entonces esperarán por siempre (CONDICIÓN DE DESADLOQUE).
Una pequeña ANALOGÍA ...
Tu madre (OS),
Usted (P1),
Tu hermano (P2),
Apple (R1),
Cuchillo (R2),
sección crítica (corte de manzana con cuchillo).Tu madre te da la manzana y el cuchillo a tu hermano al principio.
Ambos están felices y jugando (Ejecutando sus códigos).
Cualquiera de ustedes quiere cortar la manzana (sección crítica) en algún momento.
No quieres darle la manzana a tu hermano.
Tu hermano no quiere darte el cuchillo.
Entonces, los dos van a esperar mucho, mucho, mucho tiempo :)
El punto muerto es una situación que ocurre cuando hay menos recursos disponibles a medida que el proceso lo solicita. Significa que cuando la cantidad de recursos disponibles es inferior a la solicitada por el usuario, en ese momento el proceso entra en estado de espera. Algunas veces la espera aumenta más y no hay ninguna posibilidad de verificar el problema de la falta de recursos. esta situación se conoce como punto muerto. En realidad, el punto muerto es un problema importante para nosotros y ocurre solo en el sistema operativo multitarea. No se puede producir un bloqueo en el sistema operativo de una sola tarea porque todos los recursos están presentes solo para la tarea que se está ejecutando actualmente.
El punto muerto se produce cuando un hilo está esperando a que otro hilo termine y viceversa.
¿Como evitar?
- Evite las cerraduras anidadas
- Evite bloqueos innecesarios
- Usar unión de hilo ()
¿Cómo lo detecta?
ejecuta este comando en cmd:
jcmd $PID Thread.print
reference : geeksforgeeks
El punto muerto se puede definir formalmente como: Un conjunto de procesos está estancado si cada proceso en el conjunto está esperando un evento que solo puede causar otro proceso en el conjunto. Debido a que todos los procesos están esperando, ninguno de ellos causará ninguno de los eventos que podrían despertar a ninguno de los otros miembros del conjunto, y todos los procesos continúan esperando por siempre. A continuación, se muestran las cuatro condiciones que deben estar presentes para que se produzca un punto muerto. Si uno de ellos está ausente, no es posible un punto muerto.
Condición de exclusión mutua: cada recurso está actualmente asignado a exactamente un proceso o está disponible.
Condición de espera y espera: los procesos que actualmente tienen recursos otorgados anteriormente pueden solicitar nuevos recursos.
Sin condición de preferencia: los recursos otorgados previamente no pueden ser retirados a la fuerza de un proceso. Deben ser liberados explícitamente por el proceso que los contiene.
Condición de espera circular: debe haber una cadena circular de dos o más procesos, cada uno de los cuales está esperando un recurso retenido por el siguiente miembro de la cadena. En general, se usan cuatro estrategias para lidiar con los puntos muertos. Ellos son: Simplemente ignore el problema por completo. Tal vez si lo ignoras, te ignorará. Detección y recuperación: permita que ocurran interbloqueos, detectarlos y tomar medidas. Evitación dinámica mediante una cuidadosa asignación de recursos. Prevención: al negar estructuralmente una de las cuatro condiciones necesarias para causar un punto muerto.
Los bloqueos solo se producirán cuando tenga dos o más bloqueos que puedan adquirirse al mismo tiempo y que se agarren en un orden diferente.
Formas de evitar tener bloqueos son:
- evitar tener bloqueos (si es posible),
- evitar tener más de un bloqueo
- toma siempre las cerraduras en el mismo orden.
Mutex en esencia es un bloqueo que proporciona acceso protegido a los recursos compartidos. En Linux, el tipo de datos de exclusión mutua de subprocesos es pthread_mutex_t. Antes del uso, inicialízalo.
Para acceder a los recursos compartidos, debe bloquear el mutex. Si el mutex ya está en el bloqueo, la llamada bloqueará el hilo hasta que se desbloquee el mutex. Una vez completada la visita a los recursos compartidos, debe desbloquearlos.
En general, hay algunos principios básicos no escritos:
Obtenga el candado antes de usar los recursos compartidos.
Sosteniendo la cerradura el menor tiempo posible.
Libere el bloqueo si el hilo devuelve un error.
Para definir el punto muerto, primero definiría el proceso.
Proceso : como sabemos, el proceso no es más que un program en ejecución.
Recurso : para ejecutar un programa, el proceso necesita algunos recursos. Las categorías de recursos pueden incluir memoria, impresoras, CPU, archivos abiertos, unidades de cinta, CD-ROM, etc.
Deadlock : Deadlock es una situación o condición en la que dos o más procesos están reteniendo algunos recursos e intentando adquirir más recursos, y no pueden liberar los recursos hasta que finalicen la ejecución.
Situación o situación de punto muerto
En el diagrama de arriba hay dos procesos P1 y p2 y hay dos recursos R1 y R2 .
El recurso R1 se asigna al proceso P1 y el recurso R2 se asigna al proceso p2 . Para completar la ejecución del proceso P1 necesita el recurso R2 , entonces P1 solicita R2 , pero R2 ya está asignado a P2 .
De la misma manera, el Proceso P2 para completar su ejecución necesita R1 , pero R1 ya está asignado a P1 .
ambos procesos no pueden liberar su recurso hasta y a menos que completen su ejecución. Entonces, ambos esperan otros recursos y esperarán por siempre. Entonces esta es una condición DEADLOCK .
Para que ocurra un punto muerto, cuatro condiciones deben ser verdaderas.
- Exclusión mutua : cada recurso está asignado actualmente a exactamente un proceso o está disponible. (Dos procesos no pueden controlar simultáneamente el mismo recurso o estar en su sección crítica).
- Espera y espera : los procesos que actualmente tienen recursos pueden solicitar nuevos recursos.
- Sin preferencia : una vez que un proceso contiene un recurso, no puede ser retirado por otro proceso o el kernel.
- Espera circular : cada proceso está esperando obtener un recurso retenido por otro proceso.
y todas estas condiciones se cumplen en el diagrama anterior.
Permítanme explicar un ejemplo del mundo real (no real) para una situación de estancamiento de las películas del crimen. Imagine que un criminal tiene como rehén y, en contra de eso, un policía también tiene como rehén a un amigo del criminal. En este caso, el criminal no va a dejar ir al rehén si el policía no permite que su amigo lo suelte. Además, el policía no permitirá que el amigo del criminal lo suelte, a menos que el criminal libere al rehén. Esta es una situación interminable e indigna de confianza, porque ambas partes insisten en el primer paso el uno para el otro.
Escena criminal y policial
Entonces, simplemente, cuando dos hilos necesitan dos recursos diferentes y cada uno de ellos tiene el bloqueo del recurso que el otro necesita, es un punto muerto.
Otra explicación de alto nivel de punto muerto: corazones rotos
Estás saliendo con una chica y un día después de una discusión, ambos lados se rompen el uno con el otro y esperan una llamada de "lo siento" y "te extrañé" . En esta situación, ambas partes quieren comunicarse entre sí si y solo si una de ellas recibe una llamada de "lo siento" del otro. Debido a que ninguno de los dos va a iniciar la comunicación y esperar en estado pasivo, ambos esperarán a que el otro inicie la comunicación que termina en una situación de bloqueo.
Por encima de algunas explicaciones son agradables. Espero que esto también sea útil: https://ora-data.blogspot.in/2017/04/deadlock-in-oracle.html
En una base de datos, cuando una sesión (p. Ej., Ora) quiere un recurso retenido por otra sesión (p. Ej. Datos), pero esa sesión (datos) también quiere un recurso que es retenido por la primera sesión (ora). Puede haber más de 2 sesiones involucradas también, pero la idea será la misma. En realidad, los Bloqueos evitan que algunas transacciones continúen funcionando. Por ejemplo: supongamos que ORA-DATA mantiene el bloqueo A y solicita el bloqueo B Y SKU mantiene el bloqueo B y solicita el bloqueo A.
Gracias,
Puedes echar un vistazo a estos maravillosos artículos , en la sección Interbloqueo . Está en C # pero la idea sigue siendo la misma para otra plataforma. Cito aquí para una fácil lectura
Se produce un interbloqueo cuando dos subprocesos cada uno esperan un recurso mantenido por el otro, por lo que ninguno puede continuar. La forma más fácil de ilustrar esto es con dos bloqueos:
object locker1 = new object();
object locker2 = new object();
new Thread (() => {
lock (locker1)
{
Thread.Sleep (1000);
lock (locker2); // Deadlock
}
}).Start();
lock (locker2)
{
Thread.Sleep (1000);
lock (locker1); // Deadlock
}
Se produce un bloqueo cuando varios procesos intentan acceder al mismo recurso al mismo tiempo.
Un proceso se pierde y debe esperar a que el otro termine.
Se produce un interbloqueo cuando el proceso de espera aún se mantiene en otro recurso que el primero necesita antes de que pueda finalizar.
Entonces, un ejemplo:
El recurso A y el recurso B son utilizados por el proceso X y el proceso Y
- X comienza a usar A.
- X e Y intentan comenzar a usar B
- Y ''gana'' y obtiene B primero
- ahora Y necesita usar A
- A está bloqueado por X, que está esperando Y
La mejor manera de evitar interbloqueos es evitar que los procesos se crucen de esta manera. Reduce la necesidad de bloquear todo lo que puedas.
En las bases de datos, evite hacer muchos cambios en diferentes tablas en una sola transacción, evite los desencadenantes y cambie a lecturas optimistas / sucias / nolock tanto como sea posible.
Un interbloqueo es un estado de un sistema en el que ningún proceso / subproceso es capaz de ejecutar una acción. Como lo mencionaron otros, un punto muerto suele ser el resultado de una situación en la que cada proceso / subproceso desea adquirir un bloqueo para un recurso que ya está bloqueado por otro (o incluso el mismo) proceso / subproceso.
Existen varios métodos para encontrarlos y evitarlos. Uno está pensando mucho y / o tratando muchas cosas. Sin embargo, lidiar con el paralelismo es notoriamente difícil y la mayoría de las personas (si no todas) no podrán evitar por completo los problemas.
Algunos métodos más formales pueden ser útiles si se toma en serio el tratamiento de este tipo de problemas. El método más práctico del que soy consciente es utilizar el enfoque teórico de procesos. Aquí puede modelar su sistema en algún lenguaje de proceso (por ejemplo, CCS, CSP, ACP, mCRL2, LOTOS) y usar las herramientas disponibles para (modelo) verificar si hay interbloqueos (y tal vez algunas otras propiedades también). Ejemplos de herramientas para usar son FDR, mCRL2, CADP y Uppaal. Algunas almas valientes incluso podrían probar que sus sistemas están libres de interferencias mediante el uso de métodos puramente simbólicos (prueba de teorema, busquen a Owicki-Gries).
Sin embargo, estos métodos formales normalmente requieren algún esfuerzo (por ejemplo, aprender los principios básicos de la teoría de procesos). Pero supongo que eso es simplemente una consecuencia del hecho de que estos problemas son difíciles.
Un punto muerto ocurre cuando un hilo está esperando algo que nunca ocurre.
Normalmente, sucede cuando un subproceso está esperando en un mutex o semáforo que nunca fue liberado por el propietario anterior.
También ocurre con frecuencia cuando tienes una situación que involucra dos hilos y dos bloqueos como este:
Thread 1 Thread 2
Lock1->Lock(); Lock2->Lock();
WaitForLock2(); WaitForLock1(); <-- Oops!
Generalmente los detecta porque las cosas que espera que suceda nunca lo hacen, o la aplicación se cuelga por completo.
Un punto muerto se produce cuando hay una cadena circular de hilos o procesos que contienen un recurso bloqueado y están tratando de bloquear un recurso en el siguiente elemento de la cadena. Por ejemplo, dos hilos que mantienen, respectivamente, el bloqueo A y el bloqueo B, y ambos intentan adquirir el otro bloqueo.