线程通信之等待机制

DougLiang

于 2024-08-30 09:04:10 发布

阅读量1.2k

点赞数 16

分类专栏：多线程文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/weixin_38121806/article/details/141703103

版权

多线程专栏收录该内容

9 篇文章 1 订阅

订阅专栏

线程通信之等待机制

线程之间的通信是指当某个线程修改了对象的值时。另外一个线程能够感知到该值变化并进行相应的操作。实现线程之间的通信方法如下：

基于volatile修饰的共享变量
通过wait/notify机制
Thread.join方法
使用synchronized同步关键字
Condition.await/signal方法

5.1 wait/notify

在Java中提供了wait/notify机制来实现多个线程之间的协同处理，也就是控制线程之间的等待和唤醒。wait()/notify()/notifyAll()属于Object对象中的方法，方法的功能说明如下：

wait()方法，使当前线程进入阻塞状态，并释放持有的锁(wait(0)相当于wait)
notofy()方法，唤醒处于阻塞状态下的一个线程
notifyAll()方法，唤醒处于阻塞状态下的所有线程

想要唤醒一个被Object.wait()方法阻塞的线程，有两种方法：

其他线程调用统一对象的notify()/notifyAll()方法
调用了该线程的interrupt()方法，被阻塞的线程被唤醒并且抛出InterruptException异常

5.1.1 wait()/notify()方法使用实战

wait()/notify()方法实际上是针对同一共享的对象的竞争来实现数据变更的通知，当某个共享变量满足某个条件时会触发阻塞和唤醒，从而实现线程的通信。

关于wait()/notify()方法设计的一个生产者/消费者模型

public class Producer implements Runnable{

    private final Queue<String> bags;
    private final int maxSize;

    public Producer(Queue<String> bags, int maxSize) {
        this.bags = bags;
        this.maxSize = maxSize;
    }

    @Override
    public void run() {

        int i = 0;
        while (true){
            i++;
            // 抢占锁
            synchronized (bags){
                if (bags.size() == maxSize){
                    System.out.println("bags 满了");
                    try {
                        // 当队列中满了之后，阻塞当前线程并释放Producer抢到的锁
                        bags.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("生产者生产： bag"+i);
                // 生产bag
                bags.add("bag"+i);
                // 表示当前已经生产了数据，提示消费者可以消费
                bags.notify();
            }
        }


    }
}

public class Consumer implements Runnable {

    private final Queue<String> bags;
    private final int maxSize;

    public Consumer(Queue<String> bags, int maxSize) {
        this.bags = bags;
        this.maxSize = maxSize;
    }

    @Override
    public void run() {
        while (true){
            synchronized (bags){
                if (bags.isEmpty()){
                    System.out.println("bags 空了");
                    try {
                        bags.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                String bag = bags.remove();
                System.out.println("消费者消费："+bag);
                bags.notify();
            }
        }
    }
}

public static void main(String[] args) throws InterruptedException {
    Queue<String>bags = new LinkedList<>();
    int maxSize = 2;
    Producer producer = new Producer(bags, maxSize);
    Consumer consumer = new Consumer(bags, maxSize);
    new Thread(producer).start();
    // 确保生产者先执行
    TimeUnit.SECONDS.sleep(1);
    new Thread(consumer).start();

}

5.1.2 wait()/notify()方法实现原理

wait()/notify()是基于ObjectMonitor实现，synchronized关键字中偏向锁是为重入设计，轻量级锁自旋实现，只有重量级锁是基于ObjectMonitor实现，所以wait()/notify()使用的锁必然是重量级锁。不明白的同学可以复习下synchronized那章内容。

5.1.3 wait()/notify()方法为什么要加同步锁？

wait()/notify()方法必须放在synchronized同步代码中，否者会抛出IllegalMonitorStateException的异常，之所以要加同步代码块，实际上是以下2个原因导致的：

wait()/notify()方法是基于一个共享对象来实现线程通信的，这意味着存在多个线程对该共享变量的竞争，为了保证原子性，需要加锁。
wait()/notify()方法需要实现现成的阻塞和唤醒，当某个线程调用notify唤醒时，要唤醒哪个线程？从哪里找？synchronized本身实现了同步队列机制(_cxp 保存的队列)，正好为wait/notify()方法正好提供了很好的协同机制。

只回答java中是这样规定的不加分的

**注：**之所以将wait()/notify()方法放到Object中，是因为Java中任何一个Object都关联了一个监视器对象，能够很好的实现同步锁机制

5.2 通过Thread.join获取线程执行结果

在应用程序中使用线程时，如果某段程序希望等待前面的线程执行结束后再执行，那么在并发编程中有很多方法可以实现，Thread.join（）就是其中的一个方法。

5.2.1 Thread.join()方法的执行流程

在这里插入图片描述

5.2.2 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()方法阻塞当前线程
            wait(0);
        }
    } else {
        while (isAlive()) {
            long delay = millis - now;
            if (delay <= 0) {
                break;
            }
            wait(delay);
            now = System.currentTimeMillis() - base;
        }
    }
}

调用了wait一定会调用notify()或者notifyall()才能唤醒，理论上join()方法是可以阻塞当前主线程，则应该是在当前调用join()方法这个线程终止之后才会触发唤醒的动作，而且这个唤醒的方法必然是在JVM层面实现。

void JavaThread::exit(bool destroy_vm, ExitType exit_type) {
  assert(this == JavaThread::current(),  "thread consistency check");
  // 省略部分代码

  // 重点关注ensure_join方法，在线程退出时调用
  ensure_join(this);
  assert(!this->has_pending_exception(), "ensure_join should have cleared");

 
// 省略部分代码
 
  Threads::remove(this);
}

static void ensure_join(JavaThread* thread) {
  // 不需要捕获Threads_lock，因为正在对自己进行操作。
  Handle threadObj(thread, thread->threadObj());
  assert(threadObj.not_null(), "java thread object must exist");
  ObjectLocker lock(threadObj, thread);
  // 忽略挂起异常(ThreadDeath)，因为正在退出
  thread->clear_pending_exception();
  // 线程正在退出。因此，将java.lang.Thread类中的thread_status字段设置为TERMINATED。
  java_lang_Thread::set_thread_status(threadObj(), java_lang_Thread::TERMINATED);
  // 清除本机线程实例——这使得isAlive返回false，并允许join()在完成下面的notify_all之后完成
  java_lang_Thread::set_thread(threadObj(), NULL);
  lock.notify_all(thread);
  // 忽略挂起异常(ThreadDeath)，因为正在退出
  thread->clear_pending_exception();
}

java_lang_Thread::set_thread(threadObj(), NULL);这行代码会使得isAlive()返回false

因此Thread.join（）方法本质依然是基于wait()/notify()方法来实现的。

5.3 J.U.C的条件控制Condition

5.3.1 Condition基本应用

public class ConditionExampleWait implements Runnable{

    private final Lock lock;

    private final Condition condition;

    public ConditionExampleWait(Lock lock, Condition condition) {
        this.lock = lock;
        this.condition = condition;
    }

    @Override
    public void run() {
        System.out.println("begin - ConditionExampleWait");

        lock.lock();
        try{
           condition.await();
            System.out.println("end - ConditionExampleWait");
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

public class ConditionExampleSignal implements Runnable {

    private final Lock lock;

    private final Condition condition;

    public ConditionExampleSignal(Lock lock, Condition condition) {
        this.lock = lock;
        this.condition = condition;
    }

    @Override
    public void run() {
        System.out.println("begin - ConditionExampleSignal");

        lock.lock();
        try{
            condition.signal();
            System.out.println("end - ConditionExampleSignal");
        } finally {
            lock.unlock();
        }
    }
}

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

    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    ConditionExampleWait conditionExampleWait = new ConditionExampleWait(lock, condition);
    ConditionExampleSignal conditionExampleSignal = new ConditionExampleSignal(lock, condition);

    new Thread(conditionExampleWait).start();
    TimeUnit.SECONDS.sleep(1);
    new Thread(conditionExampleSignal).start();

    Thread t1 = new Thread();
    t1.join();
}

注意:Condition condition = lock.newCondition();表示创建一个新的condition,这是与wait()/notify()方法最大的区别。Condition可以针对于不同的场景设置不同的Condition，并且可以通过condition.signal()唤醒指定的线程，这样做可以减少线程的无效竞争。

5.3.1 Condition源码分析

public final void await() throws InterruptedException {
    // 首先判断线程是否已经中断，中断直接抛出中断异常，抛出中断异常也会释放锁
    if (Thread.interrupted())
        throw new InterruptedException();
    // 创建一个新的节点，节点的状态为Condition，采用的数据结构依然是链表(链表为单向链表，且采用尾插法)
    Node node = addConditionWaiter();
    // 释放当前的锁，得到锁的状态，并且唤醒AQS队列中的一个线程
    int savedState = fullyRelease(node);
    // 设置一个中断标识的局部变量
    int interruptMode = 0;
    // 如果当前节点不在同步队列上，那么当前线程在等待队列上已维护完成
    while (!isOnSyncQueue(node)) {
        // 挂起当前线程---释放CPU时间片
        LockSupport.park(this);
        
        if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
            break;
    }
    //抢占到了锁，并且中断标识不是-1，
    if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
        // interruptMode 赋值为1
        interruptMode = REINTERRUPT;
    // 做一个清理的动作
    if (node.nextWaiter != null) 
        unlinkCancelledWaiters();
    
    if (interruptMode != 0)
        
        reportInterruptAfterWait(interruptMode);
}

// 等待队列中的最后一个等待者
private transient Node lastWaiter;
// 等待队列中的第一个等待者
private transient Node firstWaiter;
// AQS的头节点
private transient volatile Node head;
// AQS的尾节点
private transient volatile Node tail;
// AQS上一个节点
volatile Node prev;
// AQS下一个节点
volatile Node next;

/**
 *
 * 添加一个等待者到等待队列
 */
private Node addConditionWaiter() {
    Node t = lastWaiter;
    // 如果最后一个节点不为空，且waitStatus不是CONDITION状态，说明这个节点已经失效
    if (t != null && t.waitStatus != Node.CONDITION) {
        // 尝试清理失效的节点
        unlinkCancelledWaiters();
        // 重新获取最后一个节点
        t = lastWaiter;
    }
    // 创建一个且waitStatus为CONDITION的节点
    Node node = new Node(Thread.currentThread(), Node.CONDITION);
    // 维护等待队列的链表结构
    if (t == null)
        firstWaiter = node;
    else
        t.nextWaiter = node;
    lastWaiter = node;
    return node;
}

// 链式查找，从头结点往下找到尾结点为止，如果发现Node节点的且waitStatus状态不是CONDITION，就剔除当前的链表，在这个过程中，更新第一个节点和最后一个节点
private void unlinkCancelledWaiters() {
    Node t = firstWaiter;
    Node trail = null;
    while (t != null) {
        Node next = t.nextWaiter;
        if (t.waitStatus != Node.CONDITION) {
            t.nextWaiter = null;
            if (trail == null)
                firstWaiter = next;
            else
                trail.nextWaiter = next;
            if (next == null)
                lastWaiter = trail;
        }
        else
            trail = t;
        t = next;
    }
}

为什么建议：方法行数尽量不要太长，尽可能的通过局部变量来控制当前方法里的一些属性的变更。这个是受性能的影响，主要是在GC层面考虑性能

/**
 *
 * node:lastWaiter最后一个等待节点
 */
final int fullyRelease(Node node) {
    boolean failed = true;
    try {
        int savedState = getState();
        // 与之前讲AQS里的锁释放一样，即先释放锁资源，然后唤醒AQS队列中的一个线程(进入AQS才会被park)
        if (release(savedState)) {
            failed = false;
            return savedState;
        } else {
            throw new IllegalMonitorStateException();
        }
    } finally {
        if (failed)
            node.waitStatus = Node.CANCELLED;
    }
}

final boolean isOnSyncQueue(Node node) {
    // 如果第一次进来，那么此时的waitStatus一定是CONDITION
    if (node.waitStatus == Node.CONDITION || node.prev == null)
        return false;
    if (node.next != null) // If has successor, it must be on queue
        return true;
    return findNodeFromTail(node);
}

分析：condition.signal()方法应该要把等待队列中等待最久的节点（头结点）移动到AQS的CLH队列中之所以这么做，是因为当前线程仍然需要去竞争锁，如果不这么做，锁的排他性会被打破。

public final void signal() {
    // 如果当前线程不是独占状态，说明有问题
    if (!isHeldExclusively())
        // 非法的监视器状态异常
        throw new IllegalMonitorStateException();
    // 因为在添加的时候采用的是尾插法，所以在获取的时候采用的是从头部获取，符合先进先出FIFO
    Node first = firstWaiter;
    // 如果第一个等待节点不为空
    if (first != null)
        // 那么开始真正做事了。约定：对于纯粹的底层来说，所有真正执行的方法，一般以do开头。在编写业务代码时，为了避免与底层出现冲突，禁			 止使用do开头作为方法名
        doSignal(first);
}

// 判断当前线程是否是独占状态，也就是说当前线程有没有获取到锁
protected final boolean isHeldExclusively() {

    return getExclusiveOwnerThread() == Thread.currentThread();
}

private void doSignal(Node first) {
    do {
        if ( (firstWaiter = first.nextWaiter) == null)
            lastWaiter = null;
        first.nextWaiter = null;
        // 唤醒的动作
    } while (!transferForSignal(first) &&
             (first = firstWaiter) != null);
}

final boolean transferForSignal(Node node) {

    // 如果CAS失败，则说明当前节点状态为CANCELLED，此时需要继续查找等待队列中的下一个节点
    if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
        return false;

    // 通过enq方法将等待队列中要释放的节点移动到同步队列中
    Node p = enq(node);
    // 等待状态为p节点的waitStatus
    int ws = p.waitStatus;
    // 如果上一个节点的状态被取消，或者尝试设置上一个节点的状态为SIGNAL表示next节点需要停止阻塞
    // ws大于0 说明是CANCELLED状态
    if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
        // 唤醒输入节点的线程
        LockSupport.unpark(node.thread);
    return true;
}

private int checkInterruptWhileWaiting(Node node) {
    // Thread.interrupted()判断当前线程是否中断过，如果当前线程中断过，就调用transferAfterCancelledWait(node)
    return Thread.interrupted() ?
        (transferAfterCancelledWait(node) ? THROW_IE : REINTERRUPT) :
    0;
}

final boolean transferAfterCancelledWait(Node node) {
    
    // 同过CAS去更改节点状态，如果能够更改成功，则说明线程被中断时signal()方法还没有被调用
    if (compareAndSetWaitStatus(node, Node.CONDITION, 0)) {
        // 添加到AQS队列中
        enq(node);
        return true;
    }
    
    while (!isOnSyncQueue(node))
        // 让出当前的时间片给其他线程使用
        Thread.yield();
    return false;
}

THROW_IE(-1):在触发中断之前，singal()方法没有被调用，此时抛中断异常
REINTERRUPT(1)：在触发中断之前，singal()方法已经被调用，意味当前线程已经在同步队列中,再次触发中断标识
0：表示状态正常

private void reportInterruptAfterWait(int interruptMode)
    throws InterruptedException {
    // 在触发中断之前，singal()方法没有被调用，此时抛中断异常
    if (interruptMode == THROW_IE)
        throw new InterruptedException();
    // 在触发中断之前，singal()方法已经被调用，意味当前线程已经在同步队列中,再次触发中断标识
    else if (interruptMode == REINTERRUPT)
        selfInterrupt();
}