文档章节

java基础---->线程 生产者消费者问题

小强斋太
 小强斋太
发布于 2016/11/09 20:07
字数 962
阅读 1
收藏 0

生产者和消费者问题是线程模型中的经典问题:生产者和消费者在同一时间段内共用同一个存储空间,如下图所示,生产者向空间里存放数据,而消费者取用数据,

如果不加以协调可能会出现以下情况:

存储空间已满,而生产者占用着它,消费者等着生产者让出空间从而去除产品,生产者等着消费者消费产品,从而向空间中添加产品。互相等待,从而发生死锁。

存储空间为空,而消费者占用着它,生产者等着消费者让出空间从而添加产品,消费者等着生产者生产产品,从而从空间中去除产品。互相等待,从而发生死锁。

JAVA解决线程模型的三种方式

1、wait()和notify()

import java.util.LinkedList;

public class ProducerConsumer {
    private LinkedList<Object> storeHouse = new LinkedList<Object>();
    private int MAX = 10;

    public ProducerConsumer() {
    }

    public void start() {
        new Producer().start();
        new Comsumer().start();
    }

    class Producer extends Thread {
        public void run() {
            while (true) {
                synchronized (storeHouse) {
                    try {
                        while (storeHouse.size() == MAX) {
                            System.out.println("storeHouse is full , please wait");
                            storeHouse.wait();
                        }
                        Object newOb = new Object();
                        if (storeHouse.add(newOb)) {
                            System.out.println("Producer put a Object to storeHouse");
                            Thread.sleep((long) (Math.random() * 3000));
                            storeHouse.notify();
                        }
                    } catch (InterruptedException ie) {
                        System.out.println("producer is interrupted!");
                    }

                }
            }
        }
    }

    class Comsumer extends Thread {
        public void run() {
            while (true) {
                synchronized (storeHouse) {
                    try {
                        while (storeHouse.size() == 0) {
                            System.out.println("storeHouse is empty , please wait");
                            storeHouse.wait();
                        }
                        storeHouse.removeLast();
                        System.out.println("Comsumer get  a Object from storeHouse");
                        Thread.sleep((long) (Math.random() * 3000));
                        storeHouse.notify();
                    } catch (InterruptedException ie) {
                        System.out.println("Consumer is interrupted");
                    }

                }
            }

        }
    }

    public static void main(String[] args) throws Exception {
        ProducerConsumer pc = new ProducerConsumer();
        pc.start();
    }
}

2、await()和signal(),即线程锁的方式

package sort;

import java.util.LinkedList;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ProducerConsumer {
    private LinkedList<Object> myList = new LinkedList<Object>();
    private int MAX = 10;
    private final Lock lock = new ReentrantLock();
    private final Condition full = lock.newCondition();
    private final Condition empty = lock.newCondition();

    public ProducerConsumer() {
    }

    public void start() {
        new Producer().start();
        new Consumer().start();
    }

    public static void main(String[] args) throws Exception {
        ProducerConsumer s2 = new ProducerConsumer();
        s2.start();
    }

    class Producer extends Thread {
        public void run() {
            while (true) {
                lock.lock();
                try {
                    while (myList.size() == MAX) {
                        System.out.println("warning: it's full!");
                        full.await();
                    }
                    Object o = new Object();
                    if (myList.add(o)) {
                        System.out.println("Producer: " + o);
                        empty.signal();
                    }
                } catch (InterruptedException ie) {
                    System.out.println("producer is interrupted!");
                } finally {
                    lock.unlock();
                }
            }
        }
    }

    class Consumer extends Thread {
        public void run() {
            while (true) {
                lock.lock();
                try {
                    while (myList.size() == 0) {
                        System.out.println("warning: it's empty!");
                        empty.await();
                    }
                    Object o = myList.removeLast();
                    System.out.println("Consumer: " + o);
                    full.signal();
                } catch (InterruptedException ie) {
                    System.out.println("consumer is interrupted!");
                } finally {
                    lock.unlock();
                }
            }
        }
    }

}

3、阻塞队列的方式

import java.util.concurrent.*;

public class ProducerConsumer {
    // 建立一个阻塞队列
    private LinkedBlockingQueue<Object> queue = new LinkedBlockingQueue<Object>(10);

    public ProducerConsumer() {
    }

    public void start() {
        new Producer().start();
        new Consumer().start();
    }

    public static void main(String[] args) throws Exception {
        ProducerConsumer s3 = new ProducerConsumer();
        s3.start();
    }

    class Producer extends Thread {
        public void run() {
            while (true) {
                try {
                    Object o = new Object();
                    // 取出一个对象
                    queue.put(o);
                    System.out.println("Producer: " + o);
                } catch (InterruptedException e) {
                    System.out.println("producer is interrupted!");
                }
                // }
            }
        }
    }

    class Consumer extends Thread {
        public void run() {
            while (true) {
                try {
                    // 取出一个对象
                    Object o = queue.take();
                    System.out.println("Consumer: " + o);
                } catch (InterruptedException e) {
                    System.out.println("producer is interrupted!");
                }
                // }
            }
        }
    }

}

三种方式原理一致,都是对独占空间加锁,阻塞和唤醒线程,第一种方式比较传统,第三种方式最简单,只需存储和取用,线程同步的操作交由LinkedBlockingQueue全权处理。

 

 

wait()和notify()其他例子

产品类

//生产的产品
public class Product {
	private  int productId;

	public Product(int productId) {
		this.productId = productId;
	}

	public int getProductId() {
		return productId;
	}

	public void setProductId(int productId) {
		this.productId = productId;
	}

	@Override
	public String toString() {
		return "product_"+productId;
	}
}

仓库类

import java.util.ArrayList;
import java.util.List;

public class StoreHouse {
	private static final Integer initialSize = 10;
	private List<Product> list = null;

	public StoreHouse() {

		this.list = new ArrayList<Product>(initialSize);

	}

	public synchronized void put(Product product) {
		if (list.size() == StoreHouse.initialSize) {
			try {
				System.out.println("仓库已满,等待消费者消费");
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

		list.add(product);
		System.out.println("放入仓库" + product);
		notifyAll();

	}

	public synchronized void get() {
		if (list.size() == 0) {
			try {
				System.out.println("仓库为空,等待生产者生产");
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		Product product = list.get(list.size()-1);
		System.out.println("从仓库取出" + product);
		list.remove(list.size()-1);
		notifyAll();
	}

}

生产者

public class Producer implements Runnable {

	StoreHouse storeHouse = null;

	public Producer(StoreHouse storeHouse) {
		this.storeHouse = storeHouse;
	}

	@Override
	public void run() {
		int i = 0;
		while (true) {

			Product product = new Product(++i);
			storeHouse.put(product);
			 try { 
	                Thread.sleep(1000); 
	            } catch (InterruptedException e) { 
	                return; 
	            } 

		}
	}

}

消费者

public class Consumer implements Runnable {

	StoreHouse storeHouse = null;

	public Consumer(StoreHouse storeHouse) {
		this.storeHouse = storeHouse;
	}

	@Override
	public void run() {
		int i = 0;
		while (true) {
			storeHouse.get();
			 try { 
	                Thread.sleep(1500); 
	            } catch (InterruptedException e) { 
	                return; 
	            } 
		}
	}

}


客户端测试

public class Client {

	public static void main(String[] args) {
		StoreHouse storeHouse = new StoreHouse();

		Runnable producer = new Producer(storeHouse);
		Runnable consumer = new Consumer(storeHouse);
		Thread produceThread = new Thread(producer);
		Thread consumeThread = new Thread(consumer);
		produceThread.start();
		consumeThread.start();
	}

}



 

 

本文转载自:http://www.cnblogs.com/xqzt/archive/2013/01/12/5637115.html

共有 人打赏支持
小强斋太
粉丝 0
博文 181
码字总数 0
作品 0
广州
Java并发基础你需要知道的基础知识

多线程和并发编程是Java里面的核心内容,通常有以下一些概念需要重点掌握。 线程; 锁; 同步器; 并发容器和框架; Java并发工具类; 原子操作类; Executor框架(执行机制); 并发基础概念 ...

异步社区
05/30
0
0
你真的懂wait、notify和notifyAll吗

生产者消费者模型是我们学习多线程知识的一个经典案例,一个典型的生产者消费者模型如下: 这段代码很容易引申出来两个问题:一个是wait()方法外面为什么是while循环而不是if判断,另一个是结...

A_客
06/03
0
0
java基础thread——java5之后的多线程(浅尝辄止)

承上启下 虽然我们可以理解同步代码块和同步方法的锁对象问题,但是我们并没有直接看到在哪里加上了锁,在哪里释放了锁,为了更清晰的表达如何加锁和释放锁,JDK5以后提供了一个新的锁对象L...

潇潇漓燃
06/03
0
0
ActiveMQ : Async error occurred: java.lang.OutO...

参考--http://activemq.apache.org/javalangoutofmemory.html 对于MQ的内容实用是可管理和可配置的。首先需要判断的是MQ的哪部分系统因内存不足而导致泄漏,是JVM,broker还是消费者、生产者...

hbdrawn
2011/06/28
0
0
Java并发面试,幸亏有点道行,不然又被忽悠了

前言 面试Java,必然要被问Java内存模型和Java并发开发。我被问到的时候,心里慌得一批,“额,是在《Thinking in Java》里面写的吗?果然每天增删改太low了” 要了解这些图吗? 我希望能解释...

codeGoogle
08/14
0
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

Spark core基础

Spark RDD的五大特性 RDD是由一系列的Partition组成的,如果Spark计算的数据是在HDFS上那么partition个数是与block数一致(大多数情况) RDD是有一系列的依赖关系,有利于Spark计算的容错 RDD中每...

张泽立
33分钟前
0
0
如何搭建Keepalived+Nginx+Tomcat高可用负载均衡架构

一.概述 初期的互联网企业由于业务量较小,所以一般单机部署,实现单点访问即可满足业务的需求,这也是最简单的部署方式,但是随着业务的不断扩大,系统的访问量逐渐的上升,单机部署的模式已...

Java大蜗牛
47分钟前
0
0
ffplay 播放 rtsp地址

D:\ffmpeg\ffmpeg\bin ffplay.exe 播放rtsp地址: ffplay.exe -rtsp_transport tcp "rtsp://ip:port/pag://172.16.0.11:7302:33000000001310001748:1:SUB:TCP?cnid=2&pnid=2&auth=50&streamf......

yizhichao
53分钟前
3
0
[Jekyll] permalink -- 修改文章的链接地址

在我的个人博客中访问这篇文章时,你有注意到地址栏中显示的地址吗?它应该是这样的: https://cometeme.github.io/jekyll/2018/08/Jekyll-为文章设置永久链接.html 。打开其他的文章,可以看...

cometeme
54分钟前
0
0
启动mango数据库批处理

::启动mango数据库set dbdir=c:\mongodb\dataif not exist %dbdir% md %dbdir%c:cd c:\mongodbmongod.exe --dbpath %dbdir%...

江湖令
今天
0
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

返回顶部
顶部