[Java][华为云Java编程创造营][学习笔记][第三阶段][05_Java多线程实战][04_线程通信]

4.1，线程通信机制

• 线程间同步可以归纳为线程间通信的子集，对于线程通信指的是两个线程之间可以交换一些实时的数据信息。
• 线程是操作系统中独立的个体，但这些个体如果不经过特殊处理就不能成为一个整体，线程间的通信就成为整体的必用方式之一。
• 当线程存在通信指挥，系统间的交互性会更强大，在提高CPU利用率的同时还会使开发人员对线程任务在处理过程中进行有效的把控与监督。

4.2，线程通信的wait和notify机制

• wait/notify方法实现线程间的通信：

  • 这两个方法都是Object类的方法，换句话说Java为所有的对象都提供了这两个方法。

• Lock和Condition实现线程间的通信：

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

• 线程通信的wait/notify机制：

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

• 线程通信案例：

class SumThread extends Thread
{
    private int sum = 0;

    public void run()
    {
        synchronized (this)
        {
            for (int i = 0; i <= 100; i++)
            {
                sum += i;
            }
            /*
             * 算好后，通知和子线程持有同一个对象的锁的被阻塞的线程解锁继续运行
             * 如果是当前线程对象，默认可以不写this.notify();
             * */
            this.notify();
        }
    }

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

public class Test
{
    /*
     * 子线程计算1-100之和，算好后马上通知主线程获取计算的总和
     * */
    public static void main(String[] args)
    {
        SumThread st = new SumThread();
        st.start();
        synchronized (st)
        {
            try
            {
                System.out.println(Thread.currentThread().getName() + "，线程被阻塞");
                //wait()和notify()是匹配，如果被wait()，一定要notify()唤醒解锁
                st.wait();
                System.out.println(Thread.currentThread().getName() + "，线程收到的值为：" + st.getSum());
            } catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
    }
    /*
    * 输出结果
    *   main，线程被阻塞
        main，线程收到的值为：5050
    * */
}

4.3，线程通信的Lock和Condition机制

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

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

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;
    }

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

    public int getSum()
    {
        return sum;
    }
}
public class Test
{
    public static void main(String[] args)
    {
        //1，创建锁
        ReentrantLock lock = new ReentrantLock();
        //2，监视器
        Condition condition = lock.newCondition();

        UserThread ut = new UserThread(lock, condition);
        ut.start();

        lock.lock();
        System.out.println(Thread.currentThread().getName() + "-->被阻塞");

        try
        {
            condition.await();
            System.out.println(Thread.currentThread().getName() + "-->" + ut.getSum());
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        } finally
        {
            lock.unlock();
        }
        /*
        * 输出结果
        *   main-->被阻塞
            main-->5050
        * */
    }
}