1 线程中断机制

1.1 什么是中断？

• 首先
  一个线程不应该由其他线程来强制中断或停止，而是应该由线程自己自行停止。所以，Thread.stop, Thread.suspend, Thread.resume 都已经被废弃了。

• 其次
  在Java中没有办法立即停止一条线程，然而停止线程却显得尤为重要，如取消一个耗时操作。因此，Java提供了一种用于停止线程的机制——中断。

中断只是一种协作机制，Java没有给中断增加任何语法，中断的过程完全需要程序员自己实现。若要中断一个线程，你需要手动调用该线程的interrupt方法，该方法也仅仅是将线程对象的中断标识设成true；接着你需要自己写代码不断地检测当前线程的标识位，如果为true，表示别的线程要求这条线程中断，此时究竟该做什么需要你自己写代码实现。

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

1.2 中断的相关API方法

public void interrupt()	实例方法， 实例方法interrupt()仅仅是设置线程的中断状态为true，不会停止线程
public static boolean interrupted()	静态方法，Thread.interrupted(); 判断线程是否被中断，并清除当前中断状态 这个方法做了两件事： 1 返回当前线程的中断状态 2 将当前线程的中断状态设为false 这个方法有点不好理解，因为连续调用两次的结果可能不一样。
public boolean isInterrupted()	实例方法， 判断当前线程是否被中断（通过检查中断标志位）

1.3 面试题：如何使用中断标识停止线程？

在需要中断的线程中不断监听中断状态，一旦发生中断，就执行相应的中断处理业务逻辑。

中断只是一种协同机制，修改中断标识位仅此而已，不是立刻stop打断

中断线程方法:

1. 通过一个volatile变量实现

public class InterruptDemo
{
private static volatile boolean isStop = false;public static void main(String[] args)
{new Thread(() -> {while(true){if(isStop){System.out.println(Thread.currentThread().getName()+"线程------isStop = true,自己退出了");break;}System.out.println("-------hello interrupt");}},"t1").start();//暂停几秒钟线程try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }isStop = true;
}

2. 通过AtomicBoolean

public class StopThreadDemo
{private final static AtomicBoolean atomicBoolean = new AtomicBoolean(true);public static void main(String[] args){Thread t1 = new Thread(() -> {while(atomicBoolean.get()){try { TimeUnit.MILLISECONDS.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); }System.out.println("-----hello");}}, "t1");t1.start();try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }atomicBoolean.set(false);}
}

3. 通过Thread类自带的中断api方法实现

   public class InterruptDemo
   {public static void main(String[] args){Thread t1 = new Thread(() -> {while(true){if(Thread.currentThread().isInterrupted()){System.out.println("-----t1 线程被中断了，break，程序结束");break;}System.out.println("-----hello");}}, "t1");t1.start();System.out.println("**************"+t1.isInterrupted());//暂停5毫秒try { TimeUnit.MILLISECONDS.sleep(5); } catch (InterruptedException e) { e.printStackTrace(); }t1.interrupt();System.out.println("**************"+t1.isInterrupted());}
   }
   

1.4 线程中断总结

线程中断相关的方法：

• interrupt() 方法是一个实例方法
  它通知目标线程中断，也就是设置目标线程的中断标志位为true，中断标志位表示当前线程已经被中断了。

• isInterrupted()方法也是一个实例方法
  它判断当前线程是否被中断（通过检查中断标志位）并获取中断标志

• Thread类的静态方法interrupted()
  返回当前线程的中断状态(boolean类型)且将当前线程的中断状态设为false，此方法调用之后会清除当前线程的中断标志位的状态（将中断标志置为false了），返回当前值并清零置false

2. LockSupport

LockSupport是concurrent包中一个工具类，不支持构造，提供了一堆 static 方法，比如park(),unpark()等。

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

下面这句话，后面详细说
LockSupport中的park() 和 unpark() 的作用分别是阻塞线程和解除阻塞线程

使用了一种名为Permit（许可）的概念来做到阻塞和唤醒线程的功能，每个线程都有一个许可。

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

方式1：使用Object中的wait()方法让线程等待，使用Object中的notify()方法唤醒线程

/**** 1 正常程序演示** 以下异常情况：* 2 wait方法和notify方法，两个都去掉同步代码块后看运行效果*   2.1 异常情况*   Exception in thread "t1" java.lang.IllegalMonitorStateException at java.lang.Object.wait(Native Method)*   Exception in thread "t2" java.lang.IllegalMonitorStateException at java.lang.Object.notify(Native Method)*   2.2 结论*   Object类中的wait、notify、notifyAll用于线程等待和唤醒的方法，都必须在synchronized内部执行（必须用到关键字synchronized）。** 3 将notify放在wait方法前面*   3.1 程序一直无法结束*   3.2 结论*   先wait后notify、notifyall方法，等待中的线程才会被唤醒，否则无法唤醒*/
public class LockSupportDemo
{public static void main(String[] args)//main方法，主线程一切程序入口{Object objectLock = new Object(); //同一把锁，类似资源类new Thread(() -> {synchronized (objectLock) {try {objectLock.wait();} catch (InterruptedException e) {e.printStackTrace();}}System.out.println(Thread.currentThread().getName()+"\t"+"被唤醒了");},"t1").start();//暂停几秒钟线程try { TimeUnit.SECONDS.sleep(3L); } catch (InterruptedException e) { e.printStackTrace(); }new Thread(() -> {synchronized (objectLock) {objectLock.notify();}//objectLock.notify();/*synchronized (objectLock) {try {objectLock.wait();} catch (InterruptedException e) {e.printStackTrace();}}*/},"t2").start();}
}

小结：

• wait和notify方法必须要在同步块或者方法里面，且成对出现使用
• 先wait后notify才OK

方式2：使用JUC包中Condition的await()方法让线程等待，使用signal()方法唤醒线程

public class LockSupportDemo2
{public static void main(String[] args){Lock lock = new ReentrantLock();Condition condition = lock.newCondition();new Thread(() -> {lock.lock();try{System.out.println(Thread.currentThread().getName()+"\t"+"start");condition.await();System.out.println(Thread.currentThread().getName()+"\t"+"被唤醒");} catch (InterruptedException e) {e.printStackTrace();} finally {lock.unlock();}},"t1").start();//暂停几秒钟线程try { TimeUnit.SECONDS.sleep(3L); } catch (InterruptedException e) { e.printStackTrace(); }new Thread(() -> {lock.lock();try{condition.signal();} catch (Exception e) {e.printStackTrace();} finally {lock.unlock();}System.out.println(Thread.currentThread().getName()+"\t"+"通知了");},"t2").start();}
}

小结

• Condtion中的线程等待和唤醒方法之前，需要先获取锁
• 一定要先await后signal，不要反了

方式3：LockSupport类可以阻塞当前线程以及唤醒指定被阻塞的线程

LockSupport 主要API

阻塞 park() /park(Object blocker)

阻塞当前线程/阻塞传入的具体线程

调用LockSupport.park()时

permit默认是零，所以一开始调用park()方法，当前线程就会阻塞，直到别的线程将当前线程的permit设置为1时，park方法会被唤醒，
然后会将permit再次设置为零并返回。

唤醒 unpark(Thread thread)

LockSupport.unpark(thread);

调用unpark(thread)方法后，就会将thread线程的许可permit设置成1(注意多次调用unpark方法，不会累加，permit值还是1)会自动唤醒thread线程，即之前阻塞中的LockSupport.park()方法会立即返回。

public class LockSupportDemo3
{public static void main(String[] args){//正常使用+不需要锁块Thread t1 = new Thread(() -> {System.out.println(Thread.currentThread().getName()+" "+"1111111111111");LockSupport.park();System.out.println(Thread.currentThread().getName()+" "+"2222222222222------end被唤醒");},"t1");t1.start();//暂停几秒钟线程try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }LockSupport.unpark(t1);System.out.println(Thread.currentThread().getName()+"   -----LockSupport.unparrk() invoked over");}
}

之前错误的先唤醒后等待，LockSupport照样支持

public class T1
{public static void main(String[] args){Thread t1 = new Thread(() -> {try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }System.out.println(Thread.currentThread().getName()+"\t"+System.currentTimeMillis());LockSupport.park();System.out.println(Thread.currentThread().getName()+"\t"+System.currentTimeMillis()+"---被叫醒");},"t1");t1.start();try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }LockSupport.unpark(t1);System.out.println(Thread.currentThread().getName()+"\t"+System.currentTimeMillis()+"---unpark over");}
}

2.2 小结一下，LockSupport比Object的wait/notify有两大优势：

1. LockSupport不需要在同步代码块里 。所以线程间也不需要维护一个共享的同步对象了，实现了线程间的解耦。
2. unpark函数可以先于park调用，所以不需要担心线程间的执行的先后顺序。
3. LockSupport原理

2.3 LockSupport原理

看源码，park和unpark都是直接调用了Unsafe的方法

 public static void park() {UNSAFE.park(false, 0L);}public static void unpark(Thread var0) {if (var0 != null) {UNSAFE.unpark(var0);}}    

Unsafe源码也相对简单，看下就行了：

void
sun::misc::Unsafe::unpark (::java::lang::Thread *thread)
{natThread *nt = (natThread *) thread->data;nt->park_helper.unpark ();
}void
sun::misc::Unsafe::park (jboolean isAbsolute, jlong time)
{using namespace ::java::lang;Thread *thread = Thread::currentThread();natThread *nt = (natThread *) thread->data;nt->park_helper.park (isAbsolute, time);
}

2.4 小结

多次调用unpark方法和调用一次unpark方法效果一样，因为都是直接将_counter赋值为1，而不是加1。简单说就是：线程A连续调用两次LockSupport.unpark(B)方法唤醒线程B，然后线程B调用两次LockSupport.park()方法， 线程B依旧会被阻塞。因为两次unpark调用效果跟一次调用一样，只能让线程B的第一次调用park方法不被阻塞，第二次调用依旧会阻塞。

3. Java内存模型之JMM

参考 万字总结什么是JMM、内存屏障及其原理

4. CAS

源码级别的讲解JAVA 中的CAS

5. 聊聊ThreadLocal

ThreadLocal 源码级别详解

6. Java对象内存布局和对象头

Java对象内存布局及对象头详解

7. Synchronized与锁升级

史上最详细JUC教程之Synchronized与锁升级详解

8. AbstractQueuedSynchronizer之AQS

谈谈Java多线程离不开的AQS