并行程序设计模式

第一部分：概念层

1.Future模式：

客户端发送请求，由于某种原因，服务器对请求的速度很慢，导致客户端一直处于等待状态中，因为方法的执行是同步的，所以只能等到它处理完了之后才能进行其他的处理。而Future就是针对这种情形，它会快速创建一个虚拟对象，里面是不包含真实数据的。而在真正用到它的地方返回真实数据。而在返回真实数据前的一段时间，我们是可以进行其他操作的。

2、Master-worker模式：

是并行模式的一种。Master负责任务的接收与分配，而Worker负责处理子任务。当所有的Worker都处理完成之后，由Master进行归纳总结，返回结果。

M-W模式的好处是，将一个大任务分解为若干个小任务，并行执行，从而提高系统的吞吐量。

3、Guarded Suspension模式

Guarded Suspension是一种保护暂停模式，它的核心思想是在服务器进程准备好时，才提供服务。比如说：服务器在很短的时间内，有大量客户端请求，超过了服务器的负载，而服务器又不能丢弃任何一个客户请求。这时使用队列缓存，将所有请求放在队列里，等待服务器有空再从队列里面逐个取出处理。

4.不变模式：

当多线程对同一个对象进行读写操作时，为了保证对象数据的一致性和正确性，需要对对象进行同步，而同步操作对系统性能有损耗。这个时候使用对象的不变模式，能在无需同步的情况下保持数据的一致性。

5.生产者-消费者模式：

它是一个经典的多线程间协作的设计模式，它们通过共享内存缓存区进行通信，彼此无需知道对方的存在而进行间接通信，内存缓存区是一个Queue队列。

第二部分：代码层详解

一、Future模式

结构：

Client——>客户端发送请求；

Data——>数据接口

VirtualData——>虚拟返回数据，是RealData的装饰者

RealData——>真实的数据处理，及返回真实数据

Test——>测试

代码层：

①Test测试类：

package com.yanbo.threadpool;


public class Test {


public static void main(String[] args) {
Client client=new Client();
Data data=client.sendReuqest("check query");
System.out.println("request is over!");
try {
System.out.println("do other process!");
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("return the result to client "+data.getResult());
}
}

②Client发送请求

package com.yanbo.threadpool;


public class Client {

public Data sendReuqest(final String query){
final VirtureData data=new VirtureData();
new Thread(){
public void run() {
RealData real=new RealData(query);
data.setRealData(real);
};
}.start();
return data;
}

}

③Data数据接口

package com.yanbo.threadpool;


public interface Data {

public Object getResult();

}

④VIrture虚拟类，真实数据的包装类

package com.yanbo.threadpool;


public class VirtureData implements Data{


private RealData real=null;
private boolean isFinish=false;

public Object getResult() {
while(!isFinish){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
return real.result;
}

public synchronized void setRealData(RealData real){
if(isFinish) return;
this.real=real;
isFinish=true;
notifyAll();
}
}

⑤RealData真实数据处理类

package com.yanbo.threadpool;


public class RealData implements Data{


public Object result;

public Object getResult() {
return result;
}


public RealData(String str){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
result=new StringBuilder(str).toString();
}

}

2、Master-Worker简单的框架：

Master控制层

package com.yanbo.thread;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Queue;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;


public class Master {

//job queue
protected Queue<Object> jobQueue=new ConcurrentLinkedQueue<Object>();
//worker queue
protected Map<String, Thread> workQueue=new HashMap<String, Thread>();
//result queue
protected Map<String,Object> resultMap=new ConcurrentHashMap<String, Object>();


//check if finish
public boolean isComplete(){
Iterator<Map.Entry<String,Thread>> threads= workQueue.entrySet().iterator();
while(threads.hasNext()){
if(threads.next().getValue().getState()==Thread.State.TERMINATED)return true;
}
return false;
}

public Master(Worker worker,int number){
worker.setJobQueue(jobQueue);
worker.setResult(resultMap);
for (int j = 1; j <= number; j++) {
workQueue.put(Integer.toString(j), new Thread(worker, "The"+j+"thread"));
}
}

//add job
public void addJob(Object obj){
jobQueue.add(obj);
}

//get the execute result
public Map<String,Object> getResult(){
return resultMap;
}

//execute work
public void execute(){
for(Map.Entry<String, Thread> entity:workQueue.entrySet()){
entity.getValue().start();
}
}

}

Worker工作层：

package com.yanbo.thread;


import java.util.Map;
import java.util.Queue;


public class Worker implements Runnable{

protected Queue<Object> jobQueue;
protected Map<String, Object> result;
public Queue<Object> getJobQueue() {
return jobQueue;
}
public void setJobQueue(Queue<Object> jobQueue) {
this.jobQueue = jobQueue;
}
public Map<String, Object> getResult() {
return result;
}
public void setResult(Map<String, Object> result) {
this.result = result;
}

public Object handler(Object input){
return input;
}

public void run() {
while(true){
Object input = jobQueue.poll();
if(input==null) break;
Object obj=handler(input);
result.put(Integer.toString(input.hashCode()), obj);
}
System.out.println("OVER<><><><><>><><><><><><>><<><><>");
}

}

实际业务层：

package com.yanbo.thread;

public class ActrulyWorker extends Worker{

@Override
public Object handler(Object input) {
int i=(Integer) input;
return i*i*i;
}

}

main函数测试计算结果：

package com.yanbo.thread;

import java.util.Map;
import java.util.Set;
public class TestMaster {

public static void main(String[] args) {
long start=System.currentTimeMillis();
Worker worker=new ActrulyWorker();
Master master=new Master(worker, 10);
for (int i = 1; i <= 100; i++) {
master.addJob(i);
}
master.execute();
int result=0;
Map<String,Object> resultMap = master.getResult();
while(!master.isComplete()||resultMap.size()>0){
System.out.println(resultMap.size());
Set<String> keys =resultMap.keySet();
String key=null;
for (String k : keys) {
key=k;
break;
}
int i=0;
if(key!=null)
i=(Integer) resultMap.get(key);
if(i>0)
result+=i;
if(key!=null)
resultMap.remove(key);
}
System.out.println("The last result\t"+result);
System.out.println("Time:\t"+(System.currentTimeMillis()-start));
}

}

总结：Master类创建了10个线程，每个线程已启动，Master就会处理每个线程已经算出的结果，而不是等所有的线程都运行结束之后再计算结果。直到所有的线程都终止，Master才返回结果。

不变模式

通过final、private、无set方法，确定对象不能被修改，在多线程环境无需加同步操作

package com.yanbo.test;


public final class NoChange {

private final String name;
private final int age;

public NoChange(String name, int age) {
super();
this.name = name;
this.age = age;
}

public String getName() {
return name;
}
public int getAge() {
return age;
}

}