thread-per-message模式（这项工作就交给你了）
当你很忙碌的时候，这个时候公司楼下有个快递，于是你委托你的同事帮你拿一下你的快递，这样你就可以继续做自己的工作了
在thread-per-message模式中，消息的委托端和执行端是不同的线程，消息的委托端会告诉执行端线程，这个工作就交给你了
host类：
针对请求创建线程的类，主要通过开启新的线程，调用helper的handle,并将要打印的文字传递。
|
1
2
3
4
5
6
7
8
9
10
11
12
|
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方法模拟打印耗时
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
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 blocke.printstacktrace();}}} |
main类：
创建host的实例，并调用request的方法
|
1
2
3
4
5
6
7
8
|
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类
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public class host {public void request(final int count,final char c){system.out.println("request方法开始了");threadfactory.newthread(new runnable() {@overridepublic void run() {// todo auto-generated method stubhelper.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接口，那么线程创建的操作也会被隐藏起来
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
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() {@overridepublic void run() {// todo auto-generated method stubhelper.handle(count, c);}});system.out.println("request方法结束");}} |
使用java.util.concurrent.scheduledexecutorservice类创建，其可以实现调度运行
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
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() {@overridepublic void run() {// todo auto-generated method stubhelper.handle(count, c);}}, 3l, timeunit.seconds);system.out.println("request方法结束");}} |
测试主函数入口：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
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 blocke.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模式。
原文链接：https://blog.csdn.net/qq_31350373/article/details/80454306
