#yyds干货盘点#线程通信
Posted 周杰伦本人
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了#yyds干货盘点#线程通信相关的知识,希望对你有一定的参考价值。
线程通信
volatile和synchronized关键字
任意线程对Object(Object由synchronized保护)的访问,首先要获得Object的监视器。如果获取失败,线程进入同步队列,线程状态变为BLOCKED。当访问Object的前驱(获得了锁的线程)释放了锁,则该释放操作唤醒阻塞在同步队列中的线程,使其重新尝试对监视器的获取。
等待/通知机制
notify():通知一个在对象上等待的线程,使其从 wait()方法返回,而返回的前提是该线程获取到了对象的锁
notifyAll():通知所有等待该对象上的线程
wait():调用该方法的线程进入 WAITING状态,只有等待另外线程的通知或被中断才会返回,需要注意,调用wait0方法后,会释放对象的锁
wait(long):超时等待一段时间,这里的参数时间是毫秒,也就是等待长达n毫秒,如果没有通知就超时返回
wait(long,int):对于超时时间更细粒度的控制,可以达到纳秒
package com.example.xppdemo.chapter4;
import com.example.xppdemo.chapter4.SleepUtils;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;
public class WaitNotify
static boolean flag = true;
static Object lock = new Object();
public static void main(String[] args) throws Exception
Thread waitThread = new Thread(new Wait(), "WaitThread");
waitThread.start();
TimeUnit.SECONDS.sleep(1);
Thread notifyThread = new Thread(new Notify(), "NotifyThread");
notifyThread.start();
static class Wait implements Runnable
public void run()
// 加锁,拥有lock的Monitor
synchronized (lock)
// 当条件不满足时,继续wait,同时释放了lock的锁
while (flag)
try
System.out.println(Thread.currentThread() + " flag is true. wait @ "
+ new SimpleDateFormat("HH:mm:ss").format(new Date()));
lock.wait();
catch (InterruptedException e)
// 条件满足时,完成工作
System.out.println(Thread.currentThread() + " flag is false. running @ " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
static class Notify implements Runnable
public void run()
// 加锁,拥有lock的Monitor
synchronized (lock)
// 获取lock的锁,然后进行通知,通知时不会释放lock的锁,
// 直到当前线程释放了lock后,WaitThread才能从wait方法中返回
System.out.println(Thread.currentThread() + " hold lock. notify @ " +
new SimpleDateFormat("HH:mm:ss").format(new Date()));
lock.notifyAll();
flag = false;
SleepUtils.second(5);
// 再次加锁
synchronized (lock)
System.out.println(Thread.currentThread() + " hold lock again. sleep @ " + new SimpleDateFormat(" HH: mm: ss ").format(new Date()));
SleepUtils.second(5);
结果:
Thread[WaitThread,5,main] flag is true. wait @ 20:03:13
Thread[NotifyThread,5,main] hold lock. notify @ 20:03:14
Thread[NotifyThread,5,main] hold lock again. sleep @ 20: 03: 19
Thread[WaitThread,5,main] flag is false. running @ 20:03:24
WaitThread首先获取了对象的锁,然后调用对象的wait()方法,从而放弃了锁并进入了对象的等待队列WaitQueue中,进入等待状态。由于WaitThread释放了对象的锁,NotifyThread随后获取了对象的锁,并调用对象的notify()方法,将WaitThread从WaitQueue移到同步队列SynchronizedQueue中,此时WaitThread的状态变为阻塞状态。NotifyThread释放了锁之后,WaitThread再次获取到锁并从wait()方法返回继续执行。
1)使用wait()、notify()和notifyAll()时需要先对调用对象加锁。
2)调用wait()方法后,线程状态由RUNNING变为WAITING,并将当前线程放置到对象的等待队列。
3)notify()或notifyAll()方法调用后,等待线程依旧不会从wait()返回,需要调用notify()或notifAll()的线程释放锁之后,等待线程才有机会从wait()返回。
4)notify()方法将等待队列中的一个等待线程从等待队列中移到同步队列中,而notifyAll()方法则是将等待队列中所有的线程全部移到同步队列,被移动的线程状态由WAITING变为BLOCKED。
5)从wait()方法返回的前提是获得了调用对象的锁。
等待方模板:
synchronized(对象)
while(条件不满足)
对象.wait();
对应的处理逻辑
1)获取对象的锁。
2)如果条件不满足,那么调用对象的wait()方法,被通知后仍要检查条件。
3)条件满足则执行对应的逻辑。
对应的伪代码如下。
通知方
synchronized(对象)
改变条件
对象.notifyAll();
1)获得对象的锁。
2)改变条件。
3)通知所有等待在对象上的线程。
wait与sleep区别:
在调用wait方法时,线程必须要持有被调用对象的锁,当调用wait方法后,线程就会释放掉该对象的锁。
调用Thread类的sleep方法时,线程是不会释放对象的锁的。
wait notify notifyAll方法总结:
- 当调用wait时,首先确保wait方法的线程已经持有对象的锁。
- 当调用wait后,该线程就会释放这个对象的锁,然后进入等待队列
- 当线程调用了wait后进入等待队列时,它可以等待其他线程调用相同对象的notify或者notifyAll来唤醒自己
- 线程被其他线程唤醒后,该线程就会与其他线程一同开始竞争这个对象的锁;只有当线程获取到这个锁后,线程才会继续往下执行。
- 调用wait方法的代码片段需要放在一个synchronized块或者synchronized方法中,这样才能确保线程在调用wait方法前已经获取到锁了
- 调用notify方法时,它会唤醒该对象等待队列中的任意一个线程,当某个线程被唤醒后,与其他线程一起竞争对象的锁。
- 调用notifyAll方法,唤醒等待队列的所有线程,这些线程被唤醒后,又会开始竞争对象的锁。
- 某个时刻,只有一个线程可以拥有对象的锁。
Thread.join()
一个线程A执行了thread.join()语句,其含义是:当前线程A等待thread线程终止之后才从thread.join()返回。线程Thread除了提供join()方法之外,还提供了join(long
millis)和join(longmillis,int nanos)两个具备超时特性的方法。这两个超时方法表示,如果线程thread在给定的超时时间里没有终止,那么将会从该超时方法中返回。
当线程终止时,会调用线程自身的notifyAll()方法,会通知所有等待在该线程对象上的线程。
每个线程终止的前提是前驱线程的终止,每个线程等待前驱线程终止后,才从join()方法返回,
package com.example.xppdemo.chapter4;
import java.util.concurrent.TimeUnit;
public class Join
public static void main(String[] args) throws Exception
Thread previous = Thread.currentThread();
for (int i = 0; i < 10; i++)
// 每个线程拥有前一个线程的引用,需要等待前一个线程终止,才能从等待中返回
Thread thread = new Thread(new Domino(previous), String.valueOf(i));
thread.start();
previous = thread;
TimeUnit.SECONDS.sleep(5);
System.out.println(Thread.currentThread().getName() + " terminate.");
static class Domino implements Runnable
private Thread thread;
public Domino(Thread thread)
this.thread = thread;
public void run()
try
thread.join();
catch (InterruptedException e)
System.out.println(Thread.currentThread().getName() + " terminate.");
每个线程拥有前一个线程的引用,需要等待前一个线程终止,才能从等待中返回
Thread.join()源码:
public final synchronized void join(long millis)
throws InterruptedException
long base = System.currentTimeMillis();
long now = 0;
if (millis < 0)
throw new IllegalArgumentException("timeout value is negative");
if (millis == 0)
while (isAlive())
wait(0);
else
while (isAlive())
long delay = millis - now;
if (delay <= 0)
break;
wait(delay);
now = System.currentTimeMillis() - base;
当线程终止时,会调用线程自身的notifyAll()方法,会通知所有等待在该线程对象上的线程。可以看到join()方法的逻辑结构与等待/通知经典范式一致,即加锁、循环和处理逻辑3个步骤。
等待通知超时
// 对当前对象加锁
public synchronized Object get(long mills) throws InterruptedException
long future = System.currentTimeMillis() + mills;
long remaining = mills;
// 当超时大于0并且result返回值不满足要求
while ((result == null) && remaining > 0)
wait(remaining);remaining = future - System.currentTimeMillis();
return result;
调用一个方法时等待一段时间(一般来说是给定一个时间段),如果该方法能够在给定的时间段之内得到结果,那么将结果立刻返回,反之,超时返回默认结果。
ThreadLocal
ThreadLocal,即线程变量,是一个以ThreadLocal对象为键、任意对象为值的存储结构。这个结构被附带在线程上,也就是说一个线程可以根据一个ThreadLocal对象查询到绑定在这个线程上的一个值。
import java.util.concurrent.TimeUnit;
public class Profiler
// 第一次get()方法调用时会进行初始化(如果set方法没有调用),每个线程会调用一次
private static final ThreadLocal<Long> TIME_THREADLOCAL = new ThreadLocal<Long>()
protected Long initialValue()
return System.currentTimeMillis();
;
public static final void begin()
TIME_THREADLOCAL.set(System.currentTimeMillis());
public static final long end()
return System.currentTimeMillis() - TIME_THREADLOCAL.get();
public static void main(String[] args) throws Exception
Profiler.begin();
TimeUnit.SECONDS.sleep(1);
System.out.println("Cost: " + Profiler.end() + " mills");
在AOP(面向方面编程)中,可以在方法调用前的切入点执行begin()方法,而在方法调用后的切入点执行end()方法,这样依旧可以获得方法的执行耗时。
以上是关于#yyds干货盘点#线程通信的主要内容,如果未能解决你的问题,请参考以下文章
#yyds干货盘点# springboot配置@Async异步任务的线程池
#yyds干货盘点# RPCRESTGraphQL接口类型概述