Java多线程设计模式-学习笔记-Thread Per Message模式.

1. 模式描述:

    每个消息/命令/请求分配一个线程, 有这个线程执行工作.
    使用该模式的时候"委托消息的端"与"执行消息的一端"会是不同的线程.

2. 模式参与者:
   
    2.1 Client(委托人)参与者:

         client参与者会对Host参与者发出请求(request). client参与者并不知道
         Host参与者会如何实现这个请求.

    2.2 Host参与者:

         当host参与者收到client参与者的请求(request),会建立新的线程并启动它.
         这个新的线程,会使用Helper参与者,"处理(handle)"这个请求.

    2.3 Helper(帮助者)参与者:

         Helper参与者会对Host参与者提供处理(handle)请求的功能.

3. 示例:

    3.1 ThreadPerMessageTest类 - Client参与者:

package com.quf.study.thread.threadPerMessage;

/** *//**
 * <strong>Title : ThreadPerMessageTest<br></strong>
 * <strong>Description : </strong>向Host发出显示信息请求的类.<br> 
 * <strong>Create on : 2008-5-8<br></strong>
 * <p>
 * <strong>Copyright (C) QUF Software Co.,Ltd.<br></strong>
 * <p>
 * @author renxin renxin777@126.com<br>
 * @version <strong>Java Thread Design Pattern Study</strong><br>
 * <br>
 * <strong>修改历史:</strong><br>
 * 修改人        修改日期        修改描述<br>
 * -------------------------------------------<br>
 * <br>
 * <br>
 */
public final class ThreadPerMessageTest ...{

    /** *//**
     * 构造函数
     */
    public ThreadPerMessageTest() ...{
        // TODO Auto-generated constructor stub
    }
    
    /** *//**
     * 方法描述
     * @param args
     */
    public static void main(String[] args)...{
        
        System.out.println("main Begin");
        
        Host t_host = new Host();
        
        t_host.request(10,'c');
        
        t_host.request(12, 'b');
        
        t_host.request(8, 'a');
        
        System.out.println("main End");
    }

}//END CLASS OF ThreadPerMessageTest.

    3.2 Host类 - Host参与者:

package com.quf.study.thread.threadPerMessage;

/** *//**
 * <strong>Title : Host<br>
 * </strong> <strong>Description : </strong>建立处理线程的类<br>
 * <strong>Create on : 2008-5-8<br>
 * </strong>
 * <p>
 * <strong>Copyright (C) QUF Software Co.,Ltd.<br>
 * </strong>
 * <p>
 * 
 * @author renxin renxin777@126.com<br>
 * @version <strong>Java Thread Design Pattern Study</strong><br>
 *          <br>
 *          <strong>修改历史:</strong><br>
 *          修改人 修改日期 修改描述<br>
 *          -------------------------------------------<br>
 *          <br>
 *          <br>
 */
public final class Host ...{

    private final Helper m_helper = new Helper();

    /** *//**
     * 构造函数
     */
    public Host() ...{
        // TODO Auto-generated constructor stub
    }

    /** *//**
     * 传送消息者.
     * 
     * @param count
     * @param c
     */
    public void request(final int count, final char c) ...{

        System.out.println(" request( " + count + " , " + c + " )Begin ");

        Thread t_tempThread = new Thread() ...{

            /**//*
             * (non-Javadoc)
             * 
             * @see java.lang.Thread#run()
             */
            public void run() ...{
                m_helper.handle(count, c);
            }
        };

        t_tempThread.start();
        
        System.out.println(" request( " + count + " , " + c + " )End ");
    }
}

    3.3 Helper类 - Helper参与者:

package com.quf.study.thread.threadPerMessage;

/** *//**
 * <strong>Title : Helper<br></strong>
 * <strong>Description : </strong>显示信息类.<br> 
 * <strong>Create on : 2008-5-8<br></strong>
 * <p>
 * <strong>Copyright (C) QUF Software Co.,Ltd.<br></strong>
 * <p>
 * @author renxin renxin777@126.com<br>
 * @version <strong>Java Thread Design Pattern Study</strong><br>
 * <br>
 * <strong>修改历史:</strong><br>
 * 修改人        修改日期        修改描述<br>
 * -------------------------------------------<br>
 * <br>
 * <br>
 */
public final class Helper ...{

    /** *//**
     * 构造函数
     */
    public Helper() ...{
        // TODO Auto-generated constructor stub
    }
    
    /** *//**
     * 处理信息.
     * @param count
     * @param c
     */
    public void handle(int count , char c) ...{
        System.out.println(" handle(" + count +" , " + c + " ) Begin " );
        
        for ( int i = 0 ; i < count ; i++ ) ...{
            slowly(1000);
            System.out.print(c);
        }
        
        System.out.println("");
        
        System.out.println(" handle(" + count + " , " + c + " ) End ");
        
    }
    
    /** *//**
     * 休眠线程.
     * @param sleepTime - 休眠的时间,毫秒.
     */
    private void slowly(long sleepTime)...{
        try ...{
            Thread.sleep(sleepTime);
        } catch (InterruptedException e) ...{
            // TODO: handle exception
        }
    }

}//END CLASS OF Helper.

4. 扩展思考:

    4.1 该模式提升了响应性, 降低了延迟的时间.

          由于Host参与者在收到请求后开启新的线程对请求进行处理,故Host参与者对Client参与者
       
          的响应性会提高,延迟时间会降低.

    4.2 该模式的适用情况:

          <1> 适合在操作顺序无所谓的时候.

          <2> 不需要返回值的时候.

          <3> 适合在服务器端并发处理请求.



5. 相关知识 - 进程和线程的区别 :

    进程和线程之间的关系会因为平台的差异(OS,硬件),有极大的不同,即使在相同的

    平台,进程与线程之间的关系也会因为Java虚拟机的实现方式而有所不同,不过一

    般而言,可以说一个进程里可以建立多条线程.

    最主要的区别:

    <1> 线程间的内存是共享的:

           进程与线程最大的差异在于内存能否共享.

           通常每个进程所拥有的内存空间是各自独立的.进程不能擅自读取,改写其他

           进程的内存空间.因为进程的内存空间是各自独立的.

           线程则是共享内存的.


    <2> 线程间的context-switch较容易:

           进程和线程另一个差异,在于context-switch的繁重程度.

           要切换执行中的线程时, 进程必须将现在自己的状态储存下来,并将下一个要开始执行的进

           程以前所保留的context数据读回来.这个信息的切换操作(context switch)需要花费一些

           时间.

           切换执行中的线程时, 线程与进程一样,需要进行context-switch的操作,然而线程所管理的

           context信息比进程要少很多,一般而言线程的context-switch比进程的context-switch

           快的多.