Java中的多线程

多线程的简单实现过程：

(1)将任务处理代码移到实现了Runnable接口的类的run方法中。这个接口非常简单，只有一个方法：

public interface Runnable

{

void run();

}

实现这样一个类：

class MyRunnable implements Runnable

{

public void run()

{

}

}

创建一个这个类的对象：

Runnable r=new MyRunnable();

再由Runnable创建一个Thread对象：

Thread t=new Thread(r);

启动线程：

t.start();

(2)还有一种在代码书写上比较方便的方法，创建Thread类的子类。

class MyThread extends Thread

{

public void run()

{

}

}

创建这个类的一个对象，然后调用start方法。

注意，如果线程很少，可以使用以上方法，如果线程太多，建议使用线程池。

2009.5.23

线程的中断：

Java中线程是不能强制中断的，相反的，每一个线程都有一个中断状态标志位。当外部代码想终止某个线程时，可以调用这个线程的interrupt方法。调用后，此线程的中断状态标志位自动设置为真（isInterrupted()==true），如果此线程中有对中断状态标志位的判断，则可以决定是否响应中断请求。

以上是什么意思呢？就是说，线程会判断是否有人想中断自己，如果有人想中断，则自己可以决定是不是真的中断，如果这个线程非常重要，则完全可以不理会中断请求而继续执行。

所以，典型的线程代码如下：

while(!Thread.currentThread().isInterrupted())

{

}

当然，这个代码还不是全部的，因为，还有另一种情况没有处理，那就是，如果当前线程正在sleep或者wait怎么办呢？

当调用某线程的interrupt方法而此线程正在休眠时，将在此线程内部产生InterruptedException异常，以中断线程的sleep或者wait。其实我们发现在sleep时，Java强制要求加try，就是为了捕获这个异常。一个典型的sleep代码如下：

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

此时代码正在Thread.sleep(1000)这一行阻塞着呢，突然被interrupt，就跳到catch里了。

所以，一个线程的典型代码结构有两个，第一个是不经常sleep的：

public void run()

{

try

{

......

while(!Thread.currentThread().isInterrupted())

{

}

}

catch(InterruptedException e)

{

//在sleep或者wait的时候被中断，就会跳到这里

}

finally

{

//清理现场

}

}

以上代码，由于不经常使用sleep，所以要定期检查中断状态，来处理中断情况。

如果每一次循环都需要sleep的话，那这个isInterrupted检查就不是必需的了。因为，当代码sleep或wait时，被中断后将直接进入异常处理，如果不在sleep或者wait，那么当调用sleep或wait的时候，sleep或wait会检测到中断状态标志位为真而直接抛出异常。代码如下：

public void run()

{

try

{

......

while(expression)

{

Thread.sleep(delay);

}

}

catch(InterruptedException e)

{

//被中断了

}

finally

{

//清理现场

}

}

注意：当sleep抛出异常的同时会清除中断状态。

注意：有两个非常类似的方法，interrupted和isInterrupted。interrupted是一个静态方法，它检查当前线程是否已被中断。而且调用interrupted方法会清除该线程的中断状态。另一方面，isInterrupted方法是一个实例方法，可以用它来检查是否线程被中断了。调用它不改变中断状态值。

如果A线程想要等待B线程执行完毕后再执行，则可以这样：

B.join();

调用B的阻塞方法，将A阻塞掉，直到B返回。

在很多发布的代码中，我们经常看到InterruptedException异常被抑制在了一个很低的层次上，像这样：

void mySubTask()

{

......

try{sleep(delay);}

catch(InterruptedException e){}//这里不应该忽略处理代码

......

}

忽略错误处理是非常不可取的，如果不改动这个结构，则有两个比较合理的选择：

第一，在catch中加入Thread.currentThread().interrupt()设置中断状态，这样可以保证不破坏中断状态，这样调用者可以对其进行测试。

第二，更好的选择是，标记出我们的方法将抛出InterruptedException异常，不采用try语句块捕获异常。那么，调用者（或者，最终的run方法）就能够捕获该异常。

void mySubTask() throws InterruptedException

{

......

sleep(delay);

......

}

线程的状态：

线程有四个状态：

New（新生）：new出来还没有运行的线程，在运行之前还有一些工作要做。

Runnable（可运行）：这里包括两种状态，一种是正在运行，一种是有机会运行，但时间片还没有得到。

Blocked（被阻塞）：线程不能动了。

Dead（死亡）：有自然死亡（run执行完毕）和猝死（run出现异常而未被处理）两类。

注意：无法确定一个活着的线程是可运行的还是被阻塞了，也无法确定一个可运行的线程是否正在运行。另外，还无法区分死亡线程和非可运行线程。

线程的同步：

Java中的典型同步方式有两种：块同步和方法同步，两种方式都用到了synchronized关键字。

同步方法：

如果对一个类中的方法添加了synchronized关键字，它就成了同步方法，当一个线程调用这个同步方法的时候，另一个线程调用这个类的所有同步方法时都会阻塞，直到前一个线程调用完毕。

典型代码如下：

public synchronized void method()

{

}

同步块：

和VS一样，对某个引用类型对象上锁：

synchronized(s)

{

......

s.add();

......

}

wait和notify是object方法，而不是Thread的方法。wait可以让当前获得锁的线程暂时放弃，让其它正在阻塞的线程有机会执行。如果有wait，在代码的末尾一定要加notify或notifyAll，将放弃锁的线程惊醒。

wait一般用在两个或多个线程协作上。比如A、B两线程共同操作C，A线程处理C已经很长时间了，B却还没开始。如果需要AB两者执行差距不太大，则A可以先wait，让B有机会处理C。