LockSupport与线程中断

什么是中断机制

首先一个线程应该有其他线程来强制中断，而应该有它自己自行中断，java提供了一种用于停止线程的协商机制-中断，即中断标识协商机制。

中断只是一种协商机制，java没有给中断增加任何语法，中断的过程完全需要我们自己实现，若是要中断一个线程，需要手动调用个该线程的interrupt方法，该方法也仅仅是将线程对象中的中断标识设成true;接着需要自己写代码不断的检测当前线程的标识位，如果为true，表示别的线程请求这条线程中断。

每个线程对象中都有一个中断标识位，用于表示线程是否被中断过；该标识位为true表示中断，为false表示未中断；通过调用线程对象的interrupt方法将该线程的标识位设置为true,可以在别的线程中调用，也可以在自己的线程中调用。 

interrupt() interrupted() isInterrupted()方法的区别

如何中断运行中的线程 

通过volatile变量实现

public class InterruptedDemo {

    static volatile boolean isStop =false;
    public static void main(String[] args) throws InterruptedException {
       new Thread(()->{
           while(true){
               if(isStop){
                   System.out.println("程序停止");
                   break;
               }
               System.out.println("我在运行中");
           }
       }).start();
        Thread.sleep(2000);
        new Thread(()->{
           isStop = true;
        }).start();
    }
}

通过AtomicBoolean实现

 static AtomicBoolean atomicBoolean =new AtomicBoolean(false);
    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            while(true){
                if(atomicBoolean.get()){
                    System.out.println("程序停止");
                    break;
                }
                System.out.println("我在运行中");
            }
        }).start();
        Thread.sleep(2000);
        new Thread(()->{
            atomicBoolean.set(true);
        }).start();
    }

通过Thread自带的api实现

  public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            while(true){
                if(Thread.currentThread().isInterrupted()){
                    System.out.println("程序停止");
                    break;
                }
                System.out.println("我在运行中");
            }
        });
        t1.start();
        Thread.sleep(2000);
        new Thread(()->{
           t1.interrupt();
        }).start();
    }

当对一个线程，调用interrupt()时

（1）如果线程处于正常活动状态，那么会将该线程的中断标识位设置为true,被设置中断标识位的线程将继续正常运行，不受影响。故调用interrupt()方法是不会中断线程。

private static void interrupt02() throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 300; i++) {
                System.out.println("-------------:" + i);
            }
            System.out.println("t1线程的中断标识：" + Thread.currentThread().isInterrupted());


        }, "t1");
        t1.start();
        System.out.println("================t1线程默认中断标识为"+t1.isInterrupted());
        Thread.sleep(2);
        t1.interrupt();
        System.out.println("------t1调用interrupt()后的中断标识"+t1.isInterrupted());
        Thread.sleep(2000);
        System.out.println("------t1调用2秒后的中断标识"+t1.isInterrupted());
    }

（2）如果线程处于被阻塞状态（例如调用sleep  wait join等方法） 在别的线程中调用当前线程的对象的interrupt()方法，那么线程的中断标识位被清除true变为false，将立即退出被阻塞状态，并抛出一个InterruptedException异常。
 

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            while (true){
                if(Thread.currentThread().isInterrupted()){
                    System.out.println("中断标志位"+Thread.currentThread().isInterrupted());
                    break;
                }
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Thread.currentThread.interrupt();
                    e.printStackTrace();
                }
                System.out.println("未中断======");
            }
        }, "t1");
        t1.start();
        Thread.sleep(2000);
        new Thread(()->{
            t1.interrupt();
        }).start();

    }

上述案例中sleep抛出InterruptExcetion后中断标识位置被清除，在catch中如果没调用interrupt()方法再将标识设置为true，程序会无限的循环下去。

Thread.interrupted()  判断线程是否被中断并清除当前中断状态

（1）返回当前线程的中断状态，测试当前线程是否已经被中断

（2）将当前线程的中断状态清除 并重新设为false, 清除线程的中断状态

 LockSupport是什么

park() 除非有许可证可用，否则禁用当前线程以进行线程调度。

unpark() 如果给定的线程尚不可用，则为其提供许可。

换句话  park unpark的作用是阻塞线程和接触阻塞线程

3中让线程等待和唤醒的方法

 方式1

 public static void main(String[] args) {
        Object object = new Object();
        new Thread(()->{
            synchronized (object){
                System.out.println(Thread.currentThread().getName()+"come in");
                try {
                    object.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"被唤醒");
            }
        },"t1").start();

        new Thread(()->{
            synchronized (object){
                object.notify();
                System.out.println(Thread.currentThread().getName()+"发出通知");
            }
        },"t2").start();
    }

wait和notify方法必须放在同步块或同步方法中  成对出现  先执行wait再执行notify

将notify放在wait之前，程序无法执行，无法唤醒

 public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
        new Thread(()->{
                lock.lock();
                System.out.println(Thread.currentThread().getName()+"come in");
            try {
                condition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"被唤醒");
            }).start();


        new Thread(()->{
                lock.lock();
                condition.signal();
                System.out.println(Thread.currentThread().getName()+"发出通知");
                lock.unlock();

        },"t2").start();

    }

在lock和unlock对里面才能使用condtion线程等待和线程唤醒

LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。

LockSupport类使用了一种名为Permit（许可）的概念来做阻塞和唤醒线程功能，每个线程都有一个许可，但与Semaphore不同的是 许可的累加上限是1。

permit许可证默认没有不能放行，所以一开始调park方法当前线程就阻塞，直到别的线程给当前线程的发放permit,park方法才会被唤醒。

调用unpark(thread)方法后，就会thread线程的许可证permit发放，自动唤醒park线程，即之前阻塞中的LockSupport.park方法会立即返回。

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

        Thread t1 = new Thread(()->{

            System.out.println(Thread.currentThread().getName()+"come in");
            LockSupport.park();
            System.out.println(Thread.currentThread().getName()+"被唤醒");
        });
        t1.start();
        Thread.sleep(1000);

        new Thread(()->{
            LockSupport.unpark(t1);
            System.out.println(Thread.currentThread().getName()+"发出通知");


        },"t2").start();

    }

当调用park方法时，如果有凭证，则会直接消耗掉这个凭证然后正常退出，如果无凭证，就必须阻塞等待凭证许可，而unpark则相反，它会增加一个凭证，但凭证最多只能有1个，累加无效。