天道酬勤
厚德载物

多线程并发协作模型-生产者消费者模式

多线程并发协作模型-生产者消费者模式

生产者消费者模式

应用场景

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

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

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

    Producer-consumer-problem

分析

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

  • 对于生产者,没有生产产品之前,要通知消费者等待。而生产了产品之后,又需要马上通知消费者消费。
  • 对于消费者,在消费之后,要通知生产者已经消费结束,需要继续生产新产品以供消费。
  • 在生产者消费者问题中,仅有synchronized是不够的。

    • synchronized可阻止并发更新同一个共享资源,实现了同步。
    • synchronized不能用来实现不同线程之间的消息传递(通信)。

解决方式

  • 并发协作模型-生产者消费者模式--->管程法
  • 并发协作模型-生产者消费者模式--->信号灯法

示例

管程法

示例代码如下:

package com.msl.cooperation;
/**
 * 协作模型:生产者消费者实现方式一:管程法
 * 借助缓冲区
 * 
 * @author Senley
 *
 */
public class CoTest01 {
    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;
    }

    public void run() {
        //生产
        for(int i=0;i<100;i++) {
            System.out.println("生产-->"+i+"个馒头");
            container.push(new Steamedbun(i) );
        }
    }
}
//消费者
class Consumer extends Thread{
    SynContainer container  ;   
    public Consumer(SynContainer container) {
        this.container = container;
    }
    public void run() {
        //消费
        for(int i=0;i<100;i++) {
            System.out.println("消费-->"+container.pop().id+"个馒头");
        }
    }
}
//缓冲区
class SynContainer{
    Steamedbun[] buns = new Steamedbun[10]; //存储容器
    int count = 0; //计数器
    //存储 生产
    public synchronized void push(Steamedbun bun) {
        //何时能生产  容器存在空间
        //不能生产 只有等待
        if(count == buns.length) {
            try {
                this.wait(); //线程阻塞  消费者通知生产解除
            } catch (InterruptedException e) {
            }
        }
        //存在空间 可以生产
        buns[count] = bun;
        count++;
        //存在数据了,可以通知消费了
        this.notifyAll();
    }
    //获取 消费
    public synchronized Steamedbun pop() {
        //何时消费 容器中是否存在数据
        //没有数据 只有等待
        if(count == 0) {
            try {
                this.wait(); //线程阻塞  生产者通知消费解除
            } catch (InterruptedException e) {
            }
        }
        //存在数据可以消费
        count --;
        Steamedbun bun = buns[count] ;      
        this.notifyAll(); //存在空间了,可以唤醒对方生产了
        return bun;
    }
}
//馒头
class Steamedbun{
    int id;
    public Steamedbun(int id) {
        this.id = id;
    }

}

结果如下:

生产-->0个馒头
生产-->1个馒头
生产-->2个馒头
生产-->3个馒头
生产-->4个馒头
生产-->5个馒头
生产-->6个馒头
生产-->7个馒头
生产-->8个馒头
生产-->9个馒头
生产-->10个馒头
生产-->11个馒头
消费-->9个馒头
消费-->10个馒头
消费-->11个馒头
消费-->8个馒头
生产-->12个馒头
生产-->13个馒头
消费-->7个馒头
生产-->14个馒头
消费-->13个馒头
生产-->15个馒头
消费-->14个馒头
生产-->16个馒头
消费-->15个馒头
生产-->17个馒头
消费-->16个馒头
生产-->18个馒头
消费-->17个馒头
生产-->19个馒头
生产-->20个馒头
生产-->21个馒头
消费-->18个馒头
消费-->20个馒头
生产-->22个馒头
消费-->21个馒头
消费-->22个馒头
生产-->23个馒头
消费-->19个馒头
生产-->24个馒头
消费-->23个馒头
生产-->25个馒头
消费-->24个馒头
生产-->26个馒头
生产-->27个馒头
生产-->28个馒头
消费-->25个馒头
消费-->27个馒头
生产-->29个馒头
生产-->30个馒头
消费-->28个馒头
消费-->29个馒头
生产-->31个馒头
生产-->32个馒头
消费-->30个馒头
消费-->31个馒头
生产-->33个馒头
生产-->34个馒头
消费-->32个馒头
消费-->33个馒头
生产-->35个馒头
生产-->36个馒头
消费-->34个馒头
消费-->35个馒头
生产-->37个馒头
消费-->36个馒头
生产-->38个馒头
消费-->37个馒头
生产-->39个馒头
消费-->38个馒头
生产-->40个馒头
消费-->39个馒头
生产-->41个馒头
消费-->40个馒头
生产-->42个馒头
消费-->41个馒头
消费-->42个馒头
消费-->26个馒头
消费-->12个馒头
生产-->43个馒头
消费-->6个馒头
消费-->43个馒头
消费-->5个馒头
消费-->4个馒头
消费-->3个馒头
消费-->2个馒头
消费-->1个馒头
消费-->0个馒头
生产-->44个馒头
生产-->45个馒头
消费-->44个馒头
生产-->46个馒头
消费-->45个馒头
生产-->47个馒头
消费-->46个馒头
生产-->48个馒头
消费-->47个馒头
生产-->49个馒头
消费-->48个馒头
生产-->50个馒头
消费-->49个馒头
生产-->51个馒头
消费-->50个馒头
生产-->52个馒头
消费-->51个馒头
生产-->53个馒头
消费-->52个馒头
生产-->54个馒头
消费-->53个馒头
消费-->54个馒头
生产-->55个馒头
生产-->56个馒头
消费-->55个馒头
生产-->57个馒头
消费-->56个馒头
生产-->58个馒头
消费-->57个馒头
生产-->59个馒头
消费-->58个馒头
生产-->60个馒头
消费-->59个馒头
生产-->61个馒头
消费-->60个馒头
生产-->62个馒头
消费-->61个馒头
生产-->63个馒头
消费-->62个馒头
生产-->64个馒头
消费-->63个馒头
消费-->64个馒头
生产-->65个馒头
生产-->66个馒头
消费-->65个馒头
生产-->67个馒头
消费-->66个馒头
生产-->68个馒头
消费-->67个馒头
生产-->69个馒头
消费-->68个馒头
消费-->69个馒头
生产-->70个馒头
生产-->71个馒头
消费-->70个馒头
生产-->72个馒头
消费-->71个馒头
消费-->72个馒头
生产-->73个馒头
生产-->74个馒头
生产-->75个馒头
生产-->76个馒头
消费-->73个馒头
消费-->76个馒头
消费-->75个馒头
消费-->74个馒头
生产-->77个馒头
生产-->78个馒头
消费-->77个馒头
消费-->78个馒头
生产-->79个馒头
消费-->79个馒头
生产-->80个馒头
生产-->81个馒头
消费-->80个馒头
消费-->81个馒头
生产-->82个馒头
生产-->83个馒头
消费-->82个馒头
消费-->83个馒头
生产-->84个馒头
生产-->85个馒头
消费-->84个馒头
消费-->85个馒头
生产-->86个馒头
生产-->87个馒头
消费-->86个馒头
生产-->88个馒头
消费-->87个馒头
生产-->89个馒头
消费-->88个馒头
消费-->89个馒头
生产-->90个馒头
生产-->91个馒头
消费-->90个馒头
消费-->91个馒头
生产-->92个馒头
生产-->93个馒头
消费-->92个馒头
生产-->94个馒头
消费-->93个馒头
生产-->95个馒头
消费-->94个馒头
消费-->95个馒头
生产-->96个馒头
生产-->97个馒头
消费-->96个馒头
消费-->97个馒头
生产-->98个馒头
生产-->99个馒头
消费-->98个馒头
消费-->99个馒头

信号灯法

示例代码如下:

package com.msl.cooperation;
/**
 * 协作模型:生产者消费者实现方式二:信号灯法
 * 借助标志位
 * 
 * @author Senley
 *
 */
public class CoTest02 {
    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;
    }

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

    public void run() {
        for(int i=0;i<20;i++) {
            tv.watch();
        }
    }
}
//同一个资源 电视
class Tv{
    String voice;
    //信号灯
    //T 表示演员表演 观众等待
    //F 表示观众观看 演员等待
    boolean flag = true;

    //表演
    public  synchronized void play(String voice) {
        //演员等待
        if(!flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }       
        //表演
        System.out.println("表演了:"+voice);
        this.voice = voice;
        //唤醒
        this.notifyAll();
        //切换标志
        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;
    }
}

结果如下:

表演了:欢乐集结号
听到了:欢乐集结号
表演了:怕上火 喝加多宝
听到了:怕上火 喝加多宝
表演了:欢乐集结号
听到了:欢乐集结号
表演了:怕上火 喝加多宝
听到了:怕上火 喝加多宝
表演了:欢乐集结号
听到了:欢乐集结号
表演了:怕上火 喝加多宝
听到了:怕上火 喝加多宝
表演了:欢乐集结号
听到了:欢乐集结号
表演了:怕上火 喝加多宝
听到了:怕上火 喝加多宝
表演了:欢乐集结号
听到了:欢乐集结号
表演了:怕上火 喝加多宝
听到了:怕上火 喝加多宝
表演了:欢乐集结号
听到了:欢乐集结号
表演了:怕上火 喝加多宝
听到了:怕上火 喝加多宝
表演了:欢乐集结号
听到了:欢乐集结号
表演了:怕上火 喝加多宝
听到了:怕上火 喝加多宝
表演了:欢乐集结号
听到了:欢乐集结号
表演了:怕上火 喝加多宝
听到了:怕上火 喝加多宝
表演了:欢乐集结号
听到了:欢乐集结号
表演了:怕上火 喝加多宝
听到了:怕上火 喝加多宝
表演了:欢乐集结号
听到了:欢乐集结号
表演了:怕上火 喝加多宝
听到了:怕上火 喝加多宝
赞(1) 打赏
未经允许不得转载:许我三千笔墨 » 多线程并发协作模型-生产者消费者模式
分享到: 更多 (0)

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

觉得文章有用就打赏一下文章作者

非常感谢你的打赏,我们将继续给力更多优质内容,让我们一起创建更加美好的网络世界!

支付宝扫一扫打赏

微信扫一扫打赏