Day125.JUC：线程间通信(Conditon)、并发容器类(CopyOnWrite)、JUC强大辅助类、Callable

目录

一、线程间通信

线程间通信改造成Lock版  Condition

定制化调用通信 Condition

二、并发容器类 (解决集合安全问题)

CopyOnWrite 写时拷贝技术

三、JUC 并发辅助工具类

1、CountDownLatch (倒计时线程控制)

2、CyclicBarrier (循环栅栏)

3、Semaphore (信号量)

四、Callable接口、

FutureTask 未来任务

---

一、线程间通信

线程按顺序执行

面试题：两个线程，一个线程打印1-52，另一个打印字母A-Z打印顺序为12A34B...5152Z，要求用线程间通信

1、简化问题：两个线程操作一个初始值为0的变量，实现一个线程对变量增加1，一个线程对变量减少1，交替10轮。

2、实现方案-线程间通信模型：

• 生产者+消费者

• 通知等待唤醒机制 (wait、notify)

3、多线程编程模板中：线程   操作  资源类；判断、干活、通知；高内聚低耦合

//  实现一个线程对该变量加1，一个线程对该变量减1， 交替 10 轮！
class ShareDataOne{
    private Integer number = 0;
    //加一
    public synchronized void incre()  {
        try {
            //1.判断
            if (number!=0){
                this.wait();
            }
            //2.干活
            number++;
            System.out.println(Thread.currentThread().getName()+":"+number);
            //3.通知
            this.notifyAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //减一
    public synchronized void decre(){
        try {
            //1.判断
            if (number!=1){
                this.wait();
            }
            //2.干活
            number--;
            System.out.println(Thread.currentThread().getName()+":"+number);
            //3.通知
            this.notifyAll();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
/*
 * 现在两个线程，
 * 可以操作初始值为零的一个变量，
 * 实现一个线程对该变量加1，一个线程对该变量减1，
 * 交替，来10轮。
 *
 * 笔记：Java里面如何进行工程级别的多线程编写
 * 1 多线程变成模板（套路）-----上
 *    1.1  线程    操作    资源类
 *    1.2  高内聚  低耦合
 * 2 多线程变成模板（套路）-----中
 *    2.1  判断
 *    2.2  干活
 *    2.3  通知
 */
public class NotifyWaitDemo {
    public static void main(String[] args) {
        ShareDataOne shareDataOne = new ShareDataOne();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                    shareDataOne.incre();
            }
        },"AAA").start();
 
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                    shareDataOne.decre();
            }
        },"BBB").start();
    }
}

换成4个线程会导致错误，虚假唤醒问题

原因：在java多线程判断时，不能用if，程序出事出在了判断上面。

注意，消费者被唤醒后是从wait()方法（被阻塞的地方）后面执行，而不是重新从同步块开头，没有进行条件判断。

线程间通信改造成Lock版  Condition

对标实现

 

class ShareDataOne{
    private Integer number = 0;
    Lock lock = new ReentrantLock();    // 初始化lock锁
    Condition cd = lock.newCondition(); // 初始化condition对象
    //加一
    public  void incre()  {
        lock.lock();
        try {
            //1.判断
            while (number!=0){
                //this.wait();
                cd.await(); //睡眠
            }
            //2.干活
            number++;
            System.out.println(Thread.currentThread().getName() + ":" + number);
            //3.通知
            //this.notifyAll();
            cd.signalAll(); //唤醒
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    //减一
    public  void decre(){
        lock.lock();
        try {
            //1.判断
            while (number!=1){
                //this.wait();
                cd.await(); //睡眠
            }
            //2.干活
            number--;
            System.out.println(Thread.currentThread().getName() + ":" + number);
            //3.通知
            //this.notifyAll();
            cd.signalAll(); //唤醒
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

定制化调用通信 Condition

案例：

多线程之间按顺序调用，实现A->B->C。三个线程启动，要求如下：

AA打印5次，BB打印10次，CC打印15次；

接着

AA打印5次，BB打印10次，CC打印15次；

。。。打印10轮

分析实现方式：

• 有一个锁Lock，3把钥匙Condition
• 有顺序通知（切换线程），需要有标识位
• 判断标志位
• 输出线程名 + 内容
• 修改标识符，通知下一个

/*多线程之间按顺序调用，实现A->B->C。三个线程启动，要求如下：
        AA打印5次，BB打印10次，CC打印15次；
        接着
        AA打印5次，BB打印10次，CC打印15次；
        。。。打印10轮*/
//  资源类：
class ShareDataTwo{
    //  声明一些变量
    private int flag = 1;   //  【flag=1 AA  flag=2 BB  flag=3 CC】
    private Lock lock = new ReentrantLock();
    private Condition c1 = lock.newCondition();
    private Condition c2 = lock.newCondition();
    private Condition c3 = lock.newCondition();
 
    //  定义打印方法！
    public void print5(int total){
        lock.lock(); //上锁
        try {
            while (flag!=1){ //判断
                c1.await();
            }
            //干活:循环打印
            for (int i = 0; i <= 5; i++) {
                System.out.println(Thread.currentThread().getName() +
                        "\t"+i+"\t第"+total+"轮");
            }
            //通知，修改标识位
            flag=2;
            c2.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock(); //解锁
        }
    }
 
    public void print10(int total){
        lock.lock(); //上锁
        try {
            while (flag!=2){ //判断
                c2.await();
            }
            //干活:循环打印
            for (int i = 0; i <= 10; i++) {
                System.out.println(Thread.currentThread().getName() +
                        "\t"+i+"\t第"+total+"轮");
            }
            //通知，修改标识位
            flag=3;
            c3.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock(); //解锁
        }
    }
 
    public void print15(int total){
        lock.lock(); //上锁
        try {
            while (flag!=3){ //判断
                c3.await();
            }
            //干活:循环打印
            for (int i = 0; i <= 15; i++) {
                System.out.println(Thread.currentThread().getName() +
                        "\t"+i+"\t第"+total+"轮");
            }
            //通知，修改标识位
            flag=1;
            c1.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();//解锁
        }
    }
}
public class ThreadOrderAccess {
    public static void main(String[] args) {
        //  线程操作资源类
        ShareDataTwo shareDataTwo = new ShareDataTwo();
        //  线程：
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                shareDataTwo.print5(i+1);
            }
        },"AA").start();
 
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                shareDataTwo.print10(i+1);
            }
        },"BB").start();
 
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                shareDataTwo.print15(i+1);
            }
        },"CC").start();
    }
}

面试题：

//面试题：两个线程，一个线程打印1-52，另一个打印字母A-Z打印顺序为12A34B...5152Z，要求用线程间通信
class ShareDataThree{
 
    private int flag = 1;
    private Integer number = 1;
    private char letter = 'A';
    private Lock lock = new ReentrantLock();
    Condition c1 = lock.newCondition();
    Condition c2 = lock.newCondition();
 
    public void printNum(){
        lock.lock(); //上锁
        try {
            //判断
            while (flag!=1){
                c1.await(); //睡眠
            }
            //干活
            System.out.print(number++);
            System.out.print(number++);
            //通知 修改标识，唤醒
            flag = 2;
            c2.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock(); //解锁
        }
    }
 
    public void printLetter(){
        lock.lock(); //上锁
        try {
            //判断
            while (flag!=2){
                c2.await(); //睡眠
            }
            //干活
            System.out.print(letter++ + " ");
            //通知 修改标识，唤醒
            flag = 1;
            c1.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock(); //解锁
        }
    }
}
 
public class Test {
    public static void main(String[] args) {
        ShareDataThree shareDataThree = new ShareDataThree();
        new Thread(()->{
            for (int i = 0; i < 26; i++) {
                shareDataThree.printNum();
            }
        },"num").start();
        new Thread(()->{
            for (int i = 0; i < 26; i++) {
                shareDataThree.printLetter();
            }
        },"let").start();
    }
}

二、并发容器类 (解决集合安全问题)

面试题：请举例说明集合类是不安全的。

方法一：代码验证

public class NotSafeDemo {
    public static void main(String[] args) {
        //List