Java多线程_11 线程通信

---

线程通信机制

什么是线程通信

线程间同步可以归纳为线程间通信的一个子集，对于线程通信指的是两个线程之间可以交换一些实时的数据信息。

为什么需要线程通信

线程是操作系统中独立的个体，但这些个体如果不经过特殊的处理就不能称为一个整体，线程间通信就成为整体的必用方式之一。

当线程存在通信指挥，系统间的交互性会更强大，在提高CPU利用率的同时还会使开发人员对线程任务的处理过程中进行有效的把控和监督。

实现线程通信的方式

wait/notify

这两个方法都是Object类的方法，也就是说Java所有对象都提供了这两个方法。

• 等待/通知机制，是指线程A调用了对象的wait()方法进入等待状态，而线程B调用了对象的notify()或notifyAll()方法，线程A收到通知后退出等待队列，进入可运行状态，进而执行后续操作。
• 从功能上来说wait就是说线程在获取对象锁后，主动释放对象锁，同时本线程休眠。直到有其它线程调用对象的notify()唤醒该线程，才能继续获取对象锁，并继续执行。

例子：线程计算1-100之间的和，算好后马上通知主线程获取计算的和

/**
 * @Author: 凤文  沈阳医学院2019级医学信息工程 0213
 * @CreateTime: 2021/12/25 12:16
 * @Description: 线程之间的通信
 */
public class SumThread extends Thread {
    private int sum = 0;

    @Override
    public void run() {
        synchronized (this) {
            for (int i = 1; i <= 100; i++) {
                sum += i;
            }
            //当该线程计算完sum（执行上面的代码）立即通知唤醒
            this.notify();
        }
    }

    public int getSum() {
        return sum;
    }
}

/**
 * @Author: 凤文  沈阳医学院2019级医学信息工程 0213
 * @CreateTime: 2021/12/25 12:28
 * @Description: 子线程计算1-100之间的和，算好后马上通知主线程获取计算的和
 * wait()和notify()是Object的方法，即所有对象都有的
 * wait()和notify()是匹配的，一旦线程被wait()阻塞，一定要notify()唤醒线程
 */
public class Test {
    public static void main(String[] args) {
        SumThread st = new SumThread();
        st.start();
        synchronized (st){
            System.out.println(Thread.currentThread().getName()+"线程被阻塞。。。");
            try {
                //阻塞当前线程并释放锁
                st.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName()+"线程收到的值为："+st.getSum());
    }
}

Lock和Condition

Java 5提供了Lock机制，同时还有处理Lock机制的通信控制的Condition接口。

• Lock用于控制多线程对需要竞争的共享资源的顺序访问，保证该状态的连续性。
• Condition是Java提供的来实现等待/通知的类，Condition对象是由Lock对象所创建的。
• Conditon中的await()方法相当于Object的wait()方法，Condition中的signal()方法相当于Object的notify()方法。

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

/**
 * @Author: 凤文  沈阳医学院2019级医学信息工程 0213
 * @CreateTime: 2021/12/25 14:05
 * @Description:
 */
public class UserThread extends Thread{
    private Lock lock;

    private Condition condition;

    private int sum = 0;

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

    @Override
    public void run() {
        lock.lock();
        for (int i = 1; i <= 100; i++) {
            sum += i;
        }
        condition.signal();
        lock.unlock();
    }

    public int getSum(){
        return this.sum;
    }
}

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @Author: 凤文  沈阳医学院2019级医学信息工程 0213
 * @CreateTime: 2021/12/25 14:08
 * @Description: Condition
 */
public class Test {
    public static void main(String[] args) {
        //创建锁
        Lock lock = new ReentrantLock();
        //监听器
        Condition condition = lock.newCondition();

        UserThread u = new UserThread(lock, condition);
        u.start();
        lock.lock();
        System.out.println(Thread.currentThread().getName() + "-->被阻塞");

        try {
            condition.await();
            System.out.println(Thread.currentThread().getName() + u.getSum());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
}