Thread-per-Message模式（這項工作就交給你了）
當你很忙碌的時候，這個時候公司樓下有個快遞，於是你委託你的同事幫你拿一下你的快遞，這樣你就可以繼續做自己的工作了
在Thread-Per-Message模式中，消息的委託端和執行端是不同的線程，消息的委託端會告訴執行端線程，這個工作就交給你了
下面來看一段實例代碼:
Host類：
針對請求創建線程的類，主要通過開啓新的線程，調用helper的handle,並將要打印的文字傳遞。
public class Host {
private final Helper helper = new Helper();
public void request(final int count,final char c){
System.out.println("request開始");
new Thread(){
public void run(){
helper.handle(count, c);
}
}.start();
System.out.println("request結束");
}
}
Helper類：
提供字符顯示的功能，slowly方法模擬打印耗時
public class Helper {
public void handle(int count ,char c){
System.out.println("handle方法開始");
for(int i=0;i<count;i++){
slowly();
System.out.print(c);
}
System.out.println("");
System.out.println("handle方法結束");
}
private void slowly(){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
Main類：
創建Host的實例，並調用request的方法
public static void main(String[] args) {
System.out.println("main begin");
Host host = new Host();
host.request(10, 'A');
host.request(20, 'B');
host.request(30, 'C');
System.out.println("main End");
}
測試結果：
main begin
request方法開始了
request方法結束
request方法開始了
request方法結束
request方法開始了
request方法結束
main End
handle方法開始
handle方法開始
handle方法開始
BACBACACBACBACBACBACBACBACBA
handle方法結束
CBCBCBCBCBCBCBCBCBCBCB
handle方法結束
CCCCCCCCCC
handle方法結束
從運行的結果可以看出，request方法，並沒有等待handle方法執行結束後再執行，而是調用handle方法後就返回到request方法中，直到運行結束，所以相當於request方法將所要進行的打印一定數量字符的工作轉交給了handle方法，而request方法則可以再執行笨方法中的其他的語句，不必等待handle方法完成。這也同時告訴我們，當某些工作比較耗時時，則可以通過這種模式啓動新的線程來執行處理。可以將此模式應用於服務器，這樣就可以減少服務器的響應時間。
講解一下進程和線程：
線程和進程最大的區別就是內存是否共存。
每個進程有自己的獨立的內存空間，一個進程不可以擅自讀取和寫入其他的進程的內存，由於進程的內存空間是彼此獨立的，所以一個進程無需擔心被其他的進程所破壞。
線程之間是可以共存的，一個線程向實例中寫入內容，其他線程就可以讀取該實例的內容，由於多個線程可以訪問同一個實例，我們就需要保證其正確執行互斥處理。
Host設計優化：
1.使用java.util.concurrent包下的ThreadFactory接口設計Host類
public class Host {
public void request(final int count,final char c){
System.out.println("request方法開始了");
threadFactory.newThread(
new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
helper.handle(count, c);
}
}
).start();;
System.out.println("request方法結束");
}
}
對應的Host實例化對象：
Host host = new Host(Executors.defaultThreadFactory());
這樣設計的優勢在於，原來的使用new創建的實例代碼依賴於java.lang.Thread類，無法控制創建線程的部分，可複用性較低，假如使用threadFactory來保存對應類的對象，調用newThread方法創建新的線程，這樣便實現了線程的創建，這樣不再依賴於Thread類，而是取決於構造函數中傳入的ThreadFactory對象，實現了控制線程創建的細節。
使用java.util.concurrent.Executor接口重新設計Host類：
前面的ThreadFactory接口隱藏了線程創建的細節，但是並未隱藏線程創建的操作，如果使用Executor接口，那麼線程創建的操作也會被隱藏起來
public class Host{
private final Helper helper = new Helper();
private final Executor executor;
public Host(Executor executor){
this.executor = executor;
}
public void request(final int count,final char c){
System.out.println("request方法開始了");
executor.execute(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
helper.handle(count, c);
}
});
System.out.println("request方法結束");
}
}
使用java.util.concurrent.ScheduledExecutorService類創建，其可以實現調度運行
public class Host{
private final Helper helper = new Helper();
private final ScheduledExecutorService scheduledExecutorService;
public Host(ScheduledExecutorService scheduledExecutorService){
this.scheduledExecutorService = scheduledExecutorService;
}
public void request(final int count,final char c){
System.out.println("request方法開始了");
scheduledExecutorService.schedule(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
helper.handle(count, c);
}
}, 3L, TimeUnit.SECONDS);
System.out.println("request方法結束");
}
}
測試主函數入口：
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5);
Host host = new Host(
scheduledExecutorService
);
try {
host.request(10, 'A');
host.request(20, 'B');
host.request(30, 'C');
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
scheduledExecutorService.shutdown();
System.out.println("main End");
}
總結
Client 角色調用Host角色的request方法發來的請求，該請求的實際處理則交給Helper的handle去執行，然而，如果Client直接從request中調用handle方法，那麼直到實際操作結束之前，都無法從handle方法返回（request返回），這樣一來request的響應性能就下降了，因此，Host角色會啓動用於處理來自Client角色請求的新線程，並讓該線程來調用handle，這樣一來發出請求的線程便可以立即從handle中返回。這就是Thread-Per-Message模式。