java多线程设计模式全部源码:
类图
时序图
- Main.java
/**
* 生产者-消费者模式
*
* Main.java用到的java文件如下
* ProducerThread.java
* EaterThread.java
* Table.java用两种实现方式:
* 1.数组,自己实现同步
* 2.LinkedList容器,自己实现同步
* 3.ArrayBlockingQueue自带同步,所以不用自己同步
*
* @author csx
*
*/
public class Main {
public static void main(String[] args) {
Table table = new Table(6);
new EaterThread("eater 1", table).start();
new EaterThread("eater 2", table).start();
new EaterThread("eater 3", table).start();
new ProducerThread("maker 1", table).start();
new ProducerThread("maker 2", table).start();
new ProducerThread("maker 3", table).start();
}
}
- Table.java (版本一:用数组表示桌子容量)
/**
*此Table版本用数组,自己实现同步
* @author csx
*
*/
public class Table {
private String[] mBuffer; //模拟table的容量
private int mHead; //队列的头指针
private int mTail; //队列的尾指针
private int mCount; //队列中已有的蛋糕数量(table上现在有几个蛋糕)
public Table(int count) {
this.mBuffer = new String[count];
this.mHead = 0;
this.mTail = 0;
this.mCount = 0;
}
public synchronized void put(String cake) throws Exception {
while(mCount >= mBuffer.length) { //桌子已经放满蛋糕,需wait直到consumer取蛋糕
wait();
}
mCount++;
mBuffer[mTail] = cake;
mTail = (mTail + 1) % mBuffer.length;
System.out.println(Thread.currentThread().getName() +
" put " + cake + "... count=" + mCount);
notifyAll();
}
public synchronized void take() throws Exception {
while(mCount <= 0) {//桌子已经没有蛋糕,需wait直到producer取蛋糕
wait();
}
mCount--;
String cake = mBuffer[mHead];
System.out.println(Thread.currentThread().getName() + " eat "
+ cake + "... count=" + mCount);
mHead = (mHead + 1) % mBuffer.length;
notifyAll();
}
}
- EaterThread.java
import java.util.Random;
public class EaterThread extends Thread {
private Table mTable;
Random mRandom;
public EaterThread(String name, Table mTable) {
super(name);
this.mTable = mTable;
mRandom = new Random();
}
@Override
public void run() {
while(true) {
try {
mTable.take();
Thread.sleep(mRandom.nextInt(1000));
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
- ProducerThread.java
import java.util.Random;
public class ProducerThread extends Thread {
private Table mTable;
Random mRandom;
private static int mCakeId = 0;
public ProducerThread(String name, Table mTable) {
super(name);
this.mTable = mTable;
mRandom = new Random();
}
@Override
public void run() {
while(true) {
try {
Thread.sleep(mRandom.nextInt(1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
String cake = "No." + nextCakeId() + " maked by " + getName();
try {
mTable.put(cake);
} catch (Exception e) {
e.printStackTrace();
}
}
}
public static synchronized int nextCakeId() {
return mCakeId++;
}
}
结果图
Table的另外两种实现方式
Table.java (版本二:用LinkedList表示桌子容量,需要synchronized,其它类不用改变)
import java.util.LinkedList;
/**
* LinkedList容器自己实现同步
* @author csx
*
*/
public class Table {
int mTotal; //桌子的容量大小
private int mCount; //桌子上已经有的蛋糕数量
LinkedList<String> mCakes; //模拟桌子存放蛋糕
public Table(int count) {
this.mCount = 0;
this.mTotal = count;
mCakes = new LinkedList<>();
}
public synchronized void put(String cake) throws Exception {
while(mCount >= mTotal) { //桌子已放满蛋糕,需wait直到consumer取走至少一个蛋糕
wait();
}
mCount++;
mCakes.add(cake);
System.out.println(Thread.currentThread().getName() +
" put " + cake + "... count=" + mCount);
notifyAll();
}
public synchronized void take() throws Exception {
while(mCount <= 0) {//桌子已经没有蛋糕,需wait直到producer生产至少一个蛋糕
wait();
}
mCount--;
String cake = mCakes.remove();
System.out.println(Thread.currentThread().getName() + " eat " + cake + "... count=" + mCount);
notifyAll();
}
}
- 结果图
Table.java (版本三:用ArrayBlockingQueue表示桌子容量,不需要synchronized,其它类不用改变,注意:take()和put()的调用者不能加synchronized,加了会死锁!!!)
public class Table {
ArrayBlockingQueue<String> mArrayBlockingQueue; //模拟桌子存放蛋糕
public Table(int count) {
mArrayBlockingQueue = new ArrayBlockingQueue<>(count);
}
//take和put不能加synchronized,加了会死锁,因为ArrayBlockingQueue内部有加锁
public void put(String cake) throws Exception {
System.out.println(Thread.currentThread().getName() + " put " + cake
+ "... count=" + mArrayBlockingQueue.size());
mArrayBlockingQueue.put(cake);
}
//take和put不能加synchronized,加了会死锁,因为ArrayBlockingQueue内部有加锁
public void take() throws Exception {
String cake = mArrayBlockingQueue.take();
System.out.println(Thread.currentThread().getName() + " eat "
+ cake + "... count=" + mArrayBlockingQueue.size());
}
}
- 结果图
更高效的生产者和消费者模式
- 用ReentrantLock中的Condition.因为生产者线程和消费者线程使用不同的Condition,所以唤醒线程时:对于消费者线程,只需唤醒所有的生产者线程即可;对于生产者线程,只需唤醒所有的消费者线程即可。
Table.java代码:
import java.util.LinkedList;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Table {
int mTotal; //桌子的容量大小
private int mCount; //桌子上已经有的蛋糕数量
LinkedList<String> mCakes; //模拟桌子存放蛋糕
private Lock mLock = new ReentrantLock();
private Condition mProCondition = mLock.newCondition();
private Condition mConCondition = mLock.newCondition();
public Table(int count) {
this.mCount = 0;
this.mTotal = count;
mCakes = new LinkedList<>();
}
public /*synchronized*/ void put(String cake) throws Exception {
try {
mLock.lock();
while(mCount >= mTotal) { //桌子已放满蛋糕,需wait直到consumer取走至少一个蛋糕
// wait();
mProCondition.await();
}
mCount++;
mCakes.add(cake);
System.out.println(Thread.currentThread().getName() +
" put " + cake + "... count=" + mCount);
// notifyAll();
//由于只是唤醒消费者线程,所以可以写成mConCondition.signal();
mConCondition.signalAll();
} finally {
mLock.unlock();
}
}
public /*synchronized*/ void take() throws Exception {
try {
mLock.lock();
while(mCount <= 0) {//桌子已经没有蛋糕,需wait直到producer生产至少一个蛋糕
// wait();
mConCondition.await();
}
mCount--;
String cake = mCakes.remove();
System.out.println(Thread.currentThread().getName() + " eat " + cake + "... count=" + mCount);
// notifyAll();
//由于只是唤醒生产者线程,所以可以写成mProCondition.signal();
mProCondition.signalAll();
} finally {
mLock.unlock();
}
}
}
Main.java
import java.util.Random;
import java.util.concurrent.TimeUnit;
public class Main {
static int p1 = 1; //生产者线程1计数用
static int p2 = 1;//生产者线程2计数用
static Random sRandom = new Random();
public static void main(String[] args) {
final Table table = new Table(4);
//消费者
new Thread(()->{
while(true) {
try {
table.take();
doSleep();
} catch (Exception e) {
e.printStackTrace();
}
}
},"consumer1").start();
new Thread(()->{
while(true) {
try {
table.take();
doSleep();
} catch (Exception e) {
e.printStackTrace();
}
}
},"consumer2").start();
//生产者
new Thread(()->{
while(true) {
try {
table.put("No." + (p1++)
+ " make by " + Thread.currentThread().getName());
doSleep();
} catch (Exception e) {
e.printStackTrace();
}
}
},"producer1").start();
new Thread(()->{
while(true) {
try {
table.put("No." + (p2++)
+ " make by " + Thread.currentThread().getName());
doSleep();
} catch (Exception e) {
e.printStackTrace();
}
}
},"producer2").start();
}
public static void doSleep() {
try {
TimeUnit.MILLISECONDS.sleep(sRandom.nextInt(1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
结果图: