Thread

创建线程的方式

方法一 直接使用Thread

public class MyThread extends Thread {
	//定义指定线程名称的构造方法    
    public MyThread(String name) {    
        //调用父类的String参数的构造方法，指定线程的名称        
        super(name);        
    }
    
    /**    
     * 重写run方法，完成该线程执行的逻辑    
     */    
	@Override    
	public void run() {    
        for (int i = 0; i < 10; i++) {        
        System.out.println(getName()+"：正在执行！"+i);            
        }        
	}    
}
//可以使用匿名内部类或者lambda进行简化

方法二 实现Runnable接口

/**
     * Allocates a new {@code Thread} object. This constructor has the same
     * effect as {@linkplain #Thread(ThreadGroup,Runnable,String) Thread}
     * {@code (null, target, gname)}, where {@code gname} is a newly generated
     * name. Automatically generated names are of the form
     * {@code "Thread-"+}<i>n</i>, where <i>n</i> is an integer.
     *
     * @param  target
     *         the object whose {@code run} method is invoked when this thread
     *         is started. If {@code null}, this classes {@code run} method does
     *         nothing.
     */
    public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {        
        	System.out.println(Thread.currentThread().getName()+" "+i);            
        }        
    }    
}

public class Demo {
    public static void main(String[] args) {
        //创建自定义类对象  线程任务对象
        MyRunnable mr = new MyRunnable();
        //创建线程对象
        Thread t = new Thread(mr, "小强");
        t.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("旺财 " + i);
        }
    }
}

方法一和方法二的异

方法1 是把线程和任务合并在了一起 耦合度更高，方法2 是把线程和任务分开了,耦合度更低,实际上使用了静态代理的设计模式

代理模式

1. 用 Runnable 更容易与线程池等高级 API 配合

2. 用 Runnable 让任务类脱离了 Thread 继承体系，更灵活

FutureTask配合Thread

				//创建任务对象
        FutureTask<Integer> futureTask = new FutureTask(() -> {
            log.debug("hello");
            return 100;
        });
        new Thread(futureTask, "t3").start();
        //主线程阻塞,同步等待task执行完毕的结果
        Integer result = futureTask.get();
        log.debug("结果是:{}",result);

线程运行的原理

栈与栈帧

public class TestFrames {
    public static void main(String[] args) {
        Thread t1 = new Thread(){
            @Override
            public void run() {
                method1(20);
            }
        };
        t1.setName("t1");
        t1.start();
        method1(10);
    }

    private static void method1(int x) {
        int y = x + 1;
        Object m = method2();
        System.out.println(m);
    }

    private static Object method2() {
        Object n = new Object();
        return n;
    }
}

Thread t1 = new Thread(() -> {
            log.debug(Thread.currentThread().getName());
            FileReader.read(Constants.MP4_FULL_PATH);
        }, "t1");
        t1.run();
        log.debug("do other things");

//output
//19:39:14 [main] c.TestStart - main
//19:39:14 [main] c.FileReader - read [1.mp4] start ...
//19:39:18 [main] c.FileReader - read [1.mp4] end ... cost: 4227 ms 19:39:18 [main] c.TestStart - do other things ...

线程上下文切换

• 线程的 cpu 时间片用完

• 垃圾回收

• 有更高优先级的线程需要运行

• 线程自己调用了 sleep、yield、wait、join、park、synchronized、lock 等方法

线程常用方法

start与run

/**
   * Causes this thread to begin execution; the Java Virtual Machine
   * calls the <code>run</code> method of this thread.
    * <p>
     * The result is that two threads are running concurrently: the
     * current thread (which returns from the call to the
     * <code>start</code> method) and the other thread (which executes its
     * <code>run</code> method).
     * <p>
     * It is never legal to start a thread more than once.
     * In particular, a thread may not be restarted once it has completed
     * execution.
     *
     * @exception  IllegalThreadStateException  if the thread was already
     *               started.
     * @see        #run()
     * @see        #stop()
		

  */
public synchronized void start() {
        /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
		    //判断线程是不是NEW状态
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
				//添加到线程组
        group.add(this);

        boolean started = false;
        try {
					  //调用操作系统的方法创建线程
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }
		
    private native void start0();

/**
     * If this thread was constructed using a separate
     * <code>Runnable</code> run object, then that
     * <code>Runnable</code> object's <code>run</code> method is called;
     * otherwise, this method does nothing and returns.
     * <p>
     * Subclasses of <code>Thread</code> should override this method.
     *
     * @see     #start()
     * @see     #stop()
     * @see     #Thread(ThreadGroup, Runnable, String)
     */
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }

Thread t1 = new Thread(() -> {
            log.debug(Thread.currentThread().getName());
            FileReader.read(Constants.MP4_FULL_PATH);
        }, "t1");
        t1.run();
        log.debug("do other things");

//output
//19:39:14 [main] c.TestStart - main
//19:39:14 [main] c.FileReader - read [1.mp4] start ...
//19:39:18 [main] c.FileReader - read [1.mp4] end ... cost: 4227 ms 19:39:18 [main] c.TestStart - do other things ...

//19:41:30 [main] c.TestStart - do other things ...
//19:41:30 [t1] c.TestStart - t1
//19:41:30 [t1] c.FileReader - read [1.mp4] start ...
//19:41:35 [t1] c.FileReader - read [1.mp4] end ... cost: 4542 ms

• 直接调用 run 是在主线程中执行了 run，没有启动新的线程

• 使用 start 是启动新的线程，通过新的线程间接执行 run 中的代码

sleep 与 yield

sleep

/**
     * Causes the currently executing thread to sleep (temporarily cease
     * execution) for the specified number of milliseconds, subject to
     * the precision and accuracy of system timers and schedulers. The thread
     * does not lose ownership of any monitors.
     *使当前正在执行的线程休眠（暂时停止执行）指定的毫秒数，取决于系统计时器和调度程序的精度和准确性。该线程不会失去任何监视器的所有权。
     */
    public static native void sleep(long millis) throws InterruptedException;

1. 调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）

2. 其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException

3. 睡眠结束后的线程未必会立刻得到执行

4. 建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性

@Slf4j(topic = "c.Test6")
public class Test6 {
    public static void main(String[] args) {
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        t1.start();
        log.debug("t1 state: {}", t1.getState());

        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.debug("t1 state: {}", t1.getState());
    }
}
//output
//15:49:39.196 c.Test6 [main] - t1 state: RUNNABLE
//15:49:39.718 c.Test6 [main] - t1 state: TIMED_WAITING

@Slf4j(topic = "c.Test7")
public class Test7 {

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                log.debug("enter sleep...");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    log.debug("wake up...");
                    e.printStackTrace();
                }
            }
        };
        t1.start();

        Thread.sleep(1000);
        log.debug("interrupt...");
        t1.interrupt();
    }
}

@Slf4j(topic = "c.Test8")
public class Test8 {

    public static void main(String[] args) throws InterruptedException {
        log.debug("enter");
        TimeUnit.SECONDS.sleep(1);
        log.debug("end");
//        Thread.sleep(1000);
    }
}

yield

/**
     * A hint to the scheduler that the current thread is willing to yield
     * its current use of a processor. The scheduler is free to ignore this
     * hint.
     *
     * <p> Yield is a heuristic attempt to improve relative progression
     * between threads that would otherwise over-utilise a CPU. Its use
     * should be combined with detailed profiling and benchmarking to
     * ensure that it actually has the desired effect.
     *
     * <p> It is rarely appropriate to use this method. It may be useful
     * for debugging or testing purposes, where it may help to reproduce
     * bugs due to race conditions. It may also be useful when designing
     * concurrency control constructs such as the ones in the
     * {@link java.util.concurrent.locks} package.

     */
    public static native void yield();

1. 调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态，然后调度执行其它线程

2. 具体的实现依赖于操作系统的任务调度器

@Slf4j(topic = "c.TestYield")
public class TestYield {
    public static void main(String[] args) {
        Runnable task1 = () -> {
            int count = 0;
            for (;;) {
                System.out.println("---->1 " + count++);
            }
        };
        Runnable task2 = () -> {
            int count = 0;
            for (;;) {
                Thread.yield();
                System.out.println("              ---->2 " + count++);
            }
        };
        Thread t1 = new Thread(task1, "t1");
        Thread t2 = new Thread(task2, "t2");
        t1.setPriority(Thread.MIN_PRIORITY);
        t2.setPriority(Thread.MAX_PRIORITY);
        t1.start();
        t2.start();
    }

}//t1线程调度的频率较高

设置线程的优先级(setPriority)

public final void setPriority(int newPriority) {
        ThreadGroup g;
        checkAccess();
        if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
            throw new IllegalArgumentException();
        }
        if((g = getThreadGroup()) != null) {
            if (newPriority > g.getMaxPriority()) {
                newPriority = g.getMaxPriority();
            }
            setPriority0(priority = newPriority);
        }
    }    
    /**
     * The minimum priority that a thread can have.
     */
    public final static int MIN_PRIORITY = 1;

   /**
     * The default priority that is assigned to a thread.
     */
    public final static int NORM_PRIORITY = 5;

    /**
     * The maximum priority that a thread can have.
     */
    public final static int MAX_PRIORITY = 10;

@Slf4j(topic = "c.Test9")
public class Test9 {

    public static void main(String[] args) {
        Runnable task1 = () -> {
            int count = 0;
            for (;;) {
                System.out.println("---->1 " + count++);
            }
        };
        Runnable task2 = () -> {
            int count = 0;
            for (;;) {
                System.out.println("              ---->2 " + count++);
            }
        };
        Thread t1 = new Thread(task1, "t1");
        Thread t2 = new Thread(task2, "t2");
        t1.setPriority(Thread.MIN_PRIORITY);
        t2.setPriority(Thread.MAX_PRIORITY);
        t1.start();
        t2.start();
    }
}
//t2获得cpu时间片较多,调度频率更高

join

@Slf4j(topic = "c.Test10")
public class Test10 {
    static int r = 0;
    public static void main(String[] args) throws InterruptedException {
        test1();
    }
    private static void test1() throws InterruptedException {
        log.debug("开始");
        Thread t1 = new Thread(() -> {
            log.debug("开始");
            sleep(1);
            log.debug("结束");
            r = 10;
        },"t1");
        t1.start();
       // t1.join(); 不执行此行代码最终打印r=0.执行后r=10
        log.debug("结果为:{}", r);
        log.debug("结束");
    }
}

@Slf4j(topic = "c.TestJoin")
public class TestJoin {
    static int r = 0;
    static int r1 = 0;
    static int r2 = 0;

    public static void main(String[] args) throws InterruptedException {
        test3();
    }

    public static void test3() throws InterruptedException {
        Thread t1 = new Thread(() -> {
            sleep(2);
            r1 = 10;
        });

        long start = System.currentTimeMillis();
        t1.start();

        // 线程执行结束会导致 join 结束
        log.debug("join begin");
        t1.join(3000);// t1线程2秒就运行结束了,所以只会阻塞2秒
        long end = System.currentTimeMillis();
        log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
        
        //output
        //20:12:30.096 c.TestJoin [main] - join begin
		//20:12:32.096 c.TestJoin [main] - r1: 10 r2: 0 cost: 2001
    }


    private static void test1() throws InterruptedException {
        log.debug("开始");
        Thread t1 = new Thread(() -> {
            log.debug("开始");
            sleep(1);
            log.debug("结束");
            r = 10;
        });
        t1.start();
        t1.join();
        log.debug("结果为:{}", r);
        log.debug("结束");
    }
    //output
    //20:14:57.897 c.TestJoin [main] - 开始
	//20:14:57.967 c.TestJoin [Thread-0] - 开始
	//20:14:58.968 c.TestJoin [Thread-0] - 结束
	//20:14:58.968 c.TestJoin [main] - 结果为:10
	//20:14:58.969 c.TestJoin [main] - 结束
}

	
		 public static void main(String[] args) throws InterruptedException {
        test2();
    }
    private static void test2() throws InterruptedException {
        Thread t1 = new Thread(() -> {
            sleep(1);
            r1 = 10;
        });
        Thread t2 = new Thread(() -> {
            sleep(2);
            r2 = 20;
        });
        t1.start();
        t2.start();
        long start = System.currentTimeMillis();
        log.debug("join begin");
        t2.join();
        log.debug("t2 join end");
        t1.join();
        log.debug("t1 join end");
        long end = System.currentTimeMillis();
        log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
        //output:
        //20:14:16.465 c.TestJoin [main] - join begin
	    //20:14:18.467 c.TestJoin [main] - t2 join end
		//20:14:18.467 c.TestJoin [main] - t1 join end
		//20:14:18.467 c.TestJoin [main] - r1: 10 r2: 20 cost: 2004
    }

interrupt

/*中断此线程。
如果此线程在调用Object类的wait() 、 wait(long)或wait(long, int)方法或join() 、 join(long) 、 join(long, int)被阻塞、 sleep(long)或sleep(long, int) ，此类的方法，则其中断状态将被清除并收到InterruptedException 。
如果此线程在InterruptibleChannel的 I/O 操作中被阻塞，则通道将关闭，线程的中断状态将被设置，并且线程将收到java.nio.channels.ClosedByInterruptException 。
如果此线程在java.nio.channels.Selector被阻塞，则该线程的中断状态将被设置，并且它将立即从选择操作中返回，可能具有非零值，就像调用了选择器的wakeup方法一样。
如果前面的条件都不成立，则将设置此线程的中断状态。
中断一个不活跃的线程不需要有任何影响。
*/
public void interrupt() {
        if (this != Thread.currentThread())
            checkAccess();

        synchronized (blockerLock) {
            Interruptible b = blocker;
            if (b != null) {
                interrupt0();           // Just to set the interrupt flag
                b.interrupt(this);
                return;
            }
        }
        interrupt0();
    }

打断sleep,wait,join的线程

@Slf4j(topic = "c.Test11")
public class Test11 {

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            log.debug("sleep...");
            try {
                Thread.sleep(5000); // wait, join
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t1");

        t1.start();
        Thread.sleep(1000);
        log.debug("interrupt");
        t1.interrupt();
        log.debug("打断标记:{}", t1.isInterrupted());
    }
}
//output
20:18:56.791 c.Test11 [t1] - sleep...
20:18:57.789 c.Test11 [main] - interrupt
20:18:57.791 c.Test11 [main] - 打断标记:false //sleep ,wait,join会清除打断标记
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at cn.itcast.test.Test11.lambda$main$0(Test11.java:12)
	at java.lang.Thread.run(Thread.java:748)

打断正常运行的线程

@Slf4j(topic = "c.Test12")
public class Test12 {

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            while(true) {
                boolean interrupted = Thread.currentThread().isInterrupted();
                if(interrupted) {
                    log.debug("被打断了, 退出循环");
                    break;
                }
            }
        }, "t1");
        t1.start();

        Thread.sleep(1000);
        log.debug("interrupt");
        t1.interrupt();
    }
20:26:05.085 c.Test12 [main] - interrupt
20:26:05.093 c.Test12 [t1] - 被打断了, 退出循环

打断park线程

private static void test3() throws InterruptedException {
        Thread t1 = new Thread(() -> {
            log.debug("park...");
            LockSupport.park();
            log.debug("unpark...");
            log.debug("打断状态：{}", Thread.currentThread().isInterrupted());
            LockSupport.park();
            log.debug("unpark...");
        }, "t1");
        t1.start();
        sleep(1);
        t1.interrupt();
    }
// output
// 21:36:29.443 c.Test14 [t1] - park...
// 21:36:30.441 c.Test14 [t1] - unpark...
// 21:36:30.441 c.Test14 [t1] - 打断状态：true
// 21:36:30.442 c.Test14 [t1] - unpark...

private static void test4() {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                log.debug("park...");
                LockSupport.park();
                log.debug("打断状态：{}", Thread.interrupted());
                LockSupport.park();
                log.debug("unpark...");
            }
        });
        t1.start();
        
        sleep(1);
        t1.interrupt();
    }
//
// 21:40:36.500 c.Test14 [Thread-0] - park...
// 21:40:37.499 c.Test14 [Thread-0] - 打断状态：true

一些过时不推荐的方法

两阶段终止

线程状态

五种状态(操作系统层面)

• 如果调用了阻塞API,如BIO读写文件,这时该线程实际不会用到CPU,会导致线程上下文切换,进入阻塞状态等BIO操作完毕,会由操作系统唤醒阻塞的线程,转换至可运行状态

• 与可运行状态的区别是,对阻塞状态的线程来说只要它们一直不唤醒,调度器就一直不会考虑调度它们

六种状态(Java API层面)

1. NEW: 线程刚被创建,但是还没有调用start()方法

2. RUNNABLE: 当调用了start()方法之后,
注意,JAVA API层面的RUNNABLE状态涵盖了操作系统层面的可运行状态,运行状态和阻塞状态(由于BIO导致的线程阻塞,在java里无法区分,仍然认为是可运行)

public class TestState2 {
    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            FileReader.read(Constants.MP4_FULL_PATH);
            FileReader.read(Constants.MP4_FULL_PATH);
            FileReader.read(Constants.MP4_FULL_PATH);
        }, "t1").start();

        Thread.sleep(1000);
        System.out.println("ok");
    }
}

3. BOLOCKEDWAITINGTIMED_WAITING都是java API层面对阻塞状态的细分

4. TERMINATED当线程代码运行结束

@Slf4j(topic = "c.TestState")
public class TestState {
    public static void main(String[] args) throws IOException {
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                log.debug("running...");
            }
        };

        Thread t2 = new Thread("t2") {
            @Override
            public void run() {
                while(true) { // runnable

                }
            }
        };
        t2.start();

        Thread t3 = new Thread("t3") {
            @Override
            public void run() {
                log.debug("running...");
            }
        };
        t3.start();

        Thread t4 = new Thread("t4") {
            @Override
            public void run() {
                synchronized (TestState.class) {
                    try {
                        Thread.sleep(1000000); // timed_waiting
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t4.start();

        Thread t5 = new Thread("t5") {
            @Override
            public void run() {
                try {
                    t2.join(); // waiting
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        t5.start();

        Thread t6 = new Thread("t6") {
            @Override
            public void run() {
                synchronized (TestState.class) { // blocked
                    try {
                        Thread.sleep(1000000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t6.start();

        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.debug("t1 state {}", t1.getState());
        log.debug("t2 state {}", t2.getState());
        log.debug("t3 state {}", t3.getState());
        log.debug("t4 state {}", t4.getState());
        log.debug("t5 state {}", t5.getState());
        log.debug("t6 state {}", t6.getState());
        System.in.read();
    }
}
//output
//19:31:36.992 c.TestState [t3] - running...
//19:31:37.479 c.TestState [main] - t1 state NEW
//19:31:37.497 c.TestState [main] - t2 state RUNNABLE
//19:31:37.497 c.TestState [main] - t3 state TERMINATED
//19:31:37.497 c.TestState [main] - t4 state TIMED_WAITING
//19:31:37.497 c.TestState [main] - t5 state WAITING
//19:31:37.497 c.TestState [main] - t6 state BLOCKED

public enum State {
        /**
         * Thread state for a thread which has not yet started.
         */
        NEW,

        /**
         * Thread state for a runnable thread.  A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         */
        RUNNABLE,

        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         */
        BLOCKED,

        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * <ul>
         *   <li>{@link Object#wait() Object.wait} with no timeout</li>
         *   <li>{@link #join() Thread.join} with no timeout</li>
         *   <li>{@link LockSupport#park() LockSupport.park}</li>
         * </ul>
         *
         * <p>A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called <tt>Object.wait()</tt>
         * on an object is waiting for another thread to call
         * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
         * that object. A thread that has called <tt>Thread.join()</tt>
         * is waiting for a specified thread to terminate.
         */
        WAITING,

        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         */
        TIMED_WAITING,

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         */
        TERMINATED;
    }

线程状态转换

NEW --> RUNNABLE

RUNNABLE <--> WAITING

• 调用 obj.wait() 方法时，t 线程从 RUNNABLE --> WAITING

• 调用 obj.notify() ， obj.notifyAll() ， t.interrupt() 时
• 竞争锁成功，t 线程从 WAITING --> RUNNABLE
• 竞争锁失败，t 线程从 WAITING --> BLOCKED
 
 

• 当前线程调用 t.join() 方法时，当前线程从 RUNNABLE --> WAITING
• 注意是当前线程在t 线程对象的监视器上等待

• t 线程运行结束，或调用了当前线程的 interrupt() 时，当前线程从 WAITING --> RUNNABLE

• 当前线程调用 LockSupport.park() 方法会让当前线程从 RUNNABLE --> WAITING

• 调用 LockSupport.unpark(目标线程) 或调用了线程 的 interrupt() ，会让目标线程从 WAITING --> RUNNABLE

RUNNABLE <--> BLOCKED

• t 线程用 synchronized(obj) 获取对象锁时如果竞争失败，从 RUNNABLE --> BLOCKED

• 持 obj 锁线程的同步代码块执行完毕，会唤醒该对象上所有 BLOCKED 的线程重新竞争，如果其中 t 线程竞争 成功，从 BLOCKED --> RUNNABLE ，其它失败的线程仍然 BLOCKED

RUNNABLE <--> TERMINATED