深入理解Java多线程—生产者消费者问题

最新推荐文章于 2022-06-04 22:16:26 发布

「已注销」

最新推荐文章于 2022-06-04 22:16:26 发布

阅读量85

点赞数

分类专栏： Java基础

本文链接：https://blog.csdn.net/m0_52286488/article/details/113855709

版权

Java基础专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一、创建消费者Pojo、生产者 Pojo和产品Pojo

二、使用阻塞队列BlockingQueue

三、使用synchronized同步方法

四、使用synchronized同步代码块

五、使用lock、condition

一、创建消费者Pojo、生产者 Pojo和产品Pojo

消费者类

/**
 * 
 */
package com.producerConsumer;

/**
 * 消费者
 * @author yyx
 * 2021年3月3日
 */
public class Consumer implements Runnable {
	private Warehouse warehouse;

	public Consumer(Warehouse warehouse) {
		super();
		this.warehouse = warehouse;
	}

	@Override
	public void run() {
		for (int i = 1; i <= 10; i++) {
			try {
				Thread.sleep(800);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			warehouse.removeProduct();
		}
	}
}

生产者

/**
 * 
 */
package com.producerConsumer;

/**
 * 生产者
 * @author yyx
 * 2021年3月3日
 */
public class Producer implements Runnable {
	private Warehouse warehouse;

	public Producer(Warehouse warehouse) {
		super();
		this.warehouse = warehouse;
	}

	@Override
	public void run() {
		for (int i = 1; i <= 10; i++) {
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			warehouse.addProduct();
		}
	}
}

产品类

/**
 * 
 */
package com.producerConsumer;

import java.util.UUID;

/**
 * 产品类
 * @author yyx
 * 2021年3月3日
 */
public class Product {
	// 产品唯一编码
	private UUID proCode;

	public Product(UUID proCode) {
		super();
		this.proCode = proCode;
	}

	public UUID getProCode() {
		return proCode;
	}

	public void setProCode(UUID proCode) {
		this.proCode = proCode;
	}
}

二、使用阻塞队列BlockingQueue

/**
 * 
 */
package com.producerConsumer;

import java.util.UUID;
import java.util.concurrent.BlockingQueue;

/**
 * @author yyx
 * 2021年3月3日
 */
public class Warehouse {
	private final int MAX_SIZE = 10;
	private BlockingQueue<Product> blockingQueue;

	public Warehouse(BlockingQueue<Product> blockingQueue) {
		super();
		this.blockingQueue = blockingQueue;
	}

	public void addProduct() {
		String currentName = Thread.currentThread().getName();
		if (blockingQueue.size() >= MAX_SIZE) {
			System.out.println("产品列表已满，不再生产！" + currentName + "进入等待");
		} else {
			Product product = new Product(UUID.randomUUID());
			System.out.println(currentName + "生产了一个产品，它的编号是：" + product.getProCode().toString());
			try {
				blockingQueue.put(product);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	public void removeProduct() {
		String currentName = Thread.currentThread().getName();
		if (blockingQueue.size() <= 0) {
			System.out.println("产品列表不足，不再消费！" + currentName + "进入等待");
		} else {
			try {
				Product product = blockingQueue.take();
				System.out.println(currentName + "消费了一个产品，它的编号是：" + product.getProCode().toString());
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

测试类

/**
 * 
 */
package com.producerConsumer;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

/**
 * @author yyx
 * 2021年3月3日
 */
public class ProducerConsumer {
	public static void main(String[] args) {
		BlockingQueue<Product> blockingQueue = new LinkedBlockingQueue<>(10);
		Warehouse warehouse = new Warehouse(blockingQueue);
		Producer producer = new Producer(warehouse);
		Consumer consumer = new Consumer(warehouse);
		new Thread(producer).start();
		new Thread(producer).start();
		new Thread(consumer).start();
	}
}

三、使用synchronized同步方法

/**
 * 
 */
package com.producerConsumer;

import java.util.List;
import java.util.UUID;

/**
 * @author yyx
 * 2021年3月3日
 */
public class Warehouse {
	private final int MAX_SIZE = 10;
	private List<Product> listProduct;

	public Warehouse(List<Product> listProduct) {
		super();
		this.listProduct = listProduct;
	}

	/**
	 * 生产产品
	 */
	public synchronized void addProduct() {
		String currentName = Thread.currentThread().getName();
		while (listProduct.size() >= MAX_SIZE) {
			try {
				System.out.println("产品列表已满，不再生产！" + currentName + "进入等待");
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		Product product = new Product(UUID.randomUUID());
		System.out.println(currentName + "生产了一个产品，它的编号是：" + product.getProCode().toString());
		listProduct.add(product);
		notifyAll();
	}

	/**
	 * 消费产品
	 */
	public synchronized void removeProduct() {
		String currentName = Thread.currentThread().getName();
		while (listProduct.size() <= 0) {
			try {
				System.out.println("产品列表不足，不再消费！" + currentName + "进入等待");
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		Product product = listProduct.get(0);
		System.out.println(currentName + "消费了一个产品，它的编号是：" + product.getProCode().toString());
		listProduct.remove(0);
		notifyAll();
	}
}

测试类

/**
 * 
 */
package com.producerConsumer;

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

/**
 * @author yyx
 * 2021年3月3日
 */
public class ProducerConsumer {
	public static void main(String[] args) {
		List<Product> listProduct = new ArrayList<Product>();
		Warehouse warehouse = new Warehouse(listProduct);
		Producer producer = new Producer(warehouse);
		Consumer consumer = new Consumer(warehouse);
		new Thread(producer, "生产者A").start();
		new Thread(producer, "生产者B").start();
		new Thread(consumer, "消费者C").start();
		new Thread(consumer, "消费者D").start();
	}
}

四、使用synchronized同步代码块

private final int MAX_SIZE = 10; // 最大数量
	private List<Product> listProduct;

	public Warehouse2(List<Product> listProduct) {
		super();
		this.listProduct = listProduct;
	}

	/**
	 * 生产产品
	 */
	public void addProduct() {
		synchronized (listProduct) {
			String currentName = Thread.currentThread().getName();
			while (listProduct.size() >= MAX_SIZE) { // 为了避免虚假唤醒，应该总是使用在循环中
				try {
					System.out.println("产品列表已满，不再生产！" + currentName + "进入等待");
					listProduct.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			Product product = new Product(UUID.randomUUID());
			System.out.println(currentName + "生产了一个产品，它的编号是：" + product.getProCode().toString());
			listProduct.add(product);
			listProduct.notifyAll();
		}
	}

	/**
	 * 消费产品
	 */
	public void removeProduct() {
		synchronized (listProduct) {
			String currentName = Thread.currentThread().getName();
			while (listProduct.size() <= 0) {
				try {
					System.out.println("产品列表不足，不再消费！" + currentName + "进入等待");
					listProduct.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			Product product = listProduct.get(0);
			System.out.println(currentName + "消费了一个产品，它的编号是：" + product.getProCode().toString());
			listProduct.remove(0);
			listProduct.notifyAll();
		}
	}

测试类

/**
 * 
 */
package com.producerConsumer;

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

/**
 * @author yyx
 * 2021年3月3日
 */
public class ProducerConsumer {
	public static void main(String[] args) {
		List<Product> listProduct = new ArrayList<Product>();
		Warehouse warehouse = new Warehouse(listProduct);
		Producer producer = new Producer(warehouse);
		Consumer consumer = new Consumer(warehouse);
		new Thread(producer, "生产者A").start();
		new Thread(producer, "生产者B").start();
		new Thread(consumer, "消费者C").start();
		new Thread(consumer, "消费者D").start();
	}
}

五、使用lock、condition

/**
 * 
 */
package com.producerConsumer;

import java.util.List;
import java.util.UUID;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

/**
 * @author yyx
 * 2021年3月3日
 */
public class Warehouse {
	private final int MAX_SIZE = 5;
	private List<Product> listProduct;
	private Lock lock;
	private Condition conditionProducer;
	private Condition conditionConsumer;

	public Warehouse(List<Product> listProduct, Lock lock, Condition conditionProducer, Condition conditionConsumer) {
		super();
		this.listProduct = listProduct;
		this.lock = lock;
		this.conditionProducer = conditionProducer;
		this.conditionConsumer = conditionConsumer;
	}

	/**
	 * 生产产品
	 */
	public void addProduct() {
		lock.lock();
		try {
			String currentName = Thread.currentThread().getName();
			while (listProduct.size() >= MAX_SIZE) { // 为了避免虚假唤醒，应该总是使用在循环中
				try {
					System.out.println("产品列表已满，不再生产！" + currentName + "进入等待");
					conditionProducer.await();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			Product product = new Product(UUID.randomUUID());
			System.out.println(currentName + "生产了一个产品，它的编号是：" + product.getProCode().toString());
			listProduct.add(product);
			conditionConsumer.signalAll();
		} finally {
			lock.unlock();
		}
	}

	/**
	 * 消费产品
	 */
	public void removeProduct() {
		lock.lock();
		try {
			String currentName = Thread.currentThread().getName();
			while (listProduct.size() <= 0) {
				try {
					System.out.println("产品列表不足，不再消费！" + currentName + "进入等待");
					conditionConsumer.await();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			Product product = listProduct.get(0);
			System.out.println(currentName + "消费了一个产品，它的编号是：" + product.getProCode().toString());
			listProduct.remove(0);
			conditionProducer.signalAll();
		} finally {
			lock.unlock();
		}
	}
}

测试类

/**
 * 
 */
package com.producerConsumer;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author yyx
 * 2021年3月3日
 */
public class ProducerConsumer {
	public static void main(String[] args) {
		List<Product> listProduct = new ArrayList<Product>();
		Lock lock = new ReentrantLock();
		Condition conditionProducer = lock.newCondition();
		Condition conditionConsumer = lock.newCondition();
		Warehouse warehouse = new Warehouse(listProduct, lock, conditionProducer, conditionConsumer);
		Producer producer = new Producer(warehouse);
		Consumer consumer = new Consumer(warehouse);
		new Thread(producer, "生产者A").start();
		new Thread(producer, "生产者B").start();
		new Thread(consumer, "消费者C").start();
		new Thread(consumer, "消费者D").start();
	}
}