Java多线程设计
2013年11月28日

在我开发的报表引擎中 ,线程的运用颇多,而且是项目的核心。从最开始的线程设计,到目前为止的设计,有了很大的改进。

一、关于Thread和Runnable的选择
    我们知道用Runnable相对于用Thread有两个优势:
1. 避免继承的局限,采用Runnable接口的方式,不占用extends位置。
2. 适合于资源的共享,多个Thread可以共用一个Runnable对象。
    对于第1点,如果线程本身不需要继承其他类,则使用extends Thread更好,这样就可以直接调用很多操作线程的方法,也无需再多一个Runanble对象(见后面的例子)。对于第2点,资源共享是优点也是缺点。下面举个实际的例子:
【案例】
    我需要new一个线程去处理一个任务(task),同时我想把线程的引用(句柄)保存起来,以便后续对线程进行观察和控制。有两种实现方式:
方式一:

public static Map<String , Thread> threadMap;
......
MyTask task = new MyTask();
Thread thread01 = new MyThread(task);
threadMap.put("thread01", thread01);

直接用thread01即可调用线程的start、getState、isAlive等方法。
方式二:

public static Map<String , Thread> threadMap;
public static Map<String , WorkRunnable> workRunnableMap;
......
MyTask task = new MyTask();
WorkRunnable workRunnable01 = new WorkRunnable(task);
Thread thread01 = new Thread(workRunnable01); //用Thread包装Runnable
threadMap.put("thread01", thread01);
workRunnableMap.put("workRunnable01", workRunnable01);


用workRunnable01不能调用线程的方法,所以还需要把thread01也保存起来。

    显然,对于我这个简单的需求而言,方式一更好。
    所谓的资源共享是优点也是缺点,我也举一个例子来说明:
【案例】
    我想要给一个task(任务)分配一个worker(线程)去执行。可以这么写:
    Thread thread01 = new MyThread(task);
    thread01.start();
或者:
    WorkRunnable workRunnable = new WorkRunnable(task);
    Thread thread01 = new Thread(workRunnable);
    thread01.start();
    记住一点,采用Runnable的优势是什么?是可以在多线程中共用一个Runnable实例,以实现资源共享。例如:
    WorkRunnable workRunnable = new WorkRunnable(task);
    Thread thread01 = new Thread(workRunnable);
    Thread thread02 = new Thread(workRunnable); //线程1线程2共享一个workRunnable
    thread01.start();
    thread02.start();
    这就体现出了Runnable的优势,但是很可惜,我这个案例中,一个task只能由一个worker线程去执行,如果new了两个线程去执行同一个task,则会发生意想不到的后果。
    
    所以,在这个案例下,采用继承Thread的方式比采用实现Runnable的方式更好。
    结论:编写线程时,是采用继承Thread的方式,还是采用实现Runnable的方式,不能一概而论,要视情况而定。

    【个人经验】使用Runnable方式时,可以按照下面这个模板来编写:

public class WorkerRunnable implements Runnable {
    private Thread thisThread; //将Runnable对应的thread保存起来 -- 非常推荐
    private WorkerRunnable thisRunable; //将Runnable自身也保存起来  -- 可选,如果有需要
    @Override
    public void run() {
        thisThread = Thread.currentThread(); //指向当前的线程
        // do something
        ......
    }
    public Thread getThisThread() {
        return thisThread;
    }
    public void setThisRunable(WorkerRunnable thisRunable) {
        this.thisRunable = thisRunable;
    }
}

使用方式:
    WorkerRunnable wkRunnable = new WorkerRunnable();
    wkRunnable. setThisRunable(wkRunnable); //将自身保存起来
好处一:
    想要得到WorkerRunnable的Thread对象时,直接可以调用:
    wkRunnable. getThisThread();
    比如,获取线程的状态:wkRunnable. getThisThread().getState();
好处二:
    在WorkerRunnable的内部,可以使用自身的实例对象wkRunnable。
例如,在外部XxxClass中有一个:
    public static Map<String, WorkerRunnable> workRunnableMap;
在WorkerRunnable中,可以在线程运行完之后,从workRunnableMap中移除runnable:
    public void run() {
        // do something
        ......
        XxxClass.workRunnableMap.remove(thisRunable);
    }

    如果有需要,还可以把上面的thisThread和thisRunable变量定义成public static的,那么直接从WorkerRunnable即可调用它们。


二、增强线程的可控性(单线程和多线程通用)
1. 设置启停控制标志位
    以多线程,实现Runable接口为例。(单线程情况还要简单些,不再多说)
假设有:

public class WorkRunnable implements Runnable {
    public void run() {
        // do something
    }
}
WorkRunnable workRunnable = new WorkRunnable();
Thread thread01 = new Thread(workRunnable);
Thread thread02 = new Thread(workRunnable); //线程1线程2共享一个workRunnable
thread01.start();
thread02.start();

    那么想要控制所有加在workRunnable上的线程,可以通过workRunnable入手。但是如果想要控制单个线程thread01和thread02,则只能通过Thread自带的API去操作了。而坑爹的是,Thread自带的API有些是deprecated的,比如stop、destroy、suspend、resume。
    比如,假设workRunnable的run方法是循环运转的,即:
    public void run() {
        while(true){
            // do something
        }
    }
如果我想要停止所有加在workRunnable上的线程,则可以通过一个标识位来实现:
    /** 控制线程内的while循环,进而控制整个线程的启停 */
    private volatile boolean enabled = false;
    public synchronized boolean getEnabled(){ return enabled;}
    public synchronized void setEnabled(boolean enabled){ this.enabled = enabled;}
    public void run() {
        while( enabled ){
            // do something
        }
    }
    注意我上面的写法的每一个细节。我做了一个关于synchronized和volatile效率问题的简单测试,结果如下:
    ===调用setEnabled方法1亿次,执行耗时:===
    没有这两个关键字时:约0.080秒
    有这两个关键字时:约3.744秒
    单有volatile关键字时:约1.513秒
    单有synchronized键字时:约2.371秒
    我认为在一般情况下是用不着加这两个关键字的,因为当enabled改变时,线程本来就不会立即停止,换句话说线程的关闭对enabled的响应是“迟钝的”,enabled是不是线程同步的,对线程本身几乎不构成影响。但是,如果你的程序有可能在多处同时修改和读取enabled,特别是判断enabled状态后需要进行某些重要的后续操作时,就需要按照我上面的写法加上synchronized和volatile,一个都不能少。有人可能要问,加上了synchronized,为什么还有加上volatile呢?因为set了enabled之后并不一定能保证get时能及时获取到set后的enabled值。volatile关键字的使用,其本质是告诉编译器:不要为该变量保存一份线程内的副本,当变量更新时,直接更新到变量的实际共享存储区域(编译器为了提高效率,会为每个线程使用的变量创建了副本,这个副本只允许该线程访问,其他线程访问时,第一次读取的是变量在共享内存中的值,这个值有可能和其他线程内部的这个值不相等)。
    如果你的程序getEnabled()和setEnabled()不会同时执行,或者即使会同时执行,但getEnabled()不是为了做一些重要的后续处理,则用不着设置synchronized和volatile关键字。下面是我的写法,兼顾了安全、高效和实用:

private volatile boolean enabled = false; //为了安全,volatile关键字必须要
public boolean getEnabled(){ return enabled;} //一般读取时用这个get方法
public synchronized boolean getSynEnabled(){ return enabled;} //重要操作时用这个getSyn方法
public synchronized void setEnabled (boolean enabled){ this.enabled = enabled;}
public void run() {
    while( enabled ){
        // do something
    }
}

    另外注意到,网上有人将run方法的while写成while( getSynEnabled() ),这实际上是没有必要的,因为上面我已经分析了,run方法对enabled标识的响应本来就是“迟钝的”。
    另外还有一个通用的技巧。上面使用synchronized也好,使用volatile也罢,都是为了解决线程同步问题。假如上面的那些get和set方法都是别人写好的,而没有加synchronized,但是你又需要进行严格的同步操作,那怎么办呢?方法很简单,再在get和set方法上再自己包装一层。例如:

public class SynTool4WorkRunnable{
    private WorkRunnable workRunnable;
    public SynTool4WorkRunnable(WorkRunnable workRunnable){
        this.workRunnable = workRunnable;
    }
    public synchronized boolean getSynEnabled(){
        return workRunnable.getEnabled();
    }
    public synchronized void setSynEnabled (boolean enabled){
        workRunnable.setEnabled( enabled );
    }
}

    关于synchronized关键字,能不用就尽量不要用,因为不管它加在属性上,还是加在方法上,都是一个对象锁,只要一个地方锁住,整个对象都被锁住了(此处所说的对象分为两种,一种是静态对象,另一种是对象实例,各是各的锁,互不干扰)。建议对synchronized和volatile理解不深的人在使用这两个关键字之前,先进行深入的研究和试验。
    
2. 设置运行控制标志位(只针对单线程,实现Runnbale接口的多线程不适用)
    运行控制标志位如下:
    /** 线程当前的运行控制状态 */
    private volatile boolean runFlag = false;
    常规意义上讲,线程启动后,runFlag =false代表线程没有运行,runFlag=true代表线程正在运行。但是请注意,它只是一个控制标志位,不是用来观察、显示线程状态的。而且它也并不能准确的代表线程的实际状态(包括未启动、睡眠中、正常运行、已停止等,可以用thread.getState()获取)。
    用法如下:

public synchronized boolean getRunFlag(){ return runFlag;}
public synchronized void setRunFlag(boolean runFlag){ this.runFlag = runFlag;}
public void run() {
    // do something...
    runFlag = false; //标识现在运行已结束
}
//启动线程实例,(以Thread为例,Runable的方法类似)
public synchronized MyThread checkStart (){
    if( runFlag ){ throw new RuntimeException("已经启动");}
    MyThread thread = new MyThread();
    thread. setRunFlag(true);
    thread.start();
    return thread; //返回线程的引用
}

按照如下方式启动上面这个单线程:
    // 适用于在多处(即多线程)环境下启动该单线程
    myThread = myThread. checkStart ();
分析:
    如果当某个线程试图去启动myThread时,它会去争夺myThread.checkStart ()方法的使用权,如果已被其他线程抢占了先机,则它进入等待,直到其他线程释放锁。当它抢到锁,执行时却发现线程已经被启动了,则抛出异常,有效的避免了重复启动。同时,还有一个好处(也是这么设计程序的首要原因),注意到myThread.checkStart ()方法和myThread.getRunFlag()方法不能同时调用,所以使得下面这句话为真:
    “当在外面调用getRunFlag()得到runFlag = false时,那代表线程没有运行,因为runFlag = false说明了run()方法没有运行,或者run()方法已经执行完了最后那一条语句”。
    这是一个很重要的结论。另一方面,当runFlag = true时,说明什么呢?聪明的读者,你不要回答说“runFlag = true代表线程正在运行”,因为线程可能会在run方法的中途挂掉,例如从run方法的中部抛出了未捕获的异常,那么此刻runFlag = true但是线程已经死了。所以,线程有没有挂掉,不能根据runFlag = true来判断,可以用thread.isAlive()来判断。
    如果runFlag = true且thread.isAlive()=false,那说明什么呢?说明线程在我们的预期之外挂掉了,即使外层有个大大的try-catch,线程也可能异常挂掉。我们的runFlag现在又派上用场了。

总结runFlag的主要作用:
    一是“当runFlag = false时证明线程已经正常停止”,二是“当runFlag = true且thread.isAlive()=false时证明线程异常终止”。

三、停止线程的方法
1. 使用标志位
    上面已经讲了,如果线程内通过while来循环执行,则可以设置一个while( enabled )来控制线程的停止。这也是不得已的临时解决方法。这种方法很有局限性,它的前提是while循环体能够在一段时间内循环执行。如果while循环卡在了中部,则while( enabled )根本就起不到控制效果。
2. 使用线程自带的API方法
    按理说,可以用Thread自带的stop方法。但是,这是Java废弃的一个方法,存在安全隐患不说,通常情况下还没有效果。没效果,那还说什么……
3. 我研究出来的一个特殊方法
    网上找不到一个可用的方法,那就只能自己研究了。
    Thread的相关API我已经看完了,各种方法也亲自测试过,通常情况下,stop方法确实是无效的。我初步的想法,是通过制造异常来使线程停止。如下的写法是可行的:

/**
 * 强行杀死线程的方法
 * @param thread
 * @author zollty
 */
public static void stopThread(Thread thread){
    try {
        thread.setPriority(Thread.MIN_PRIORITY);
        thread.stop();
        thread.destroy();
    } catch (Throwable e) {
        DebugTool.println(thread.getName()+"线程被强行杀死...");
    }
}

    不看广告看疗效,经过测试,上面的方法能够安全有效的杀死线程。必须stop和destroy配合着使用。调用stop后,再调用destroy,会导致线程内部的异常,从而杀死线程(这只是一个推测)。第一句thread.setPriority并不是必须的,但是加上也无妨。至于它严格意义上的安全性,还有待考究,不过通常情况下应该不存在问题。
    还有一个笨拙但绝对安全有效的方法 ,适用于结束那种程序正常执行,且执行时间比较线性均匀的方法。在线程执行的方法体内部,在多处加上sleep方法,例如IO操作,假设我们的业务要求“这个线程只能执行1个小时,如果超过1个小时,则强行杀死这个线程”。那么我们怎么强行停止它呢?可以在IO操作的循环处,加上一个“隔一段时间就sleep”的机制,sleep如果失败则抛出异常,结束线程。那么到了一个小时后,如果线程还未停止,我们就在外面调用interrupted方法,到了sleep处,线程就会因为异常而结束了。