java线程中断 interrupt 和 LockSupport解析

public boolean isInterrupted() {  
    return isInterrupted(false);  
}
public static boolean interrupted() {  
    return currentThread().isInterrupted(true);  
}
//调用同一个方法，只是传参不同
private native boolean isInterrupted(boolean ClearInterrupted);

public class TestFlag {
    static volatile boolean flag = true;
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Runnable(){
            @Override
            public void run() {
                System.out.println("线程中断标志:"+Thread.currentThread().isInterrupted());
                while (flag){
                }
                System.out.println("标志flag为:" + flag);
                System.out.println("线程中断标志:"+Thread.currentThread().isInterrupted());
                System.out.println("我还在继续执行");
            }
        });
        t.start();
        Thread.sleep(100);
        flag = false;
        t.interrupt();
    }
}

public class TestInterrupt {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Runnable() {
            private int count = 0;
            @Override
            public void run() {
                try {
                    count = new Random().nextInt(1000);
                    count = count * count;
                    System.out.println("count:"+count);
                    Thread.sleep(5000);
                } catch (Exception e) {
                    System.out.println(Thread.currentThread().getName()+"线程第一次中断标志："+Thread.currentThread().isInterrupted());
                    //重新把线程中断状态设置为true，以便上层代码判断
                    Thread.currentThread().interrupt();
                    System.out.println(Thread.currentThread().getName()+"线程第二次中断标志："+Thread.currentThread().isInterrupted());
                }
            }
        });
        t.start();
        Thread.sleep(100);
        t.interrupt();
    }
}

public class LockSupportTest {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new ParkThread());
        t.start();
        Thread.sleep(100); //①
        System.out.println(Thread.currentThread().getName()+"开始唤醒阻塞线程");
        t.interrupt();
        System.out.println(Thread.currentThread().getName()+"结束唤醒");
    }
}
class ParkThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"开始阻塞");
        LockSupport.park();
        System.out.println(Thread.currentThread().getName()+"第一次结束阻塞");
        LockSupport.park();
        System.out.println("第二次结束阻塞");
    }
}

//LockSupportTest类
//原代码
t.interrupt();
//修改为
LockSupport.unpark(t);
LockSupport.unpark(t);

public class LockSyncTest {
    private static Object lock = new Object();
    //保存调用park的线程，以便后续唤醒
    private static Thread parkedThread;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
             synchronized (lock){
                 System.out.println("unpark前");
                 LockSupport.unpark(parkedThread);
                 System.out.println("unpark后");
             }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                //和t1线程用同一把锁时，park不会释放锁资源，若换成this锁，则会释放锁
                synchronized (lock){
                    System.out.println("park前");
                    parkedThread = Thread.currentThread();
                    LockSupport.park();
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("park后");
                }
            }
        });
        t2.start();
        Thread.sleep(100);
        t1.start();
    }
}
//打印结果
//park前