文章目录

原理简单讲解
调用park()与unpark()
- park/unpark实现的伪代码
- park/unpark的实验
interrupt()与park()
- interrupt()实现的伪代码
- interrupt()实验
sleep()与interrupt()
- sleep()实现的伪代码
- sleep()实验
- wait/join 效果同sleep
总结

原理简单讲解

首先声明，本文不会去贴native方法的cpp实现，而是以伪代码的形式来理解这些native方法。

Thread对象的native实现里有一个成员代表线程的中断状态，我们可以认为它是一个bool型的变量。初始为false。
Thread对象的native实现里有一个成员代表线程是否可以阻塞的许可permit，我们可以认为它是一个int型的变量，但它的值只能为0或1。当为1时，再累加也会维持1。初始为0。

调用park()与unpark()

park/unpark实现的伪代码

下面将以伪代码的实现来说明park/unpark的实现。

park() {if(permit > 0) {permit = 0;return;}if(中断状态 == true) {return;}阻塞当前线程;  // 将来会从这里被唤醒if(permit > 0) {permit = 0;}
}

可见，只要permit为1或者中断状态为true，那么执行park就不能够阻塞线程。park只可能消耗掉permit，但不会去消耗掉中断状态。

unpark(Thread thread) {if(permit < 1) {permit = 1;if(thread处于阻塞状态)唤醒线程thread;}
}

unpark一定会将permit置为1，如果线程阻塞，再将其唤醒。从实现可见，无论调用几次unpark，permit只能为1。

park/unpark的实验

public class test3 {public static void main(String[] args) throws InterruptedException {LockSupport.park();  //因为此时permit为0且中断状态为false，所以阻塞}
}

上面程序执行后，程序不会运行结束，main线程阻塞。
原因是，线程默认的permit是0，中断状态为false，所以会阻塞当前线程;。

public class test3 {public static void main(String[] args) throws InterruptedException {LockSupport.unpark(Thread.currentThread());  //置permit为1LockSupport.park();  //消耗掉permit后，直接返回了}
}

上面程序执行后，程序运行结束。
原因是LockSupport.unpark(Thread.currentThread())执行后，会使得main线程的permit为1。而park时发现这个permit为1时，就会消耗掉这个permit，然后直接返回，所以main线程没有阻塞。

public class test3 {public static void main(String[] args) throws InterruptedException {LockSupport.unpark(Thread.currentThread());LockSupport.park();  //消耗掉permit后，直接返回了LockSupport.park();  //此时permit为0，中断状态为false，必然会阻塞}
}

上面程序执行后，程序不会运行结束，main线程阻塞。
原因是第二次park时，permit为0了，中断状态为false，所以会阻塞当前线程;。

public class test3 {public static void main(String[] args){Thread main = Thread.currentThread();new Thread(new Runnable() {@Overridepublic void run() {System.out.println("子线程开始睡觉");try {Thread.sleep(1000);//睡一下保证是在main线程park后，才去unpark main线程} catch (InterruptedException e) {System.out.println(Thread.currentThread().getName()+"抛出了中断异常");}System.out.println("子线程睡醒了，开始unpark main线程");LockSupport.unpark(main);}}).start();LockSupport.park();  //此时permit为0，中断状态为false，必然会阻塞//被子线程unpark后，从上一句被唤醒，继续执行。此时permit还是为0，中断状态为false。LockSupport.park();  //此时permit为0，中断状态为false，必然会阻塞}
}

上面程序执行后，程序不会运行结束，main线程阻塞。
这个程序同上，只是之前的版本都是先unpark，再park。现在保证是，main线程先park后，再去unpark main线程。

interrupt()与park()

interrupt()实现的伪代码

interrupt(){if(中断状态 == false) {中断状态 = true;}unpark(this);    //注意这是Thread的成员方法，所以我们可以通过this获得Thread对象
}

interrupt()会设置中断状态为true。注意，interrupt()还会去调用unpark的，所以也会把permit置为1的。

interrupt()实验

public class test3 {public static void main(String[] args) throws InterruptedException {Thread.currentThread().interrupt();LockSupport.park();  //消耗掉permit后，直接返回了}
}

上面程序执行后，程序运行结束。因为park执行时permit为1，直接返回了。

public class test3 {public static void main(String[] args) throws InterruptedException {Thread.currentThread().interrupt();LockSupport.park();  //消耗掉permit后，直接返回了LockSupport.park();  //因为中断状态 == true，直接返回了LockSupport.park();  //同上}
}

上面程序执行后，程序运行结束。马上无论怎么park都无法阻塞线程了，因为此时线程的中断状态为true，函数直接返回了。

public class test3 {public static void main(String[] args) throws InterruptedException {Thread main = Thread.currentThread();new Thread(new Runnable() {@Overridepublic void run() {System.out.println("马上开始睡觉");try {Thread.sleep(1000);//睡一下保证是在main线程阻塞后，才去中断main线程} catch (InterruptedException e) {e.printStackTrace();}System.out.println("睡醒了，开始中断main线程");main.interrupt();}}).start();LockSupport.park();  //此时permit为0，中断状态为false，必然会阻塞//被子线程中断后，从上一句被唤醒，继续执行。此时permit为0，中断状态为true。LockSupport.park();  //因为中断状态 == true，直接返回了LockSupport.park();  //同上}
}

上面程序执行后，程序运行结束。
这个程序同上，只是之前的版本都是先中断，再park。现在保证是，main线程先阻塞后，再去中断main线程。

sleep()与interrupt()

sleep()实现的伪代码

sleep(){//这里我忽略了参数，假设参数是大于0的即可if(中断状态 == true) {中断状态 = false;throw new InterruptedException();}线程开始睡觉;   if(中断状态 == true) {中断状态 = false;throw new InterruptedException();}
}

sleep()会去检测中断状态，如果检测到了，那就消耗掉中断状态后，抛出中断异常。但sleep()不会去动permit。

sleep()实验

public class test3 {public static void main(String[] args){Thread.currentThread().interrupt();try {Thread.sleep(1000);  // 消耗掉中断状态后，抛出异常} catch (InterruptedException e) {e.printStackTrace();}}
}

上面程序执行后，抛出异常，程序运行结束。

public class test3 {public static void main(String[] args){Thread.currentThread().interrupt();try {Thread.sleep(1000);  // 消耗掉中断状态后，抛出异常} catch (InterruptedException e) {e.printStackTrace();}LockSupport.park();  //消耗掉permit}
}

上面程序执行后，抛出异常，程序运行结束。

public class test3 {public static void main(String[] args){Thread.currentThread().interrupt();try {Thread.sleep(1000);//消耗掉中断状态} catch (InterruptedException e) {e.printStackTrace();}LockSupport.park();  //消耗掉permitLockSupport.park();  //因为此时permit为0且中断状态为false，所以阻塞}
}

上面程序执行后，抛出异常，程序不会运行结束。

public class test3 {public static void main(String[] args){Thread main = Thread.currentThread();new Thread(new Runnable() {@Overridepublic void run() {System.out.println("子线程开始睡觉");try {Thread.sleep(3000);//睡一下保证是在main线程sleep后，才去中断main线程} catch (InterruptedException e) {System.out.println(Thread.currentThread().getName()+"抛出了中断异常");}System.out.println("子线程睡醒了，开始中断main线程");main.interrupt();}}).start();try {System.out.println("主线程开始睡觉");Thread.sleep(5000); //main线程开始睡觉// 当被中断唤醒后，会消耗掉中断状态。唤醒后继续执行} catch (InterruptedException e) {System.out.println(Thread.currentThread().getName()+"抛出了中断异常");}LockSupport.park();  //消耗掉permit后，直接返回了LockSupport.park();  //此时permit为0，中断状态为false，必然会阻塞}
}

上面程序执行后，抛出异常，程序不会运行结束。
这个程序同上，只是之前的版本都是先中断，再sleep。现在保证是，main线程先sleep后，再去中断main线程。

wait/join 效果同sleep

public class test3 {public static void main(String[] args){Thread.currentThread().interrupt();Object lock = new Object();synchronized (lock) {try {lock.wait();  //消耗掉中断状态} catch (InterruptedException e) {e.printStackTrace();}}LockSupport.park();  //消耗掉permitLockSupport.park();  //此时permit为0，中断状态为false，必然会阻塞}
}