Comprensión de java.lang.Thread.State: ESPERA (estacionamiento)

Primero, una pregunta realmente tonta, me preguntaba qué significa el 'estacionamiento' en espera. ¿El hilo está esperando ser estacionado o simplemente se estacionó y por lo tanto está en estado de espera? Y cuando ocurre ese estacionamiento, ¿cuántos recursos de cpu / memoria se toman? ¿Cuál es el propósito de estacionar un hilo?

En segundo lugar, observando el método de estacionamiento en la API de subprocesos de Java

Desactiva el hilo actual para fines de programación de hilos a menos que el permiso esté disponible.

Si el permiso está disponible, se consume y la llamada regresa inmediatamente; de lo contrario, el hilo actual se deshabilita para fines de programación del hilo y permanece inactivo hasta que suceda una de tres cosas ...

El inglés no es mi idioma principal, por lo que tengo algunas dificultades para entenderlo, tenía la intención de 'permitir' como una especie de 'permiso para aparcar el hilo', por lo que las preguntas que siguen:

• ¿Cuál es el significado de eso, qué es 'permiso', y quién y cómo verifica esos permisos?
• ¿Qué significa eso: 'si el permiso está disponible, entonces se consume', se está 'estacionado'?
• A continuación, si el segundo punto es cierto, ¿cuál es la diferencia entre "aparcar" y "permanecer inactivo"? Si tengo permiso, puedo estacionarlo para siempre y, si no, puedo dejarlo 'inactivo'.

Gracias

Permiso significa un permiso para continuar la ejecución. Estacionar significa suspender la ejecución hasta que el permiso esté disponible.

A diferencia Semaphorede los permisos, los permisos de LockSupportestán asociados con subprocesos (es decir, el permiso se otorga a un subproceso en particular) y no se acumula (es decir, solo puede haber un permiso por subproceso, cuando el subproceso consume el permiso, desaparece).

Puede dar permiso a un hilo llamando unpark(). Un hilo puede suspender su ejecución hasta que el permiso esté disponible (o se interrumpa el hilo, o expire el tiempo de espera, etc.) llamando park(). Cuando el permiso está disponible, el subproceso aparcado lo consume y sale de un park()método.

Según la documentación del estado de subprocesos de Java , un subproceso puede pasar al estado EN ESPERA por tres razones:

1. Object.wait sin tiempo de espera
2. Thread.join sin tiempo de espera
3. LockSupport.park

Cuando llama a un método de estacionamiento en un hilo, deshabilita el hilo para fines de programación de hilos a menos que el permiso esté disponible. Puede llamar al método unpark para hacer disponible el permiso para el hilo dado, si aún no estaba disponible.

Entonces, cuando su Thread esté en modo de ESPERA por LockSupport.park, lo mostrará como ESPERANDO (estacionamiento).

Tenga en cuenta que solo puede llamar al estacionamiento en el hilo actual. Este es un mecanismo muy útil para implementar el patrón de diseño productor-consumidor.

De la descripción de la clase (en la parte superior del javadoc LockSupport ) donde describe el permiso:

Esta clase asocia con cada hilo que la usa, un permiso (en el sentido de la clase Semaphore). Una llamada para estacionar regresará inmediatamente si el permiso está disponible, consumiendo [el permiso] en el proceso; de lo contrario, [la llamada para aparcar] puede bloquearse. Una llamada para cancelar el estacionamiento hace que el permiso esté disponible, si aún no lo estaba. (Sin embargo, a diferencia de los semáforos, los permisos no se acumulan. Hay como máximo uno).

(Expandí el [texto] para que sea más fácil de leer para quienes no hablan inglés).

Es de esperar que alguien con un conocimiento más profundo pueda desarrollar esto. Vea la respuesta de axtavt.

Como nota final, una cita final del javadoc:

Estos métodos están diseñados para usarse como herramientas para crear utilidades de sincronización de alto nivel y no son útiles en sí mismos para la mayoría de las aplicaciones de control de simultaneidad.

La parte que me hizo volver a examinar esta pregunta que no pude evitar mientras leía la documentación fue:

Si el permiso está disponible, se consume y la llamada vuelve de inmediato ...

Entonces, cuando el permiso está "disponible", ¿ quién y cómo lo hace disponible para que pueda consumirse inmediatamente? De alguna manera fue trivial de descubrir:

public static void main(String[] args) {

    Thread parkingThread = new Thread(() -> {
        System.out.println("Will go to sleep...");
        sleepTwoSeconds();
        System.out.println("Parking...");
        // this call will return immediately since we have called  LockSupport::unpark
        // before this method is getting called, making the permit available
        LockSupport.park();
        System.out.println("After parking...");
    });

    parkingThread.start();

    // hopefully this 1 second is enough for "parkingThread" to start
    // _before_ we call un-park
    sleepOneSecond();
    System.out.println("Un-parking...");
    // making the permit available while the thread is running and has not yet
    // taken this permit, thus "LockSupport.park" will return immediately
    LockSupport.unpark(parkingThread);

}

private static void sleepTwoSeconds() {
    try {
        Thread.sleep(1000 * 2);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

private static void sleepOneSecond() {
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}    

El código habla por sí mismo, se threadestá ejecutando pero aún no se ha llamado LockSupport.park, mientras que otro hilo lo llama LockSupport.unpark, lo que hace que el permiso esté disponible. Después de eso llamamosLockSupport.park y eso regresa inmediatamente ya que el permiso está disponible.

Una vez que lo piensa, esto es un poco peligroso, si expone sus subprocesos a algún código que no controla y ese código llama LockSupport.unparkmientras lo hace park, es posible que no funcione.

Según tengo entendido, el "permiso" es solo un objeto que representa si un hilo se puede "desempacar" o no. Y esto lo verifica el propio Thread (o de JRE cuando intentas aparcar un Thread) Lo "se consume", entiendo que el permiso desaparece y el Thread no se desactiva.

Creo que debería aprender un poco más sobre el subproceso múltiple. Piense en ello como un dispensador de objetos llamado "permiso". Le dices a un Hilo que se estacione, y el Hilo revisa el dispensador, si hay un "permiso", el Hilo lo toma y se va (sin estacionamiento). Si no hay "permiso" en el dispensador, el Thread se estaciona hasta que haya un "permiso" disponible (y puede poner un "permiso" en el dispensador con unpark.

En cuanto al uso de CPU / memoria, creo que depende del sistema operativo, etc.