Comprensión profunda del estado del hilo de bloqueo de programación concurrente

Debido a que el LockSupport puede ver el hilo en el estado bloqueado, pensado por un momento que no hay manera de hacer que el hilo en el estado bloqueado? Porque no puedo conseguir la memoria sólo cuando la cerradura entrará en el estado bloqueado
pareció un poco-hilo de disparo en el bloqueado El método en
Internet dice esto:
(1) Thread sleep: método Thread.sleep (long millis) para hacer que el hilo pase a un estado bloqueado.

(2) Subproceso en espera: método wait () en la clase Object,

(3) Cortesía de hilo, método Thread.yield ()

(4) Método de cierre automático de roscas, join (),

(5) Los métodos suspend () y resume () El
método anterior puede bloquear el subproceso, pero creo que solo cuando se ingresa el estado de bloqueo puede bloquearse el subproceso. Puede ser que soy demasiado incómodo. Creo que esta declaración es un poco sesgada. , Porque recuerdo la siguiente imagen en mi mente: ¿

pero es posible que el libro esté equivocado?
Entonces inténtalo

Método 1.sleep ()

 public static void main(String[] args) {
        new Thread(()->{
            try {
                System.out.println("正在睡眠");
                Thread.sleep(100000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t1").start();
    }

Use jps para ver el hilo

Use jstack para ver el estado del hilo:

Oh, TimeWaiting, el hilo está en un estado de espera de tiempo de espera

2. El método de espera

    Object o = new Object();
        Thread t2 = new Thread(() -> {
            synchronized (o) {
                try {
                    System.out.println("执行等待!");
                    o.wait();
                } catch (InterruptedException e) {

                }
            }
        }, "t2");
        t2.start();

        Thread.sleep(100000);
        o.notify();

estado de espera

3.synchronized (estado bloqueado)

 Object o = new Object();
        new Thread(() -> {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o) {
            }
        }, "t1").start();
        //让t2 先拿到锁,然后就一直处于wait状态,我们再来观察t1
        new Thread(() -> {
            synchronized (o) {
                try {
                    Thread.sleep(100000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t2").start();

4. unirse

  Thread t1 = new Thread(() -> {
            try {
                Thread.sleep(10000000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "t1");
        t1.start();
        //先让t1 跑起来 观察t2
        Thread.sleep(10);
        Thread t2 = new Thread(() -> {
            try {
                t1.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }, "t2");
        t2.start();

5 rendimiento

El método de renunciar al intervalo de tiempo de la CPU es un poco difícil de operar, porque es demasiado corto para renunciar a un intervalo de tiempo

Pensaré en una forma de actualizar más tarde

6.Soporte de bloqueo

    Thread t1 = new Thread(() -> {
            LockSupport.park();
        }, "t1");
        t1.start();
        Thread.sleep(100000);
        LockSupport.unpark(t1);

Conclusión: el
último LockSupport puede derrocar a todos los anteriores: solo ingresar al estado de bloqueo se puede llamar un hilo de bloqueo

Quizás esta parte no está específicamente definida, por lo que no necesita profundizar en ella, solo necesita comprenderla y no debe usar esta parte del conocimiento en el desarrollo diario.

Y si desea bloquear el hilo: todo lo
anterior, excepto el rendimiento, puede desempeñar el papel de bloquear el hilo, en lugar de permitir que el hilo entre en el estado de hilo de bloqueo definido por java