多线程开发可以更好的发挥多核cpu性能,常用的多线程设计模式有:Future、Master-Worker、Guard
Susperionsion(保护性暂挂模式)、不变模式、生产者-消费者
模式;jdk除了定义了若干并发的数据结构,也内置了多线程框架和各种线程池;
锁(分为内部锁、重入锁、读写锁)、ThreadLocal、信号量等在并发控制中发挥着巨大的作用。
一、Future模型
1.什么是Future模型
该模型是将异步请求和代理模式联合的模型产物。见下图:
客户端发送一个长时间的请求,服务端不需等待该数据处理完成便立即返回一个伪造的代理数据(相当于商品订单,不是商品本身),用户也无需等待,先去执行其他的若干操作后,再去调用服务器已经完成组装的真实数据。该模型充分利用了等待的时间片段。
2.Future模式的核心结构:
Main:启动系统,调用Client发出请求;
Client:返回Data对象,理解返回FutureData(伪造的数据或未来数据),并开启ClientThread线程装配RealData(真实数据);
Data:返回数据的接口;
FutureData:Future数据,构造很快,但是是一个虚拟的数据,需要装配RealData;
RealData:真实数据,构造比较慢。
3.Future模式的代码实现:
(1)Main函数:
<span style="font-size:18px;">package tgb;
public class Main {
public static void main(String[] args){
Client client = new Client();
//理解返回一个FutureData
Data data = client.request("name");
System.out.println("请求完毕!");
try{
//处理其他业务
//这个过程中,真是数据RealData组装完成,重复利用等待时间
Thread.sleep(2000);
}catch (Exception e){
}
//真实数据
System.out.println("数据 = "+ data.getResult());
}
}
</span>
(2)Client的实现:
<span style="font-size:18px;">package tgb;
public class Client {
public Data request(final String queryStr){
final FutureData future = new FutureData();
//开启一个新的线程来构造真实数据
new Thread(){
public void run(){
RealData realData = new RealData(queryStr);
future.setRealData(realData); }
}.start();
return future;
}
}
</span>
(3)Data的实现:
<span style="font-size:18px;">package tgb;
public interface Data {
public String getResult();
}
</span>
(4)FutureData:
<span style="font-size:18px;">package tgb;
/**
* 是对RealData的一个包装
* @author limin
*
*/
public class FutureData implements Data {
protected RealData realData =null;
protected boolean isReady = false;
public synchronized void setRealData(RealData realData){
if(isReady){
return;
}
this.realData=realData;
isReady=true;
notifyAll();
}
@Override
public synchronized String getResult() {
while(!isReady){
try{
wait();
}catch (Exception e){
}
}
return realData.result;
}
}
</span>
(5)RealData实现:
<span style="font-size:18px;">package tgb;
public class RealData implements Data {
protected String result;
public RealData(String para){
//构造比较慢
StringBuffer sb= new StringBuffer();
for(int i=0;i<10;i++){
sb.append(para);
try{
Thread.sleep(1000);
}catch(Exception e){
}
result= sb.toString();
}
}
@Override
public String getResult() {
return result;
}
}
</span>
4.注意:
FutureData是对RealData的包装,是对真实数据的一个代理,封装了获取真实数据的等待过程。它们都实现了共同的接口,所以,针对客户端程序组是没有区别的;
客户端在调用的方法中,单独启用一个线程来完成真实数据的组织,这对调用客户端的main函数式封闭的;
因为咋FutureData中的notifyAll和wait函数,主程序会等待组装完成后再会继续主进程,也就是如果没有组装完成,main函数会一直等待。
二、Master-Worker模式
Master-Worker模式是常用的并行模式之一,它的核心思想是,系统有两个进程协作工作:Master进程,负责接收和分配任务;Worker进程,负责处理子任务。当Worker进程将子任务处理完成后,结果返回给Master进程,由Master进程做归纳汇总,最后得到最终的结果。
2.1什么是Master-Worker模式:
该模式的结构图:
结构图:
Worker:用于实际处理一个任务;
Master:任务的分配和最终结果的合成;
Main:启动程序,调度开启Master。
2.2代码实现:
下面的是一个简易的Master-Worker框架实现。
(1)Master部分:
[java] view plain copy
package MasterWorker;
import java.util.HashMap;
import java.util.Map;
import java.util.Queue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
public class Master {
//任务队列
protected Queue<Object> workQueue= new ConcurrentLinkedQueue<Object>();
//Worker进程队列
protected Map<String ,Thread> threadMap= new HashMap<String ,Thread>();
//子任务处理结果集
protected Map<String ,Object> resultMap= new ConcurrentHashMap<String, Object>();
//是否所有的子任务都结束了
public boolean isComplete(){
for(Map.Entry<String , Thread> entry:threadMap.entrySet()){
if(entry.getValue().getState()!=Thread.State.TERMINATED){
return false;
}
}
return true ;
}
//Master的构造,需要一个Worker进程逻辑,和需要Worker进程数量
public Master(Worker worker,int countWorker){
worker.setWorkQueue(workQueue);
worker.setResultMap(resultMap);
for(int i=0;i<countWorker;i++){
threadMap.put(Integer.toString(i), new Thread(worker, Integer.toString(i)));
}
}
//提交一个任务
public void submit(Object job){
workQueue.add(job);
}
//返回子任务结果集
public Map<String ,Object> getResultMap(){
return resultMap;
}
//开始运行所有的Worker进程,进行处理
public void execute(){
for(Map.Entry<String , Thread> entry:threadMap.entrySet()){
entry.getValue().start();
}
}
}
(2)Worker进程实现:
package MasterWorker;
import java.util.Map;
import java.util.Queue;
public class Worker implements Runnable{
//任务队列,用于取得子任务
protected Queue<Object> workQueue;
//子任务处理结果集
protected Map<String ,Object> resultMap;
public void setWorkQueue(Queue<Object> workQueue){
this.workQueue= workQueue;
}
public void setResultMap(Map<String ,Object> resultMap){
this.resultMap=resultMap;
}
//子任务处理的逻辑,在子类中实现具体逻辑
public Object handle(Object input){
return input;
}
@Override
public void run() {
while(true){
//获取子任务
Object input= workQueue.poll();
if(input==null){
break;
}
//处理子任务
Object re = handle(input);
resultMap.put(Integer.toString(input.hashCode()), re);
}
}
}
(3)运用这个小框架计算1——100的立方和,PlusWorker的实现:
package MasterWorker;
public class PlusWorker extends Worker {
@Override
public Object handle(Object input) {
Integer i =(Integer)input;
return i*i*i;
}
}
(4)进行计算的Main函数:
package MasterWorker;
import java.util.Map;
import java.util.Set;
public class Main {
/**
* @param args
*/
public static void main(String[] args) {
//固定使用5个Worker,并指定Worker
Master m = new Master(new PlusWorker(), 5);
//提交100个子任务
for(int i=0;i<100;i++){
m.submit(i);
}
//开始计算
m.execute();
int re= 0;
//保存最终结算结果
Map<String ,Object> resultMap =m.getResultMap();
//不需要等待所有Worker都执行完成,即可开始计算最终结果
while(resultMap.size()>0 || !m.isComplete()){
Set<String> keys = resultMap.keySet();
String key =null;
for(String k:keys){
key=k;
break;
}
Integer i =null;
if(key!=null){
i=(Integer)resultMap.get(key);
}
if(i!=null){
//最终结果
re+=i;
}
if(key!=null){
//移除已经被计算过的项
resultMap.remove(key);
}
}
}
}
2.3总结:
Master-Worker模式是一种将串行任务并行化的方案,被分解的子任务在系统中可以被并行处理,同时,如果有需要,Master进程不需要等待所有子任务都完成计算,就可以根据已有的部分结果集计算最终结果集。
三、生产者-消费模式
生产者-消费模式,通常有两类线程,即若干个生产者线程和若干个消费者线程。生产者线程负责提交用户请求,消费者线程负责具体处理生产者提交的任务。两者之间通过共享内存缓冲去进行通信。
3.1.架构模式图:
类图:
生产者:提交用户请求,提取用户任务,并装入内存缓冲区;
消费者:在内存缓冲区中提取并处理任务;
内存缓冲区:缓存生产者提交的任务或数据,供消费者使用;
任务:生产者向内存缓冲区提交的数据结构;
Main:使用生产者和消费者的客户端。
3.2代码实现一个基于生产者-消费者模式的求整数平方的并行计算:
(1)Producer生产者线程:
<span style="font-size:18px;">
package ProducerConsumer;
import java.util.Random;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
public class Producer implements Runnable{
//Volatile修饰的成员变量在每次被线程访问时,都强迫从共享内存中重读该成员变量的值。
//而且,当成员变量发生变化时,强迫线程将变化值回写到共享内存。
//这样在任何时刻,两个不同的线程总是看到某个成员变量的同一个值。
private volatile boolean isRunning= true;
//内存缓冲区
private BlockingQueue<PCData> queue;
//总数,原子操作
private static AtomicInteger count = new AtomicInteger();
private static final int SLEEPTIME=1000;
public Producer(BlockingQueue<PCData> queue) {
this.queue = queue;
}
@Override
public void run() {
PCData data=null;
Random r = new Random();
System.out.println("start producer id = "+ Thread .currentThread().getId());
try{
while(isRunning){
Thread.sleep(r.nextInt(SLEEPTIME));
//构造任务数据
data= new PCData(count.incrementAndGet());
System.out.println("data is put into queue ");
//提交数据到缓冲区
if(!queue.offer(data,2,TimeUnit.SECONDS)){
System.out.println("faile to put data: "+ data);
}
}
}catch (InterruptedException e){
e.printStackTrace();
Thread.currentThread().interrupt();
}
}
public void stop(){
isRunning=false;
}
} </span>
(2)Consumer消费者线程:
<span style="font-size:18px;">package ProducerConsumer;
import java.text.MessageFormat;
import java.util.Random;
import java.util.concurrent.BlockingQueue;
public class Consumer implements Runnable {
//缓冲区
private BlockingQueue<PCData> queue;
private static final int SLEEPTIME=1000;
public Consumer(BlockingQueue<PCData> queue) {
this.queue = queue;
}
@Override
public void run() {
System.out.println("start Consumer id= "+ Thread .currentThread().getId());
Random r = new Random();
try {
//提取任务
while(true){
PCData data= queue.take();
if(null!= data){
//计算平方
int re= data.getData()*data.getData();
System.out.println(MessageFormat.format("{0}*{1}={2}",
data.getData(),data.getData(),re
));
Thread.sleep(r.nextInt(SLEEPTIME));
}
}
} catch (InterruptedException e) {
e.printStackTrace();
Thread.currentThread().interrupt();
}
}
}
</span>
(3)PCData共享数据模型:
<span style="font-size:18px;">
package ProducerConsumer;
public final class PCData {
private final int intData;
public PCData(int d) {
intData=d;
}
public PCData(String d) {
intData=Integer.valueOf(d);
}
public int getData(){
return intData;
}
@Override
public String toString(){
return "data:"+ intData ;
}
}
</span>
(4)Main函数:
<span style="font-size:18px;">package ProducerConsumer;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingDeque;
public class Main {
/**
* @param args
*/
public static void main(String[] args) throws InterruptedException{
//建立缓冲区
BlockingQueue<PCData> queue = new LinkedBlockingDeque<PCData>(10);
//建立生产者
Producer producer1 = new Producer(queue);
Producer producer2 = new Producer(queue);
Producer producer3 = new Producer(queue);
//建立消费者
Consumer consumer1 = new Consumer(queue);
Consumer consumer2 = new Consumer(queue);
Consumer consumer3 = new Consumer(queue);
//建立线程池
ExecutorService service = Executors.newCachedThreadPool();
//运行生产者
service.execute(producer1);
service.execute(producer2);
service.execute(producer3);
//运行消费者
service.execute(consumer1);
service.execute(consumer2);
service.execute(consumer3);
Thread.sleep(10*1000);
//停止生产者
producer1.stop();
producer2.stop();
producer3.stop();
Thread.sleep(3000);
service.shutdown();
}
}
</span>
3.3注意:
volatile关键字:Volatile修饰的成员变量在每次被线程访问时,都强迫从共享内存中重读该成员变量的值。而且,当成员变量发生变化时,强迫线程将变化值回写到共享内存。这样在任何时刻,两个不同的线程总是看到某个成员变量的同一个值。
生产-消费模式的核心组件是共享内存缓冲区,是两者的通信桥梁,起到解耦作用,优化系统整体结构。
由于缓冲区的存在,生产者和消费者,无论谁在某一局部时间内速度相对较高,都可以使用缓冲区得到缓解,保证系统正常运行,这在一定程度上缓解了性能瓶颈对系统系能的影响。
四、不变模式
一个类的内部状态创建后,在整个生命期间都不会发生变化时,就是不变类
4.1 不变模式不需要同步
public final class Product {
//确保无子类
private final String no;
// 私有属性,不会被其他对象获取
private final String name;
//final保证属性不会被2次赋值
private final double price;
public Product(String no, String name, double price) {
//在创建对象时,必须指定数据
// super();
// 因为创建之后,无法进行修改
this.no = no;
this.name = name;
this.price = price;
}
public String getNo() {
return no;
}
public String getName() {
return name;
}
public double getPrice() {
return price;
}
}
4.2下面是JDK提供几种不变的模式
java.lang.String
java.lang.Boolean
java.lang.Byte
java.lang.Character
java.lang.Double
java.lang.Float
java.lang.Integer
java.lang.Long
java.lang.Short