JavaSE进阶：多线程(三)

雙馬程序猿

已于 2023-02-08 09:21:45 修改

阅读量283

点赞数

分类专栏： Java 文章标签： java

于 2022-08-26 10:21:22 首次发布

本文链接：https://blog.csdn.net/m0_64095482/article/details/126537715

版权

1.使用Collections的方法解决线程不安全集合

2.CopyOnWriteArrayList

3.CopyOnWriteArraySet

4.Queue接口(队列)

1.ConcurrentLinkedQueue

2.BlockingQueue接口(阻塞队列)

5. ConcurrentHashMap

5.线程通信

1.生产者和消费者问题

假设仓库中只能存放一件产品,生产者将生产出来的产品放入仓库,消费者将仓库产品取走消费

如果仓库中没有产品,则生产者将产品放入仓库,否则停止生产并等待,直到仓库中的产品被消费者取走为止

如果仓库中放有产品,则消费者可以将产品取走消费,否则停止消费并等待,直到仓库中再次放入产品为止

这是一个线程同步问题,生产者和消费者共享一个资源,并且生产者和消费者之间相互依赖,互为条件

对于生产者,没有生产产品之前,要通知消费者等待,而生产了产品之后,又要马上通知消费者消费

对于消费者,在消费之后,要通知生产者已经结束消费,需要生产新的产品以供消费

在生产者消费者问题上,仅有synchronized是不够的

synchronized可阻止并发更新同一个共享资源,实现了同步

synchronized不能用来实现不同线程之间消息传递(通信)

方法名	作用
wait()	表示线程一直等待，直到其他线程通知，与slepp不同，会释放锁
wait(long timeout)	指定等待的毫秒数
notify()	唤醒一个处于等待的线程
notifyAll()	唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度

注意：均是Object的方法，都只能在同步方法或同步代码块中使用，否则会抛出异常lllegalMonitorState Exception

解决方式1(管程法)

并发协作模式"生产者/消费者模式" ===>管程法

生产者: 负责生产数据的模块(可能是方法,对象,线程,数组)
消费者: 负责处理数据的模块(可能是方法,对象,线程,数组)
缓冲区: 消费者不能直接使用生产者的数据,他们之间有个缓冲区

生产者将生产好的数据放入缓冲区,消费者从缓冲区拿出数据

package java_se.java_jinjie.duoxiancheng.demo05.gcf;

//测试：生产者消费者模型->利用缓冲区解决:管程法
//生产者，消费者，产品，缓冲区
public class TestPC {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();
        new Producer(container).start();
        new Consumer(container).start();
    }
}

//生产者
class Producer extends Thread{
    SynContainer container;

    public Producer(SynContainer container) {
        this.container = container;
    }

    //生产

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            container.push(new Chicken(i));
            System.out.println("生产了"+i+"只鸡");
        }
    }
}
//消费者
class Consumer extends Thread{
    SynContainer container;

    public Consumer(SynContainer container) {
        this.container = container;
    }

    //消费
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了"+container.pop().id+"只鸡");
        }
    }
}
//产品
class Chicken{
    int id;//产品编号

    public Chicken(int id) {
        this.id = id;
    }
}
//缓冲区
class SynContainer{
    //需要一个容器大小
    Chicken[] chickens =new Chicken[10];
    //容器计数器
    int count=0;
    public synchronized void push(Chicken chicken){
        if (count==chickens.length){
            //通知消费者消费，生产等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有满，我们就需要丢入产品
        chickens[count]=chicken;
        count++;
        //可以通知消费者 消费了
        this.notifyAll();
    }

    //消费者消费产品
    public synchronized Chicken pop(){
        //判断能否消费
        if (count==0){
            //等待生产者，消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果可以消费
        count--;
        Chicken chicken = chickens[count];

        //吃完了，通知生产者生产
        this.notifyAll();
        return chicken;
    }
}

解决方式2(信号灯法)

并发协作模式"生产者/消费者模式" ===>信号灯法

package java_se.java_jinjie.duoxiancheng.demo05;
//测试：信号灯法，标志位解决
public class TestPC2 {
    public static void main(String[] args) {
        TV tv = new TV();
        new Player(tv).start();
        new Watcher(tv).start();
    }
}

//生产者-->演员
class Player extends Thread{
    TV tv;
    public Player(TV tv){
        this.tv=tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i%2==0){
                this.tv.play("快乐大本营播放中");
            }else {
                this.tv.play("抖音记录美好生活");
            }
        }
    }
}
//消费者-->观众
class Watcher extends Thread{
    TV tv;
    public Watcher(TV tv){
        this.tv=tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            tv.watch();
        }
    }
}

//产品-->节目
class TV{
    //演员录制节目，观众等待  演员T
    //观众观看，演员等待     演员F
    String voice;
    boolean flag = true;
    //录制
    public synchronized void play(String voice){
        if (!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("演员表演了:"+voice);
        //通知观众观看
        this.notifyAll();//通知唤醒
        this.voice=voice;
        this.flag=!this.flag;
    }
    //观看
    public synchronized void watch(){
        if (flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观众观看了："+voice);
        //通知演员录制
        this.notifyAll();//通知唤醒
        this.flag=!this.flag;
    }
}

2.存钱取钱案例

1.出现负数和死锁

package java_se.java_jinjie.duoxiancheng.demo05.demo;

//存钱取钱
public class BankCard {
    //余额
    private double money;
    //标记
    private boolean flag=false;//true表示有钱可以取钱，false表示没钱

    //存钱
    public synchronized void save(double m){
        if (flag){
            try {
                this.wait();//进入等待队列，同时释放锁和CPU
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        money=money+m;
        System.out.println(Thread.currentThread().getName()+"存了"+m+"余额是"+money);
        //修改标记
        flag=true;
        //唤醒取钱线程
        this.notify();
    }

    //取钱
    public synchronized void tack(double m){
        if (!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        money=mon