多线程—线程协作

导读:本篇文章讲解 多线程—线程协作,希望对大家有帮助,欢迎收藏,转发!站点地址:www.bmabk.com

线程协作

线程通信

例如生产者消费者共享一个资源,并且生产者消费者之间相互依赖,互为条件:

  • ​ 对于生产者,没有生产产品之前,要通知消费者等待,生产产品之后,要通知消费者消费

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

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

    • synchronized可阻止并发更新同一个共享资源,实现同步
    • synchronized不能实现不同线程之间的消息传递

所以Java提供了几个解决线程通讯的方法

方法名 作用
wait() 表示线程一直等待,直到其他线程通知,和sleep不同,执行该方法会释放锁
wait(long timeout) 指定等待的毫秒数
notify() 唤醒处于等待状态的线程
notifyAll() 唤醒同一个对象是所有调用wait()方法的线程,优先级高的线程优先调度

注意:上述方法均是object类的方法,都只能在同步方法或者**同步代码块中使用,否则会抛出异常IllegalMonitorStateException

解决方法1:管程法(以炸鸡为例)

并发协作模型:

  • 生产者:负责生产数据模块
  • 消费者:负责处理数据的模块
  • 缓冲区:生产者生产的数据存储于此,消费者从该处取出数据

所以缓冲区里面的方法则是要用synchronized来定义:

//缓冲区
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;
    }
}

在生产者生产完一个之后,执行notifyAll()方法,让消费者消费;当生产者生产的已经堆满缓冲区之后,则执行wait()方法,进入等待状态,让消费者进行消费,当消费一个之后,则调用notifyAll()方法唤醒生产者继续生产;当消费到缓冲区无东西可消费的时候,则消费者调用wait()方法,进入等待状态,直到生产者生产出一个产品如何调用notifyAll()方法再将消费者唤醒。

以下便是其余的代码:

//测试:生产者消费者模型 -->利用缓冲区解决:管程法

//生产,消费者,产品,缓冲区
public class TestPC {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();

        new Productor(container).start();
        new Consumer(container).start();
    }
}

//生产者,只负责生产
class Productor extends Thread{
    SynContainer container;

    public Productor(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;
    }
}

解决方法2:信号灯法(以表演节目为例)

类比解决方法1,只是没有数据缓冲存储,一有节目,观众就看,看完之后表演者再去表演,然后再给观众看

//测试生产者消费者问题2:信号灯法
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){
                tv.play("快乐大本营播放中");
            }else{
                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{
    //演员表演节目,观众等待   true
    //观众观看,演员等待 false
    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;
    }
}

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

文章由半码博客整理,本文链接:https://www.bmabk.com/index.php/post/84197.html

(0)

相关推荐

半码博客——专业性很强的中文编程技术网站,欢迎收藏到浏览器,订阅我们!