java多线程Thread

java多线程Thread

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

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方法开始了XFsvym");

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方法返回（requestXFsvym返回），这样一来request的响应性能就下降了，因此，Host角色会启动用于处理来自Client角色请求的新线程，并让该线程来调用handle，这样一来发出请求的线程便可以立即从handle中返回。这就是Thread-Per-Message模式。

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方法开始了XFsvym");

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方法返回（requestXFsvym返回），这样一来request的响应性能就下降了，因此，Host角色会启动用于处理来自Client角色请求的新线程，并让该线程来调用handle，这样一来发出请求的线程便可以立即从handle中返回。这就是Thread-Per-Message模式。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。