多个线程在并发执行的时候,他们在CPU中是随机切换执行的,这个时候我们想多个线程一起来完成一件任务,这个时候我们就需要线程之间的通信了,多个线程一起来完成一个任务,线程通信一般有4种方式:
- 通过 volatile 关键字
- 通过 Object类的 wait/notify 方法
- 通过 condition 的 await/signal 方法
- 通过 join 的方式
现在有一个问题,两个线程分别打印字符串,但是当线程A每输出两次的时候,线程B就输出一次,如此反复10次。
通过 volatile 关键字
通过 volatile
关键字来实现这个任务,这个也是最简单的一种实现方式,大致思路 volatile 是共享内存的,两个线程共享一个标志位,当标志位更改的时候就执行不同的线程。
public class VolatileDemo { private static volatile boolean flag = true; //定义一个标志位,当标志位更改的时候不同的线程被执行 public static void main(String[] args) { //线程A启动 new Thread(() -> { int i = 0; while(true){ //进行死循环,一直输出语句 if (flag){ //对标志位的判断,符合就执行 System.out.println(Thread.currentThread().getName()+" ===>" + ++i); //输出语句 if (i%2==0){ //如果语句输出两次了 改变标志位 flag =false; } if (i == 10) break; //到达十次,结束循环 } } }, "A").start(); new Thread(() -> { int i = 0; while(true){ if (!flag){ //判断条件不一样 System.out.println(Thread.currentThread().getName()+" 被唤醒啦 " + ++i); flag = true; //改变标志位 if (i == 5) break; } } }, "B").start(); }}
我们发现我们这个位置用的while循环的,用for循环指定次数可以吗,是不可以的,因为我们只是改变了标志位,但是并没有立刻唤醒另外一个线程让他执行,虽然我打印的语句是我被唤醒了,但是实际上只是线程A处于死循环,啥子也不做,直到线程B抢到了时间片,进行对标志位的判断,然后输出语句,在进行空循环,等待A抢到时间片,如此反复,可以自己在if判断外面加一条计数语句,来验证一下结果,如果想要立刻唤醒的话,那么就是另外一种方法啦。
通过 Object类的 wait/notify 方法
对于上面的volatile关键字这个方法来说,我们的线程执行了很多次空循环,来等待另外一个线程来获取锁,这种操作无疑是十分消耗CPU的资源的,所以说为了解决这种情况,我们就需要一种机制可以实现线程之间的通信,可以唤醒其他的线程,而不是等待直到自己获取CPU的时间片,我们都知道,Object类提供了三个线程间通信的方法,wait(),notify(),notifyAll()。这三个方法必须都在同步代码块中执行的。
方法名 | 具体操作 |
---|---|
wait() | wait()方法执行前,是必须要获得对应的锁的,当执行wait()方法后,线程就会释放掉自己所占有的锁,释放CPU,然后进入阻塞状态,直到被notify()方法唤醒。 |
notify() | 会唤醒一个处于等待该对象锁的线程,然后继续往下执行,直到执行完退出对象锁锁住的区域(synchronized修饰的代码块)后再释放锁。 |
notifyAll() | 和notify()方法差不多,只不过他是唤醒所有等待该对象锁的线程,让他们进入就绪队列,但是谁执行就看谁抢占到CPU,notify()方法也是这样,只不过是唤醒随机的一个而已 |
每个锁对象都有两个队列,一个是就绪队列,一个是阻塞队列。就绪队列存储了已就绪(将要竞争锁)的线程,阻塞队列存储了被阻塞的线程。当一个阻塞线程被唤醒后,才会进入就绪队列,进而等待CPU的调度;反之,当一个线程被wait后,就会进入阻塞队列,等待被唤醒。
public class WaitAndNotify { public static void main(String[] args) { Object lock = new Object(); //创建一个锁对象 new Thread(() -> { for (int i = 1; i <= 10; i++) { synchronized (lock) { //首先需要获取锁 System.out.println(Thread.currentThread().getName() + " ==> " + i); if (i % 2 == 0) { lock.notify(); //唤醒线程B if (i!=10){try { lock.wait(); //让自己等待} catch (InterruptedException e) { e.printStackTrace();} } } } } }, "A").start(); new Thread(() -> { for (int i = 1; i <= 5; i++) { synchronized (lock) { lock.notify(); //我们看到,执行notify方法时,后面的代码还是执行了,并不是立刻释放资源 System.out.println(Thread.currentThread().getName() + "我执行了notify方法 " + i); if (i!=5){ try {lock.wait(); } catch (InterruptedException e) {e.printStackTrace(); } } } } }, "B").start(); }}
好的,通过上面的代码我们发现,当执行notify方法时,我们并不会立刻释放锁资源,而是在执行完我们代码块里面的内容时才会释放掉锁资源,而wait()方法则会立刻释放掉锁资源,进入阻塞状态,这里我们有举例子,可以自己在wait()方法后面加上一个输出语句。我们进行交替通信的规则就是,执行wait()方法,释放掉锁资源,然后执行 notify() 方法,唤醒其他的线程,在代码中,我在wait()方法上加了一个判断,如果是最后一次的话,那么我就不执行,为什么,因为我在执行wait()方法的时候,那么线程除非被唤醒,否则就会一直阻塞,这样的话我们的demo就不可以结束了,一直处于允许状态。
通过 condition 的 await/signal 方法
Condiction对象是通过lock对象来创建得(调用lock对象的newCondition()方法),他在使用前也是需要获取锁得,其中,Lock 替代了 synchronized 方法和语句的使用,Condition 替代了 Object 监视器方法的使用。Condiction对象得常用方法:
- await() : 线程自主释放锁,进入沉睡状态,直到被再次唤醒。
- await(long time, TimeUnit unit) :线程自主释放锁,进入沉睡状态,被唤醒或者未到达等待时间时一直处于等待状态。
- signal(): 唤醒一个等待线程。
- signal()All() :唤醒所有等待线程,能够从等待方法返回的线程必须获得与Condition相关的锁。
public static void main(String[] args) { //设置一个锁 Lock lock = new ReentrantLock(); Condition condition = lock.newCondition(); AtomicInteger number = new AtomicInteger(1); AtomicInteger count = new AtomicInteger(1); new Thread(()->{ while (count.get() != 10){ lock.lock(); try { count.getAndIncrement(); if (number.get() != 1 && count.get() != 11){ condition.await(); } number.getAndIncrement(); System.out.println(Thread.currentThread().getName() + "---> 生产"); condition.signalAll(); }catch (Exception e){ e.printStackTrace(); }finally { lock.unlock(); } } },"producter").start(); new Thread(()->{ while (count.get() != 10 ){ lock.lock(); try { count.getAndIncrement(); if (number.get() != 2 && count.get() != 11){ condition.await(); } number.getAndDecrement(); System.out.println(Thread.currentThread().getName() + "---> 消费"); condition.signalAll(); }catch (Exception e){ e.printStackTrace(); }finally { lock.unlock(); } } },"customer").start(); }
await操作会立刻释放掉锁,进入阻塞状态,singal会唤醒等待队列中的头节点(失败就依次唤醒)。这个代码逻辑有大问题,只是这样写看得出数据之间的交换即可。注意点:代码一定要在lock和unlock之间。
通过 join 方法来实现线程通信
public static void main(String[] args) throws InterruptedException { Thread A = new Thread(() -> { System.out.println("执行完毕"); },"A"); Thread B = new Thread(()->{ try { Thread.sleep(1000L); System.out.println(Thread.currentThread().getName() + "测试join"); } catch (InterruptedException e) { e.printStackTrace(); } },"B"); A.start(); B.start(); B.join(); System.out.println("Main线程"); }
简单来说,就是join方法会让自己提前执行,比如上面的例子中就是让Main线程阻塞了,等待B线程执行完毕后才会执行。本质就是调用了wait方法,让当前线程阻塞,直到另一个线程执行完毕。(当前线程wait后,执行join方法的线程大概率抢到锁资源,而且当一个线程执行完毕后,会默认调用notifyAll方法。)
小结
其实准确来说,应该只有三种可以通信的方式,join只是让当前线程先执行完,并没有说根据两个线程之间数据的共享。而且这个写的太粗糙了,每一个里面其实还有很多其他的内容,比如AQS队列,volatile关键字等,懒是无敌的,感谢mmmmmm?额
的评论,让我想起了这个还没写完,拖了巨久。
来源地址:https://blog.csdn.net/weixin_43786099/article/details/119945831