一、生产者、消费者协作机制：
生产者线程和消费者线程通过共享队列进行协作，生产者将数据或任务放到队列上，而消费者从列队上取数据或任务，如果队列长度有限，在队列满的时候，生产者等待，而在队列为空的时候，消费者等待。
/**
* 使用两个栈 实现队列
*
* 生产者，消费者协作模式：
共享变量是一个阻塞队列，当队列满了生产者wait()，当队列为空消费者wait();
*
* 阻塞队列有：
* 接口：BlockingQueue、BlockingDeque 双端队列
* 基数数组的实现类：ArrayBlockingQueue
* 基于链表的实现类：LinkedBlockingQueue、LinkedBlockingDeque
* 基于堆的实现类：PriorityBlockingQueue
*
*/
public class QueueTest<E> {
private ArrayDeque<E> producerStack = null;
private ArrayDeque<E> consumerStack = null;
private static int num = 0;
public static void main(String[] args) throws InterruptedException {
QueueTest<String> eQueueTest = new QueueTest<>();
new Thread(new Runnable() {
@Override
public void run() {
try {
eQueueTest.producer();
Thread.sleep( (int)(Math.random() * 100));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
// Thread.sleep( (int)(Math.random() * 100));
new Thread(new Runnable() {
@Override
public void run() {
try {
eQueueTest.consumer();
Thread.sleep( (int)(Math.random() * 100));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
public QueueTest() {
producerStack = new ArrayDeque<>(10);
consumerStack = new ArrayDeque<>(10);
}
public synchronized void producer() throws InterruptedException {
while (true){
while(producerStack.size() == 10){
this.wait();
}
producerStack.addLast((E) String.valueOf(++num));
System.out.println("producerStack size :" + producerStack.size() );
for (E e : producerStack) {
System.out.println("producerStack..." + e.toString());
}
this.notifyAll();
}
}
public synchronized void consumer() throws InterruptedException {
while(true){
while(producerStack.isEmpty()){
this.wait();
}
consumerStack.addLast(producerStack.pollLast());
System.out.println("consumerStack size :" + consumerStack.size() );
for (E c : consumerStack) {
System.out.println("consumerStack..." + c.toString());
}
System.out.println("------------------------------------------------------------");
if(consumerStack.size() == 10){
while(consumerStack.size() > 0){
System.out.println("consumerStack,pollLast :" + consumerStack.pollLast().toString());
}
}
this.notifyAll();
}
}
}
二、同步协作机制：
在一些程序，尤其是模拟仿真程序中，要求多个线程同时开始。
/**
* 同步协作机制
*
*/
public class SynchronizationTest {
private volatile boolean fired = false;
public static void main(String[] args){
SynchronizationTest synchronizationTest = new SynchronizationTest();
new Thread(new Runnable() {
@Override
public void run() {
try {
//等待住线程唤醒
synchronizationTest.await();
System.out.println("thread 1: " + Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
try {
//等待住线程唤醒
synchronizationTest.await();
System.out.println("thread 2: " + Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
// 唤醒所有线程
synchronizationTest.fire();
}
public synchronized void await() throws InterruptedException {
while (!fired){
wait();
}
}
public synchronized void fire(){
this.fired = true;
notifyAll();
}
}
三、主从协作机制（等待结束、异步结果）：
主线程将任务分解为若干个子任务，为每个子任务创建一个线程，主线程在继续执行其他任务之前需要等待每个子任务执行完毕。
/**
* 等待所有子线程执行完毕，主线程再执行
*
* 协作对象
*
* 同步类：
* CountDownLatch
*
*/
public class MyLatch {
public static void main(String[] args) throws InterruptedException {
int countNum = 10;
CountDownLatch countDownLatch = new CountDownLatch(countNum);
for (int j = 0; j < countNum; j++){
new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println("countDownLatch : " + Thread.currentThread().getName());
Thread.sleep((int)(Math.random() * 100));
countDownLatch.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "thread" + j).start();
}
countDownLatch.await();
System.out.println("collect worker result");
}
}/**
* 主从模式，一种常见的模式是异步调用，异步调用返回一个Future对象，通过它获得最终的结果；
*
* 1.表示异步结果的接口 Future、FutureTask
*
* 2.用于执行异步任务的接口Executor,以及子接口ExecutorService
*
* 3.用于创建Executor和ExecutorService的工厂方法类Executors
*
* 4.Callable 创建子任务的接口
*
*/
public class AsynchronizationTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
ExecutorService executor = Executors.newCachedThreadPool();
List<MyFuture> myFutureList = new ArrayList<>();
for (int i = 1; i <= 10 ; i++) {
myFutureList.add(new MyFuture("callable " + i));
}
// 实现 callable 的子类实例
List<Future<String>> futures = executor.invokeAll(myFutureList);
System.out.println("futures size : " + futures.size());
futures.forEach(p -> {
try {
if(!p.isDone()){
System.out.println("future is not done ");
}
System.out.println("futures" + p.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
});
executor.shutdown();
}
/**
* 实现 Callable 接口
*/
static class MyFuture implements Callable<String> {
private String name;
public MyFuture(String name){
= name;
}
@Override
public String call() throws Exception {
return "callable " + name;
}
}
}
四、集合点协作机制：
给所有线程到指定一个集合点，当都到达时才继续执行下面的程序。
/**
* 多线程集合点协调模式
*/
public class CyclicBarrierTest {
public static void main(String[] args){
int num = 10;
CyclicBarrier cyclicBarrier = new CyclicBarrier(num, new Runnable() {
@Override
public void run() {
System.out.println("所有子线程已集合，继续执行任务..."); //所有线程集合后执行
}
});
for (int i = 1; i <= num; i++) {
new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep((int)(Math.random() * 100));
System.out.println(Thread.currentThread().getName() + " 等待集合...");
cyclicBarrier.await();
System.out.println(Thread.currentThread().getName() + " 已集合，继续执行...");
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}
}, "cyclicBarrier " + i).start();
}
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
