Java线程：并发协作-生产者消费者模型

对于多线程程序来说，不管任何编程语言，生产者和消费者模型都是最经典的。就像学习每一门编程语言一样，Hello World！都是最经典的例子。

实际上，准确说应该是“生产者-消费者-仓储”模型，离开了仓储，生产者消费者模型就显得没有说服力了。

对于此模型，应该明确一下几点：

生产者仅仅在仓储未满时候生产，仓满则停止生产。
消费者仅仅在仓储有产品时候才能消费，仓空则等待。
当消费者发现仓储没产品可消费时候会通知生产者生产。
生产者在生产出可消费产品时候，应该通知等待的消费者去消费。

此模型将要结合java.lang.Object的wait与notify、notifyAll方法来实现以上的需求。这是非常重要的。

/** * Java线程：并发协作-生产者消费者模型 */
public class Test {  public static void main(String[] args) {  Godown godown=new Godown(30);  Consumer c1=new Consumer(50,godown);  Consumer c2=new Consumer(20,godown);  Consumer c3=new Consumer(30,godown);  Producer p1=new Producer(10,godown);  Producer p2=new Producer(10,godown);  Producer p3=new Producer(10,godown);  Producer p4=new Producer(10,godown);  Producer p5=new Producer(10,godown);  Producer p6=new Producer(10,godown);  Producer p7=new Producer(80,godown);  c1.start();  c2.start();  c3.start();  p1.start();  p2.start();  p3.start();  p4.start();  p5.start();  p6.start();  p7.start();  }
}
/** * 仓库 */
class Godown{  public static final int max_size=100;//最大库存量  public int curnum;//当前库存量  Godown() {  }  Godown(int curnum){  this.curnum=curnum;  }  /** * 生产指定数量的产品 */  public synchronized void produce(int neednum){  //测试是否需要生产  while(neednum+curnum>max_size){  System.out.println("要生产的产品数量" + neednum +"超过剩余库存量" + (max_size - curnum) +"，暂时不能执行生产任务!");  try {  //当前的生产线程等待  wait();  } catch (InterruptedException e) {  e.printStackTrace();  }  }  //满足生产条件，则进行生产，这里简单的更改当前库存量  curnum+=neednum;  System.out.println("已经生产了"+neednum+"个产品，现仓储量为"+curnum);  //唤醒在此对象监视器上等待的所有线程  notifyAll();  }  /** * 消费指定数量的产品 */  public synchronized void consume(int neednum){  //测试是否可以消费  while(curnum<neednum){  try {  //当前的生产线程等待  wait();  } catch (InterruptedException e) {  e.printStackTrace();  }  }  //满足消费条件，则进行消费，这里简单的更改当前库存  curnum-=neednum;  System.out.println("已经消费了" + neednum +"个产品，现仓储量为" + curnum);  //唤醒在此对象监视器上等待的所有线程  notifyAll();  }
}
//生产者
class Producer extends Thread{  private int neednum;//生产产品的数量  private Godown godown;//仓库  Producer(int neednum, Godown godown) {  this.neednum = neednum;  this.godown = godown;  }  public void run(){  //生产指定数量的产品  godown.produce(neednum);  }
}
//消费者
class Consumer extends Thread{  private int neednum;//消费产品的数量  private Godown godown;//仓库  Consumer(int neednum, Godown godown) {  this.neednum = neednum;  this.godown = godown;  }  public void run(){  //消费指定数量的产品  godown.consume(neednum);  }
}

执行结果：

已经消费了20个产品，现仓储量为10
已经生产了10个产品，现仓储量为20
已经生产了10个产品，现仓储量为30
已经生产了10个产品，现仓储量为40
要生产的产品数量80超过剩余库存量60，暂时不能执行生产任务!
已经消费了30个产品，现仓储量为10
已经生产了10个产品，现仓储量为20
已经生产了10个产品，现仓储量为30
已经生产了10个产品，现仓储量为40
要生产的产品数量80超过剩余库存量60，暂时不能执行生产任务!

说明：

对于本例，要说明的是当发现不能满足生产或者消费条件的时候，调用对象的wait方法，wait方法的作用是释放当前线程的所获得的锁，并调用对象的notifyAll()方法，通知（唤醒）该对象上其他等待线程，使得其继续执行。这样，整个生产者、消费者线程得以正确的协作执行。

notifyAll() 方法，起到的是一个通知作用，不释放锁，也不获取锁。只是告诉该对象上等待的线程“可以竞争执行了，都醒来去执行吧”。

本例仅仅是生产者消费者模型中最简单的一种表示，本例中，如果消费者消费的仓储量达不到满足，而又没有生产者，则程序会一直处于等待状态，这当然是不对的。实际上可以将此例进行修改，修改为，根据消费驱动生产，同时生产兼顾仓库，如果仓不满就生产，并对每次最大消费量做个限制，这样就不存在此问题了，当然这样的例子更复杂，更难以说明这样一个简单模型。

Java线程：并发协作-死锁

线程发生死锁可能性很小，即使看似可能发生死锁的代码，在运行时发生死锁的可能性也是小之又小。

发生死锁的原因一般是两个对象的锁相互等待造成的。

在《Java线程：线程的同步与锁》部分，简述了死锁的概念与简单例子，但是所给的例子是不完整的，这里给出一个完整的例子。

/** * Java线程：并发协作-死锁 */
public class Test {  public static void main(String[] args) {  DeadlockRisk dead = new DeadlockRisk();  MyThread t1 = new MyThread(dead, 1, 2);  MyThread t2 = new MyThread(dead, 3, 4);  MyThread t3 = new MyThread(dead, 5, 6);  MyThread t4 = new MyThread(dead, 7, 8);  t1.start();  t2.start();  t3.start();  t4.start();  }
}  class MyThread extends Thread {  private DeadlockRisk dead;  private int a, b;  MyThread(DeadlockRisk dead, int a, int b) {  this.dead = dead;  this.a = a;  this.b = b;  }  @Override  public void run() {  dead.read();  dead.write(a, b);  }
}  class DeadlockRisk {  private static class Resource {  public int value;  }  private Resource resourceA = new Resource();  private Resource resourceB = new Resource();  public int read() {  synchronized (resourceA) {  System.out.println("read():" + Thread.currentThread().getName()  + "获取了resourceA的锁！");  synchronized (resourceB) {  System.out.println("read():" + Thread.currentThread().getName()  + "获取了resourceB的锁！");  return resourceB.value + resourceA.value;  }  }  }  public void write(int a, int b) {  synchronized (resourceB) {  System.out.println("write():" + Thread.currentThread().getName()  + "获取了resourceA的锁！");  synchronized (resourceA) {  System.out.println("write():"  + Thread.currentThread().getName() + "获取了resourceB的锁！");  resourceA.value = a;  resourceB.value = b;  }  }  }
}

执行结果：

read():Thread-1获取了resourceA的锁！
read():Thread-1获取了resourceB的锁！
write():Thread-1获取了resourceA的锁！
write():Thread-1获取了resourceB的锁！
read():Thread-3获取了resourceA的锁！
read():Thread-3获取了resourceB的锁！
write():Thread-3获取了resourceA的锁！
write():Thread-3获取了resourceB的锁！
read():Thread-2获取了resourceA的锁！
read():Thread-2获取了resourceB的锁！
write():Thread-2获取了resourceA的锁！
write():Thread-2获取了resourceB的锁！
read():Thread-0获取了resourceA的锁！
read():Thread-0获取了resourceB的锁！
write():Thread-0获取了resourceA的锁！
write():Thread-0获取了resourceB的锁！

Java线程详解(9)-并发协作相关推荐

java线程详解_Java线程详解
程序.进程.线程的概念程序(program):是为完成特定任务.用某种语言编写的一组指令的集合.即指一段静态的代码,静态对象. 进程(process):是程序的一次执行过程,或是正在运行的一个程序.动 ...
Java线程详解（深度好文）
Java线程:概念与原理一.进程与线程进程是指一个内存中运行的应用程序,每个进程都有自己独立的一块内存空间,即进程空间或(虚空间).进程不依赖于线程而独立存在,一个进程中可以启动多 ...
Java线程详解(17)-原子量
所谓的原子量即操作变量的操作是"原子的",该操作不可再分,因此是线程安全的. 为何要使用原子变量呢,原因是多个线程对单个变量操作也会引起一些问题.在Java5之前,可以通过vola ...
Java线程详解(16)-条件变量
条件变量是Java5线程中很重要的一个概念,顾名思义,条件变量就是表示条件的一种变量.但是必须说明,这里的条件是没有实际含义的,仅仅是个标记而已,并且条件的含义往往通过代码来赋予其含义. 这里的条件和 ...
Java线程详解(13)-锁
Java线程:新特征-锁(上) 在Java5中,专门提供了锁对象,利用锁可以方便的实现资源的封锁,用来控制对竞争资源并发访问的控制,这些内容主要集中在java.util.concurrent.lock ...
Java线程详解(8)-线程的同步
Java线程:线程的同步-同步方法线程的同步是保证多线程安全访问竞争资源的一种手段. 线程的同步是Java多线程编程的难点,往往开发者搞不清楚什么是竞争资源.什么时候需要考虑同步,怎么同步等等问题, ...
Java线程详解：wait、notify、notifyAll、join
线程的概念线程是进程的子任务,一个进程可以创建多个线程,线程不拥有系统资源,但是线程可以共享进程的资源,而线程自己也有一块独立的小块空间:包括堆栈,程序计数器和局部变量. 线程是CPU调度和分派的基 ...
Java线程详解(18)-障碍器
Java5中,添加了障碍器类,为了适应一种新的设计需求,比如一个大型的任务,常常需要分配好多子任务去执行,只有当所有子任务都执行完成时候,才能执行主任务,这时候,就可以选择障碍器了. 障碍器是多线程并 ...
Java线程详解(15)-阻塞队列和阻塞栈
Java线程:新特征-阻塞队列阻塞队列是Java5线程新特征中的内容,Java定义了阻塞队列的接口java.util.concurrent.BlockingQueue,阻塞队列的概念是,一个指定长度 ...

Java线程详解(9)-并发协作

Java线程：并发协作-生产者消费者模型

Java线程：并发协作-死锁

Java线程详解(9)-并发协作相关推荐

最新文章

热门文章