JUC---线程间定制化通信

最新推荐文章于 2024-02-06 19:38:03 发布

Jesslili

最新推荐文章于 2024-02-06 19:38:03 发布

阅读量275

点赞数

分类专栏： JAVA并发编程文章标签：多线程 java juc

本文链接：https://blog.youkuaiyun.com/myjess/article/details/119032059

版权

JAVA并发编程专栏收录该内容

10 篇文章

订阅专栏

本文通过示例详细介绍了Java中线程间的通信问题，包括使用同步锁和Condition实现线程间的顺序执行。首先，通过修复虚假通信问题展示了如何确保线程正确同步。然后，通过引入定制化通信的概念，实现特定线程顺序执行的案例，演示了如何使用Lock和Condition来控制线程执行的顺序，以达到预期的打印效果。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

此博客案例来自尚硅谷JUC视频

一、线程间的通信

实现两个线程（AA、BB），使得AA线程+1，BB线程-1

package com.jess.sync;
/**
 * @program: JUC
 * @description: 线程间的通信
 * @author: Jess
 * @create: 2021-07-23 13:48
 **/
//第一步 创建资源类，定义属性和操作方法
class Share {
    //初始值
    private int number = 0;
    //+1的方法
    public synchronized void incr() throws InterruptedException {
        //第二步 判断 干活 通知
        if(number != 0) { //判断number值是否是0，如果不是0，等待
            this.wait(); 
        }
        //如果number值是0，就+1操作
        number++;
        System.out.println(Thread.currentThread().getName()+" :: "+number);
        //通知其他线程
        this.notifyAll();
    }

    //-1的方法
    public synchronized void decr() throws InterruptedException {
        //判断
        if(number != 1) {
            this.wait();
        }
        //干活
        number--;
        System.out.println(Thread.currentThread().getName()+" :: "+number);
        //通知其他线程
        this.notifyAll();
    }
}

public class ThreadDemo1 {
    //第三步 创建多个线程，调用资源类的操作方法
    public static void main(String[] args) {
        Share share = new Share();
        //创建线程
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    share.incr(); //+1
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "AA").start();

        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    share.decr(); //-1
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "BB").start();
    }
}

输出结果：
在这里插入图片描述
再额外增加两个线程（CC、DD），期望结果为AA：1、BB：0、CC：1、DD：0

new Thread(()->{
	for (int i = 1; i <=10; i++) {
      try {
          share.incr(); //+1
      } catch (InterruptedException e) {
          e.printStackTrace();
      }
  }
},"CC").start();

new Thread(()->{
  for (int i = 1; i <=10; i++) {
      try {
          share.decr(); //-1
      } catch (InterruptedException e) {
          e.printStackTrace();
      }
  }
},"DD").start();

输出结果如下所示，并不符合预期
在这里插入图片描述
出现上述错误情况的原因-----虚假通信：假设AA线程先执行，执行完后会唤醒其他线程，剩余3个线程抢占资源。若CC线程抢占到了执行权，该线程会从wait()处继续执行，而最初用于判断的if语句不会再次执行了，即CC线程又在原有的基础上+1。

正确代码：应将if语句改为while循环，这样的话，每当线程被唤醒都会再次进行判断是否执行。

class Share {
    //初始值
    private int number = 0;
    //+1的方法
    public synchronized void incr() throws InterruptedException {
        //第二步 判断 干活 通知
        while(number != 0) { //判断number值是否是0，如果不是0，等待
            this.wait(); //在哪里睡，就在哪里醒
        }
        //如果number值是0，就+1操作
        number++;
        System.out.println(Thread.currentThread().getName()+" :: "+number);
        //通知其他线程
        this.notifyAll();
    }

    //-1的方法
    public synchronized void decr() throws InterruptedException {
        //判断
        while(number != 1) {
            this.wait();
        }
        //干活
        number--;
        System.out.println(Thread.currentThread().getName()+" :: "+number);
        //通知其他线程
        this.notifyAll();
    }
}

执行结果：
在这里插入图片描述
使用Lock实现该案例：
newCondition方法：返回绑定到此Lock实例的新Condition实例。

Condition接口：

await()：当前线程接到信号或被中断前一直处于等待状态
signal()：唤醒一个等待线程
signaiAll()：唤醒所有等待线程

package com.jess.sync;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @program: JUC
 * @description: 线程间的通信
 * @author: Jess
 * @create: 2021-07-23 13:48
 **/
//第一步 创建资源类，定义属性和操作方法
class Share {
    private int number = 0;

    //创建Lock
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    //+1
    public void incr() throws InterruptedException {
        //上锁
        lock.lock();
        try {
            //判断
            while (number != 0) {
                condition.await();//等待
            }
            //干活
            number++;
            System.out.println(Thread.currentThread().getName()+" :: "+number);
            //通知  唤醒所有线程
            condition.signalAll();
        }finally {
            //解锁
            lock.unlock();
        }
    }

    //-1
    public void decr() throws InterruptedException {
        lock.lock();
        try {
            while(number != 1) {
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName()+" :: "+number);
            condition.signalAll();
        }finally {
            lock.unlock();
        }
    }
}

public class ThreadDemo2 {

    public static void main(String[] args) {
        Share share = new Share();
        new Thread(()->{
            for (int i = 1; i <=10; i++) {
                try {
                    share.incr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"AA").start();
        new Thread(()->{
            for (int i = 1; i <=10; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"BB").start();

        new Thread(()->{
            for (int i = 1; i <=10; i++) {
                try {
                    share.incr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"CC").start();
        new Thread(()->{
            for (int i = 1; i <=10; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"DD").start();
    }
}

二、线程间定制化通信

上述案例中4个线程的执行顺序是不确定的，让线程按照约定的顺序进行调用就是定制化通信。

案例：启动3个线程，使得AA线程先执行打印5次，BB线程打印10次，CC线程打印15次。一共进行10轮上述操作。

思路分析：
在这里插入图片描述

package com.jess.sync;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @program: JUC
 * @description: 线程间的定制通信
 * @author: Jess
 * @create: 2021-07-23 14:21
 **/
//第一步 创建资源类
class ShareResource {
    //定义标志位
    private int flag = 1;  // 1 AA     2 BB     3 CC

    //创建Lock锁
    private Lock lock = new ReentrantLock();

    //创建三个condition，对应3个线程
    private Condition c1 = lock.newCondition();
    private Condition c2 = lock.newCondition();
    private Condition c3 = lock.newCondition();

    //打印5次，参数第几轮
    public void print5(int loop) throws InterruptedException {
        //上锁
        lock.lock();
        try {
            //判断
            while(flag != 1) {
                c1.await();
            }
            for (int i = 1; i <=5; i++) {
                System.out.println(Thread.currentThread().getName()+" :: "+i+" ：轮数："+loop);
            }
            //通知
            flag = 2; //修改标志位 2
            c2.signal(); //通知BB线程
        }finally {
            lock.unlock();
        }
    }

    //打印10次，参数第几轮
    public void print10(int loop) throws InterruptedException {
        lock.lock();
        try {
            while(flag != 2) {
                c2.await();
            }
            for (int i = 1; i <=10; i++) {
                System.out.println(Thread.currentThread().getName()+" :: "+i+" ：轮数："+loop);
            }
            //修改标志位
            flag = 3;
            //通知CC线程
            c3.signal();
        }finally {
            lock.unlock();
        }
    }

    //打印15次，参数第几轮
    public void print15(int loop) throws InterruptedException {
        lock.lock();
        try {
            while(flag != 3) {
                c3.await();
            }
            for (int i = 1; i <=15; i++) {
                System.out.println(Thread.currentThread().getName()+" :: "+i+" ：轮数："+loop);
            }
            //修改标志位
            flag = 1;
            //通知AA线程
            c1.signal();
        }finally {
            lock.unlock();
        }
    }
}

public class ThreadDemo3 {
    public static void main(String[] args) {
        ShareResource shareResource = new ShareResource();
        new Thread(()->{
            for (int i = 1; i <=10; i++) {
                try {
                    shareResource.print5(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"AA").start();

        new Thread(()->{
            for (int i = 1; i <=10; i++) {
                try {
                    shareResource.print10(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"BB").start();

        new Thread(()->{
            for (int i = 1; i <=10; i++) {
                try {
                    shareResource.print15(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"CC").start();
    }
}