¿Podrías explicar el orden de locking?

Aprendí que debería desbloquear el orden inverso para bloquear el pedido. Por ejemplo.

A.lock(); B.lock(); B.unlock(); A.unlock(); 

Pero, ¿qué pasaría si me gusta esto?

 A.lock(); B.lock(); A.unlock(); B.unlock(); 

Intento hacer una situación de punto muerto, pero si siempre locking A antes que a B, entonces no sé cómo ocurrirá el punto muerto. ¿Me ayudarías?

El orden de locking solo significa que evita lockings al obtener lockings en un orden fijo y no obtiene lockings una vez que comienza a desbloquear.

No creo que el orden de deslocking haga una diferencia aquí (de hecho, debería ser beneficioso liberar un locking lo antes posible, incluso si está fuera de servicio)

En el caso simple dado, no es necesario desbloquear en el orden inverso para evitar un punto muerto.

Sin embargo , a medida que el código se vuelve más complicado, el deslocking en el orden inverso lo ayuda a mantener un orden de locking adecuado.

Considerar:

 A.lock(); B.lock(); Foo(); A.unlock(); Bar(); B.unlock(); 

Si Bar() intenta readquirir A, efectivamente ha roto su orden de locking. Estás presionando B y luego tratando de obtener A. Ahora puede bloquear.

Si desbloqueas en el estilo de orden inverso (lo cual es muy natural si usas RAII):

 A.lock(); B.lock(); Foo(); B.unlock(); Bar(); A.unlock(); 

entonces no importa si Bar() intenta tomar un locking, ya que se mantendrá el orden de locking.

Tu ejemplo no va a estancarse consigo mismo nunca. Desbloquear en orden inverso no es importante, se bloquea en un orden consistente. Esto bloqueará, aunque los deslockings estén en orden inverso

 Thread 1 A.lock(); B.lock(); B.unlock(); A.unlock(); Thread 2 B.lock(); A.lock(); A.unlock(); B.unlock(); 

No creo que haya un punto muerto aquí. El concepto general de interlocking es que un subproceso espera algún recurso bloqueado por otro subproceso, mientras que otro subproceso necesita recursos bloqueados por el primer subproceso para finalizar y liberar primero el recurso necesario.

Otras lecturas

El orden de deslocking no afectará la propensión del sistema a un punto muerto, sin embargo, hay una razón para pensar en el orden de deslocking:

Para evitar interlockings, debes asegurarte de que tus lockings / deslockings estén sincronizados, ya que nunca perderás un deslocking. Como enfoque estilístico, al contar conspicuamente con bloques de código que son responsables de un locking particular, es mucho más fácil identificar visualmente que los lockings y deslockings están sincronizados. El efecto final es que el código claramente correcto probablemente tomará y liberará los lockings como usted describe.

Y para Java, el deslocking está en el orden inverso si synchronized palabra clave synchronized se usa para el locking. No hay forma de desbloquear en un orden diferente para usar palabras clave synchronized .

 synchronized(a) { synchronized(b) { // statements } } 
  > lock(B) > ---------- lock(C) > ---------- lock(B) >>>> would block here > ---------- release(B) > ---------- release(C) > lock(C) >>>>>> would block here > release(B) > release(C) 

Su respuesta es excelente, he aquí otra situación en la que puede producirse un punto muerto si se realiza un locking y una liberación desordenados. Una palabra, Release & Lock desordenado , rompe la suposición que utilizamos para diseñar nuestra zona de gestión de recursos compartidos y crítica.