【java 高并发编程之JUC】高阶JUC特性总结
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打断
中断线程方法:
- 通过一个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;
}
- 通过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);
}
}
-
通过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有两大优势：
- LockSupport不需要在同步代码块里 。所以线程间也不需要维护一个共享的同步对象了，实现了线程间的解耦。
- unpark函数可以先于park调用，所以不需要担心线程间的执行的先后顺序。
- 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