Java生产者消费者模式同步的问题

最新推荐文章于 2021-03-05 05:07:36 发布

er10hu

最新推荐文章于 2021-03-05 05:07:36 发布

阅读量341

点赞数

分类专栏： java java学习记录文章标签： Java多线程

本文链接：https://blog.csdn.net/er10hu/article/details/79118051

版权

java 同时被 2 个专栏收录

5 篇文章 0 订阅

订阅专栏

java学习记录

4 篇文章 0 订阅

订阅专栏

本文通过具体代码示例，深入探讨了生产者消费者模式中线程同步机制的应用，特别是Java中wait和notify方法的使用。文章展示了一个简单的消息队列实现，其中生产者线程不断向队列中添加元素，而消费者线程则从队列中移除元素。

摘要由CSDN通过智能技术生成

学习下生产者消费者模式下，线程同步的问题。当然对这些问题，Java已经在concurrent包下已经做了处理，以下代码仅仅为了学习下多线程wait和notify。

import java.util.concurrent.ArrayBlockingQueue;

public class ProducerAndConsumer {
	public static void main(String[] args) {
		System.out.println("program start");
		MessageQueue<Object> queue = new MessageQueue<Object>(10000);
		Thread prodThread = new ProducerThread(queue);
		Thread consThread = new ConsumerThread(queue, prodThread);
		prodThread.start();
		consThread.start();
		if (consThread.isAlive() && prodThread.isAlive()) {
			System.out.println("all thread has started and running.");
		}
	}
}

class MessageQueue<T> extends ArrayBlockingQueue<T> {
	private int capacity;

	public MessageQueue(int capacity) {
		// TODO Auto-generated constructor stub
		super(capacity);
		this.capacity = capacity;
	}

	/**
	 * 
	 */
	private static final long serialVersionUID = -8900156905307830983L;

	@Override
	public void put(T e) throws InterruptedException {
		// TODO Auto-generated method stub
		if (size() < capacity) {
			super.put(e);
			return;
		}

		synchronized (this) {
			if (size() > capacity) {
				wait();
				super.put(e);
				return;
			}
		}
		super.put(e);
	}

	@Override
	public T remove() {
		// TODO Auto-generated method stub
		if (size() < capacity && size() > 0) {
			return super.remove();
		}

		T t = null;
		while (size() > 0) {
			synchronized (this) {
				t = super.remove();
				notify();
			}
		}
		return t;
	}
}

class ConsumerThread extends Thread {
	MessageQueue<Object> queue;
	Thread producerThread;

	public ConsumerThread(MessageQueue<Object> queue, Thread producerThread) {
		// TODO Auto-generated constructor stub
		this.queue = queue;
		this.producerThread = producerThread;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		while (producerThread.isAlive()) {
			if (queue.size() > 0) {
				Object obj = queue.remove();
				System.out.println("consum: " + obj.toString() + " size: " + queue.size());
			}
		}
	}
}

class ProducerThread extends Thread {
	MessageQueue<Object> queue;

	public ProducerThread(MessageQueue<Object> queue) {
		// TODO Auto-generated constructor stub
		this.queue = queue;
	}

	@SuppressWarnings("deprecation")
	@Override
	public void run() {
		// TODO Auto-generated method stub
		int i = 0;
		while (true) {
			try {
				queue.put(i++);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				Thread.currentThread().stop();
			}
		}
	}
}