线程：生产者与消费者模式

生产者与消费者：

/**
* 生产者每次生产10件商品，消费者每次消费1件商品
* 没有商品时生产者生产商品，有商品时消费者消费商品
*/
class Producer extends Thread
{
private Cangku ck;
public Producer(Cangku ck)
{
this.ck = ck;
}
public void run()
{
ck.createProduct();
}
}
class Consumer extends Thread
{
private Cangku ck;
public Consumer(Cangku ck)
{
this.ck = ck;
}
public void run()
{
ck.useProduct();// 消费商品
}
}
class Cangku//商品对象会变化，创建一个容器对象，锁住不变
{
public synchronized void useProduct()//通过方法进行封装
{
for (int i = 0; i < 50; i++)
{
if (productSize() > 0)
{
for (int j = 0; j < 10; j++)
{
Product p = removeProduct(0);
System.out.println("消费了" + j + "个产品");
}
}
notify();
try
{
if (i != 49)
{
wait();
}
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
public synchronized void createProduct()
{
for (int i = 0; i < 50; i++)
{
if (productSize() == 0)
{
for (int j = 0; j < 10; j++)
{
addProduct(new Product());
}
System.out.println("生产了十个产品");
notify();
try
{
if (i != 49)
{
wait();
}
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
}
private LinkedList<Product> ppp = new LinkedList<Product>();//创建一个商品类型的容器
public int productSize()
{
return ppp.size();
}
public void addProduct(Product p)
{
if (null != p)
{
ppp.add(p);
}
}
public Product removeProduct(int index)
{
return ppp.remove(index);
}
}
class Product
{
String name = "玩具";
}
public class Test
{
public static void main(String[] args)
{
Cangku ck = new Cangku();
Producer p = new Producer(ck);
Consumer c = new Consumer(ck);
p.start();
c.start();
}
}

重构经过：

/**
* 加油一次20升，每次加完开车10公里
* 开车耗完油，没油时加油，有油时开车
* 双线程循环五十次
*/
public class TwoThread
{
public static void main(String[] args)
{
CarOilBox cob = new CarOilBox();
Car c = new Car(cob);
Oil o = new Oil(cob);
c.start();
o.start();
}
}
class Car extends Thread
{
private CarOilBox cob;
public Car(CarOilBox cob)
{
this.cob = cob;
}
@Override
public void run()
{
synchronized (cob)
{
for (int i = 0; i < 50; i++)
{
if (cob.co != null)
{
for (int j = 0; j < 10; j++)
{
cob.co = null;
System.out.println("第" + i + "次开车" + j + "公里");
}
}
cob.notify();
if (i < 49)
{
try
{
cob.wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
}
}
}
class Oil extends Thread
{
private CarOilBox cob;
public Oil(CarOilBox cob)
{
this.cob = cob;
}
@Override
public void run()
{
synchronized (cob)
{
for (int i = 0; i < 50; i++)
{
if (cob.co == null)
{
for (int j = 0; j < 20; j++)
{
cob.co = new CarOil();
System.out.println("第" + i + "次加油" + j + "升");
}
}
cob.notify();
if (i < 49)
{
try
{
cob.wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
}
}
}
class CarOil
{
}
class CarOilBox
{
CarOil co;
}

public class CopyTwoThread
{
public static void main(String[] args)
{
CarOilBox cob = new CarOilBox();
Car c = new Car(cob);
Oil o = new Oil(cob);
c.start();
o.start();
}
}
class Car extends Thread
{
private CarOilBox cob;
public Car(CarOilBox cob)
{
this.cob = cob;
}
@Override
public void run()
{
synchronized (cob)
{
for (int i = 0; i < 50; i++)
{
if (cob.aco.size() != 0)
{
for (int j = 0; j < 10; j++)
{
CarOil co1 = cob.aco.remove(0);
CarOil co2 = cob.aco.remove(0);
System.out.println("第" + i + "次开车" + j + "公里");
}
}
cob.notify();
if (i < 49)
{
try
{
cob.wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
}
}
}
class Oil extends Thread
{
private CarOilBox cob;
public Oil(CarOilBox cob)
{
this.cob = cob;
}
@Override
public void run()
{
synchronized (cob)
{
for (int i = 0; i < 50; i++)
{
if (cob.aco.size() == 0)
{
for (int j = 0; j < 20; j++)
{
cob.aco.add(new CarOil());
System.out.println("第" + i + "次加油" + j + "升");
}
}
cob.notify();
if (i < 49)
{
try
{
cob.wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
}
}
}
class CarOil
{
}
class CarOilBox
{
CarOil co;
ArrayList<CarOil> aco =new ArrayList<CarOil>();
}

public class CopyTwoThread
{
public static void main(String[] args)
{
CarOilBox cob = new CarOilBox();
Car c = new Car(cob);
Oil o = new Oil(cob);
c.start();
o.start();
}
}
class Car extends Thread
{
private CarOilBox cob;
public Car(CarOilBox cob)
{
this.cob = cob;
}
@Override
public void run()
{
synchronized (cob)
{
for (int i = 0; i < 50; i++)
{
if (cob.arraySize() != 0)
{
for (int j = 0; j < 10; j++)
{
CarOil co1 = cob.arrayRemove();
CarOil co2 = cob.arrayRemove();
System.out.println("第" + i + "次开车" + j + "公里");
}
}
cob.notify();
if (i < 49)
{
try
{
cob.wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
}
}
}
class Oil extends Thread
{
private CarOilBox cob;
public Oil(CarOilBox cob)
{
this.cob = cob;
}
@Override
public void run()
{
synchronized (cob)
{
for (int i = 0; i < 50; i++)
{
if (cob.arraySize() == 0)
{
for (int j = 0; j < 20; j++)
{
cob.arrayAdd();
System.out.println("第" + i + "次加油" + j + "升");
}
}
cob.notify();
if (i < 49)
{
try
{
cob.wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
}
}
}
class CarOil
{
}
class CarOilBox
{
//CarOil co;
private ArrayList<CarOil> aco =new ArrayList<CarOil>();
public int arraySize()
{
return aco.size();
}
public CarOil arrayRemove()
{
return aco.remove(0);
}
public void arrayAdd()
{
aco.add(new CarOil());
}
}

public class CopyTwoThread
{
public static void main(String[] args)
{
CarOilBox cob = new CarOilBox();
Car c = new Car(cob);
Oil o = new Oil(cob);
c.start();
o.start();
}
}
class Car extends Thread
{
private CarOilBox cob;
public Car(CarOilBox cob)
{
this.cob = cob;
}
@Override
public void run()
{
cob.driveCar(cob);
}
}
class Oil extends Thread
{
private CarOilBox cob;
public Oil(CarOilBox cob)
{
this.cob = cob;
}
@Override
public void run()
{
cob.addOil(cob);
}
}
class CarOil
{
}
class CarOilBox
{
//CarOil co;
private ArrayList<CarOil> aco =new ArrayList<CarOil>();
public int arraySize()
{
return aco.size();
}
public CarOil arrayRemove()
{
return aco.remove(0);
}
public void arrayAdd()
{
aco.add(new CarOil());
}
public synchronized void driveCar(CarOilBox cob)
{
for (int i = 0; i < 50; i++)
{
if (arraySize() != 0)
{
for (int j = 0; j < 10; j++)
{
CarOil co1 = arrayRemove();
CarOil co2 = arrayRemove();
System.out.println("第" + i + "次开车" + j + "公里");
}
}
notify();
if (i < 49)
{
try
{
wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
}
public synchronized void addOil(CarOilBox cob)
{
for (int i = 0; i < 50; i++)
{
if (arraySize() == 0)
{
for (int j = 0; j < 20; j++)
{
arrayAdd();
System.out.println("第" + i + "次加油" + j + "升");
}
}
notify();
if (i < 49)
{
try
{
wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
}
}

本文转自 glblong 51CTO博客，原文链接：http://blog.51cto.com/glblong/1195004，如需转载请自行联系原作者

线程：生产者与消费者模式相关推荐

线程间的协作（2）——生产者与消费者模式
2019独角兽企业重金招聘Python工程师标准>>> 1.何为生产者与消费者在线程世界里,生产者就是生产数据的线程,消费者就是消费数据的线程. import java.util. ...
用生产者和消费者模式实现奇数偶数不同线程交替输出
要求使用生产者和消费者模式实现,交替输出: 假设只有两个线程,输出以下结果:t1-->1t2-->2t1-->3t2-->4t1-->5t2-->6....要求: ...
6※、线程同步、同步锁、同步代码块的使用、同步锁释放的时机、ReentrantLock可重入锁、公平锁与非公平锁的区别、什么是死锁、线程间的通信（生产者和消费者模式）
线程锁 1.※线程的同步:(要确保对象锁是一致的) 1.未使用同步锁的抢票 2.使用了同步锁的抢票 3.线程-同步代码块的使用 4.同步方法和代码块的区别 5.同步锁释放的时机练习:多线程生产手机 ...
Python中的生产者与消费者模式(转载）
利用多线程和队列可以实现生产者消费者模式.该模式通过平衡生产线程和消费线程的工作能力来提高程序整体处理数据的速度. 1.什么是生产者和消费者? 在线程世界里,生产者就是生产数据(或者说发布任务)的线程 ...
生产者、消费者模式实现
1.1生产和1消费一个String对象,生产者设定值,消费者拿走值. wait()/notify()实现生产者 public class Product {private String lock; ...
Java多线模式-Producer-Consumer模式（生产者、消费者模式）
1.场景有些时候需要两个或两个以上的线程协同工作,每个线程需要使用其他线程产生数据. 2.详细说明可以把上面的场景抽象成生产者和消费者模式.从消费者的角度:消费者需要消费生产者生成的产品. 从生产 ...
多线程通信—生产者和消费者模式
1.队列Queue: 从一个线程向另一个线程发送数据最安全的方式可能就是使用queue库中的队列了.创建一个被多个线程共享的Queue对象,这些线程通过使用put()和get()操作来向队列中添加或者 ...
python 生产者和消费者模式_Python爬虫：生产者和消费者模式
认识生产者和消费者模式生产者和消费者是多线程中很常见的一个问题.产生数据的模块,我们称之为生产者,而处理数据的模块,就称为消费者.但是单单只有生产者和消费者显然还是不够的,一般来说,我们还有一个缓冲 ...
python 多线程并发编程（生产者、消费者模式），边读图像，边处理图像，处理完后保存图像实现提高处理效率
文章目录需求实现先导入本次需要用到的包一些辅助函数如下函数是得到指定后缀的文件如下的函数一个是读图像,一个是把RGB转成BGR 下面是主要的几个处理函数在上面几个函数构建对应的处理函数 ...
python中的生产者与消费者模式
Queue的说明对于Queue,在多线程通信之间扮演重要的角色添加数据到队列中,使用put()方法从队列中取数据,使用get()方法判断队列中是否还有数据,使用qsize()方法生产者消费者 ...

线程：生产者与消费者模式

线程：生产者与消费者模式相关推荐

最新文章

热门文章