別名
- Actor
- Concurrent Object
適用的情況
actor是一個很抽象多線程模式, 每一個actor是線程獨立并且有屬于自己的狀態(tài), 多個actor互相發(fā)送消息以完成最終的任務. 你可以將actor模式理解為一個團隊, 這個團隊里面的個人就是一個運行在獨立線程上的個體, 由他們互相交流并且單獨處理自己的工作, 最后完成任務.
關于actor模式, 這里有一篇個人覺得很好的文章(英文)--The actor model in 10 minutes
實現(xiàn)的方式
構造一個ActiveObject類, 來充當actor角色, 有actor角色去完成任務, 并且完成交互.
相關的模式
- 實現(xiàn)actor角色會用到Worker Thread模式
- 將消息發(fā)送給actor時候,將消息放入隊列, actor從隊列中取消息進行處理, 用到了Producer-Consumer模式.
- 將處理結果返回給最終調用方需要用到Future模式.
代碼示例:
如果不用java.util.concurrent.*, 那么將會使本模式的代碼量很大, 閱讀體驗很差, 這里只考慮actor模式, 所以引入java.util.concurrent中已經(jīng)實現(xiàn)的部分類.(完全自己實現(xiàn)的版本:GitHub連接--Actor)
代碼中ActiveObject來進行處理任務, MakerClientThread發(fā)出生產字符串的消息交給activeObject進行生產,
DisplayClientThread發(fā)送打印字符串消息交給activeObject進行打印.
package com.graphic.activeObject.concurrent;
import java.util.concurrent.Future;
/**
* @author youngxinler 19-7-3 下午4:39
**/
public interface ActiveObject {
Future<String> makeString(int count, char fillChar);
void displayString(String string);
void shutdown();
}
package com.graphic.activeObject.concurrent;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
/**
* @author youngxinler 19-7-3 下午4:43
**/
public class ActiveObjectImpl implements ActiveObject {
private final ExecutorService service = Executors.newSingleThreadExecutor();
@Override
public Future<String> makeString(final int count, final char fillChar) {
class MakeStringRequest implements Callable<String> {
public String call() {
char[] buffer = new char[count];
for (int i = 0; i < count; i++) {
buffer[i] = fillChar;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
}
}
return new String(buffer);
}
}
return service.submit(new MakeStringRequest());
}
@Override
public void displayString(final String string) {
class DisplayStringRequest implements Runnable {
@Override
public void run() {
try {
System.out.println("display: " + string);
Thread.sleep(100);
} catch (InterruptedException e) {
}
}
}
service.submit(new DisplayStringRequest());
}
@Override
public void shutdown() {
service.shutdown();
}
}
package com.graphic.activeObject.concurrent;
/**
* @author youngxinler 19-7-3 下午4:43
**/
public class ActiveObjectFactory {
public static ActiveObject createActiveObject() {
return new ActiveObjectImpl();
}
}
package com.graphic.activeObject.concurrent;
import java.util.concurrent.Future;
/**
* @author youngxinler 19-7-3 下午4:38
**/
public class MakerClientThread extends Thread {
private final ActiveObject activeObject;
private final char fillChar;
public MakerClientThread(String s, ActiveObject activeObject) {
super(s);
this.activeObject = activeObject;
this.fillChar = s.charAt(0);
}
@Override
public void run() {
try {
for (int i = 0; true; i++) {
Future<String> future = activeObject.makeString(i, fillChar);
Thread.sleep(10);
String value = future.get();
System.out.println(Thread.currentThread().getName() + ": value = " + value);
}
} catch (Exception e) {
System.out.println(Thread.currentThread().getName() + ":" + e);
}
}
}
package com.graphic.activeObject.concurrent;
import java.util.concurrent.CancellationException;
import java.util.concurrent.RejectedExecutionException;
/**
* @author youngxinler 19-7-3 下午6:23
**/
public class DisplayClientThread extends Thread {
private final ActiveObject activeObject;
public DisplayClientThread(String name, ActiveObject activeObject) {
super(name);
this.activeObject = activeObject;
}
@Override
public void run() {
try {
for (int i = 0; true; i++) {
String s = Thread.currentThread().getName() + " " + i;
activeObject.displayString(s);
Thread.sleep(200);
}
} catch (RejectedExecutionException e) {
System.out.println(Thread.currentThread().getName() + ":" + e);
} catch (CancellationException e) {
System.out.println(Thread.currentThread().getName() + ":" + e);
} catch (InterruptedException e) {
System.out.println(Thread.currentThread().getName() + ":" + e);
}
}
}
package com.graphic.activeObject.concurrent;
/**
* @author youngxinler 19-7-3 下午6:32
**/
public class Main {
public static void main(String[] args) {
ActiveObject activeObject = ActiveObjectFactory.createActiveObject();
try {
new MakerClientThread("alice", activeObject).start();
new MakerClientThread("bobby", activeObject).start();
new DisplayClientThread("chris", activeObject).start();
} catch (Exception e) {
e.printStackTrace();
}
}
}
