多线程程序设计学习(8)Thread-Per-Message

Thread-Per-Message【这个工作交给你模式】
一:Thread-Per-Message的参与者
--->Client(委托人)
--->host(中介开线程)
--->hepler(真正工作的工人)

二:Thread-Per-Message模式什么时候使用
--->提升响应时间,降低延迟时间
--->适合在操作顺序无所谓的时候
--->(委托人)不需要返回值的时候
--->应用在服务器的制作(我提供原材料,你加工,我不关心结果)
--->调用方法+启动线程--->完成某件事情(可以作为触发器)

三:Thread-Per-Message思考
--->进程和线程的区别
        ==>进程是工作在操作系统上的,线程是工作在进程中的。
        ==>进程的内存空间是独立的,不同的进程彼此独立,互不干扰
        ==>线程的内存空间是共享的,多个线程可以访问改写内存上的同一个对象
        ==>进程切换比较繁重,线程切换比较轻松。所以密切相关的事件,线程更合适

四进阶说明
--->java的内存模型中,将内存分为主存储器和工作内存两种。可让线程共享的,只有主存储器部分。

--->匿名内部类
        ==>匿名内部类是将类的声明与建立实例的操作写在一起。
        ==>虽然写在一起,也不是在执行方法时才建立出类文件。匿名内部类和一般类一样,都会在编译时生成类文件
        ==>匿名内部类中,用到方法的参数或局部变量时,必须将变量声明成final.如果不是,则编译错误

真正的工人

 1 package com.yeepay.sxf.thread7;
 2 /**
 3  * 执行任务的工人类
 4  * @author sxf
 5  *
 6  */
 7 public class Helper {
 8
 9     //任务就是将a打印b遍
10     public void handle(String a,int b) throws InterruptedException{
11         System.out.println(Thread.currentThread().getName()+"打印【"+a+"】开始");
12         for(int i=0;i<b;i++){
13             System.out.println("打印["+a+"]第["+(i+1)+"]遍");
14             Thread.sleep(1000);
15         }
16         System.out.println(Thread.currentThread().getName()+"打印【"+a+"】结束");
17
18     }
19 }

找工人开线程

 1 package com.yeepay.sxf.thread7;
 2 /**
 3  * 分发命令,找线程进行工作的类
 4  * @author sxf
 5  *
 6  */
 7 public class Host {
 8     //真正工作的工人
 9     private final Helper helper=new Helper();
10
11     //启动新线程,去工作的类
12     public void request(final String a,final int b){
13
14         System.out.println("request begin==>"+a);
15
16         //匿名内部类
17         new Thread(){
18
19             //线程体
20             @Override
21             public void run() {
22
23                 try {
24                     //真正执行的工作
25                     helper.handle(a, b);
26                 } catch (InterruptedException e) {
27                     // TODO Auto-generated catch block
28                     e.printStackTrace();
29                 }
30             }
31
32         }.start();
33
34
35         System.out.println("request end==>"+a);
36     }
37 }

主线程

 1 package com.yeepay.sxf.thread7;
 2 /**
 3  * 委托线程
 4  * @author sxf
 5  *
 6  */
 7 public class Test {
 8
 9     public static void main(String[] args) {
10             System.out.println("Test.main()主线程begin");
11             Host host=new Host();
12             host.request("尚晓飞", 10);
13             host.request("尚小帅", 10);
14             host.request("尚小燕", 10);
15             System.out.println("Test.main()主线程end");
16     }
17
18 }

时间: 2024-10-11 07:33:51

多线程程序设计学习(8)Thread-Per-Message的相关文章

多线程程序设计学习(2)之single threaded execution pattern

Single Threaded Execution Pattern[独木桥模式] 一:single threaded execution pattern的参与者--->SharedResource(共享资源) 二:single threaded execution pattern模式什么时候使用--->多线程程序设计时--->数据可被多个线程访问的时候--->共享资源状态可能变化的时候--->需要确保数据安全性的时候 三:single threaded execution p

多线程程序设计学习(6)Producer-Consumer模式

Producer-Consumer[生产消费者模式]一:Producer-Consumer pattern的参与者--->产品(蛋糕)--->通道(传递蛋糕的桌子)--->生产者线程(制造蛋糕的线程)--->消费者线程(吃掉蛋糕的线程) 二:Producer-Consumer pattern模式什么时候使用--->大量生产+大量消费的模式 三:Producer-Consumer pattern思考--->[生产消费者模式],肩负保护数据安全性使命的是通道参与者.通道参与

多线程程序设计学习(11)Two-phapse-Termination pattern

Two-phapse-Termination[A终止B线程] 一:Two-phapse-Termination的参与者--->A线程--->B线程 二:Two-phapse-Termination模式什么时候使用--->当A线程需要B线程终止时 三:Two-phapse-Termination思考       ---> 优雅的终止线程        (1)安全地终止(安全性)==>即使收到终止请求,也不会马上结束线程,而是表示收到终止请求的标识.以对象不被损坏为前提,安全终止

多线程程序设计学习(7)read-write lock pattern

Read-Write Lock Pattern[读写]一:Read-Write Lock Pattern的参与者--->读写锁--->数据(共享资源)--->读线程--->写线程 二Read-Write Lock Pattern模式什么时候使用---> * 为了多线线程环境下保护数据安全,我们必须避免的冲突 * 一个线程读取,另一个线程写入的read-write conflick * 一个线程写入,另一个线程写入的write-write conflick * 一个线程读取,另

多线程程序设计学习(5)balking模式和timed模式

Balking[返回模式]一:balking pattern的参与者--->GuardedObject(被警戒的对象) --->该模式的角色:模拟修改警戒对象的线程,当警戒条件达到执行具体操作的线程,参与者(被警戒的参与者) 二:balking pattern模式什么时候使用--->不需要刻意去执行什么操作的时候(比如说自动保存)--->不想等待警戒条件成立时.(不让线程休息)--->警戒条件只有第一次成立时候. 三:balking pattern思考--->balki

多线程程序设计学习(1)之多线程程序的评量标准

多线程程序的评量标准--->安全性[不损坏对象]        (1)不损坏对象是一种比喻手法,就是数据的一致性.比如银行的扣款操作,并发扣款,账户不会出现负数的余额.--->生存性[进行必要的处理]        (1)指也许不是现在,但一定会进行的必要处理.好比异常处理机制.在出现多线死锁等情况下的必要处理.--->复用性        (1)指可再利用的类,这不是必要条件,但却是体现程序质量重点条件.封装的意思.        (2)如果A类是一个已经确定可正常使用的软件程序的一部

多线程程序设计学习(13)Active Object pattern

Active Object[接收异步消息的对象] 一:Active Object的参与者--->客户端线程(发起某种操作请求处理)--->代理角色(工头)--->实际执行者(工人)--->主动对象接口(工人和工头)--->生产端线程(加工产品的线程)--->存放生产请求的队列(存放请求的队列)--->请求实例化(将方法的启动和执行分离的实例化包含)--->订单--->产品--->订单产品的共同接口 二:Active Object模式什么时候使用-

多线程程序设计学习(9)Future pattern

Future pattern[订单取货模式] 一:Future pattern的参与者--->Client(客户需求)--->Host(蛋糕门店)--->Data(票据和蛋糕的接口)--->Future(蛋糕票据)--->ReaData(制作蛋糕过程) 二:Future pattern模式什么时候使用---> 三:Future pattern思考       ---> 四进阶说明        ---> 数据类接口 1 package com.yeepay.

多线程程序设计学习(3)immutable pattern模式

Immutable pattern[坚不可摧模式] 一:immutable pattern的参与者--->immutable(不变的)参与者        1.1:immutable参与者是一个字段的值都无法更改的类.        1.2:immutable也没有任何用来更改字段值的方法.        1.3:immutable参与者方法不需要设置synchronized 二:immutable pattern模式什么时候使用--->当实例产生后,状态不再变化时        2.1实例状