Thinking in java 之并发其三：线程的状态

一、线程的四种状态

在 java 中，一个线程可以处于下列四种状态之一：

  1）新建（new）：当线程被创建时，它会短暂的处于这种状态。在这种状态下时，线程已经分配了必需的系统资源，并执行了初始化。此刻线程已经有资格获得 cpu 时间了，之后调度器将把这个线程转变为就绪或阻塞状态。

  2）就绪（Runnable）：在这种状态下，只要调度器把时间片分给线程，线程就可以运行。也就是说，在这种状态下，线程是可以运行也可以不运行的。只要调度器把时间片分给线程，线程立刻可以运行。这是就绪状态与阻塞或死亡状态的区别。

  3）阻塞（Blocked）：线程能够运行，但有某个条件阻止了它的运行。当线程进入阻塞状态时，调度器将忽略线程，不会将 cpu 时间分配给它。一个任务进入到阻塞状态，通常有以下几个原因：

1. 通过调用 sleep() 使任务进入休眠状态；
2. 通过调用 wait() 使线程挂起；
3. 任务在等待某个输入/输出完成；
4. 任务试图在某个对象上调用其同步控制方法。

  4）死亡（dead）：该状态下，线程不可能再被调度，并且再也不会得到 cpu 时间，它的任务已结束。任务死亡的方式是从 run() 方法返回。

 

二、终结任务

在一些情况下，我们会希望我们的线程能够在运行一段时间后终止。一种做法是，在 Runnable 里添加一个状态标识码，通过这个状态码来控制任务是否继续进行或者结束。下面就是这种方法的一个例子：

package ThreadTest.SycnSourceTest.concurrency;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

class Count{
    private int count=0;
    private Random rand=new Random(47);
    public synchronized int increment() {
        int temp=count;
        if(rand.nextBoolean()) Thread.yield();
        return (count = ++temp);
    }
    public synchronized int value() {
        return count;
    }
}

class Entrance implements Runnable{

    private static Count count = new Count();
    private static List<Entrance> entrances = new ArrayList<Entrance>();
    private int number = 0;
    private final int id;
    private static volatile boolean canceled = false;
    public static void cancel() {canceled = true;}
    public Entrance(int id) {
        this.id = id;
        entrances.add(this);
    }
    
    @Override
    public void run() {
        while(!canceled) {
            synchronized(this) {
                ++number;
            }
            System.out.println(this+" total: " + count.increment());
            try {
                TimeUnit.MILLISECONDS.sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        System.out.println("Stopping "+this);
    }
    
    public synchronized int getValue(){return number;}
    public String toString() {
        return "Entrances " + id +": " + getValue();
    }
    public static int getTotalCount() {
        return count.value();
    }
    public static int sumEntrances() {
        int sum=0;
        for(Entrance entrance:entrances) {
            sum+=entrance.getValue();
        }
        return sum;
    }
}
public class OrnametalGarden {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService exec = Executors.newCachedThreadPool();
        for(int i=0;i<5;i++) {
            exec.execute(new Entrance(i));
        }
        TimeUnit.SECONDS.sleep(3);
        Entrance.cancel();
        exec.shutdown();
        if(!exec.awaitTermination(250, TimeUnit.MILLISECONDS))
            System.out.println("Some task were not terminated");
            System.out.println("Total: "+Entrance.getTotalCount());
            System.out.println("Sum of Entrances: "+Entrance.sumEntrances());
    }
}

我们通过布尔变量 cannel 来控制任务是否应该终止，当 main 的线程进行到某一时刻时，我们将 cannel 置为 true （此处的 cannel 是volatile 的，所以它的改变会立刻被其他任务捕捉到），从而终止所有正在进行的任务。

有趣的时，我们从结果中不难发现，计数器并不是递增的，它会出现跳跃的情况。1 2 4 3 6 5... 这说明，虽然某个任务得以先进行，但未必会第一个完成。

java 的 concurrency 包也为我们提供了中断线程的方法。在第一篇线程文章里，我们使用了 Future 实现了让 run() 返回特定类型的信息。Future 也可以帮我们实现中断线程的操作。

如果我们在使用 Excutor 来启动线程时，不使用 executor() 而是使用 submit()，我们就可以获得一个 Future<?> 。这个 Future 是持有任务的上下文的，我们可以通过它的 cancel 方法来实现中断线程的操作。

package ThreadTest.ThreadStatus;

import java.io.IOException;
import java.io.InputStream;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

class SleepBlocked implements Runnable{
    public void run() {
        try {
            TimeUnit.SECONDS.sleep(100);
        }catch(InterruptedException e) {
            System.out.println("Catch InterruptedExcetpion");
        }
        System.out.println("Exiting SleepBlocked run()");
    }
}

class IOBlocked implements Runnable{
    private InputStream in;
    public IOBlocked(InputStream is) {
        in = is;
    }
    public void run() {
        try {
            System.out.println("Waiting for read()");
            in.read();
        }catch(IOException e) {
            if(Thread.currentThread().isInterrupted()) {
                System.out.println("Interrupted from block I/O");
            }else {
                throw new RuntimeException(e);
            }
        }
        System.out.println("Exiting IOBlocked.run()");
    }
}

class SynchronizedBlocked implements Runnable{
    public synchronized void f() {
        while(true) {
            Thread.yield();
        }
    }
    public SynchronizedBlocked() {
        new Thread() {
            public void run() {
                f();
            }
        }.start();
    }
    public void run() {
        System.out.println("Trying to call f()");
        f();
        System.out.println("Exiting SynchronizedBlocked r()");
    }
} 
public class Inturrupting {
    
    public static ExecutorService exec = Executors.newCachedThreadPool();
    static void test(Runnable r) throws InterruptedException{
        Future<?> f = exec.submit(r);
        TimeUnit.MILLISECONDS.sleep(100);
        System.out.println("Interrupting "+r.getClass().getName());
        f.cancel(true);
        System.out.println("Interrupt sent to "+r.getClass().getName());
    }
    public static void main(String[] args) throws InterruptedException {
        // TODO Auto-generated method stub
        test(new SleepBlocked());
        test(new IOBlocked(System.in));
        test(new SynchronizedBlocked());
        TimeUnit.SECONDS.sleep(3);
        System.out.println("Aborting with system.exit(0)");
        System.exit(0);

    }

}

在这个示例中，我们一共对3中阻塞情况进行了中断任务操作。

对于 sleep() 引起的阻塞，在我们通过 Future 对其进行了中断操作之后，任务跑出了 InturruptedException 异常，证明了任务的确被中断。

另外两种情况（IO 阻塞和等待锁阻塞）我们并没有得到它们被中断的输出。这会导致一些问题，尤其是在创建 IO 的任务是，我们可能会被 IO 锁住多线程程序。

一个比较笨拙的解决方式是关闭任务在其上发生阻塞的底层资源。

（此处本该有示例，但是运行结果并没有符合预期，目前原因未知）

Java 的 IO 的 nio 类还为我们提供更加人性化 IO 中断操作。被阻塞的 nio 通道会自动的响应中断。

至于由于等待锁而造成的阻塞，Java 的 ReentrantLock 具备阻塞时中断的功能。

package ThreadTest.ThreadStatus;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class BlockedMutex{
    private Lock lock = new ReentrantLock();
    public BlockedMutex() {
        lock.lock();
    }
    
    public void f() {
        try {
            lock.lockInterruptibly();
            System.out.println("lock acquire in f()");
        }catch(InterruptedException e) {
            System.out.println("Interrupted from lock acquisitiong in f()");
        }
    }
}

class Blocked2 implements Runnable{
    BlockedMutex block = new BlockedMutex();
    public void run() {
        System.out.println("wait for f() in BlockedMuex");
        block.f();
        System.out.println("Broken out of blocked call");
    }
}
public class Interrupting2 {

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Blocked2());
        t.start();
        TimeUnit.SECONDS.sleep(1);
        System.out.println("Issuing t.interrupt()");
        t.interrupt();
    }

}

BlokedMutex 类的构造器会获取所创建对象上自身的 lock，并且我们没有在任何地方去释放这个锁。所以当其他任务想要调用 f() 时，将会因为Mutex不可获得而被阻塞。在Blcked2中，run() 方法总是在调用 f() 的地方停止。与 I/O 调用不同，interript() 可以打断被互斥锁阻塞的调用。

如果我们编写的程序有线程中断的可能，那么为了避免 run() 里面的循环能够检测到线程被中断并且正确退出（而不是通过抛出异常的方式退出）。检测的方式可以利用 Thread.interrupted() 实现：

package ThreadTest.ThreadStatus;

import java.util.concurrent.TimeUnit;

class NeedsCleanup{
    private final int id;
    public NeedsCleanup(int ident) {
        this.id = ident;
        System.out.println("NeedsCleanUp: " + id);
    }
    public void cleanup(){
        System.out.println("cleaning up " + id);
    }
    
}

class Blocked3 implements Runnable{
    private volatile double d = 0.0;
    @Override
    public void run() {
        try {
            while(!Thread.interrupted()) {
                NeedsCleanup n1 = new NeedsCleanup(1);
                try {
                    System.out.println("Sleeping");
                    TimeUnit.SECONDS.sleep(1);
                    NeedsCleanup n2 = new NeedsCleanup(2);
                    try {
                        System.out.println("Calculation");
                        for(int i=1;i<2500000;i++) {
                            d=d+(Math.PI+Math.E)/d;
                        }
                        System.out.println("Finished time-consuming operation");
                    }finally {
                        n2.cleanup();
                    }
                }finally{
                    n1.cleanup();
                }
            }
            System.out.println("Exiting via while() test");
        }catch(InterruptedException e) {
            System.out.println("Exiting via InterruptedException");
        }
        
    }
}
public class InterruptingIdiom {

    private static int tm = 1002;
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(new Blocked3());
        t.start();
        TimeUnit.MILLISECONDS.sleep(tm);
        t.interrupt();
    }

}

在这个示例中 NeedsCleanup 表示一个必须要做清理操作的类。我们使用 try-finally 来保证它的清理方法 cleanup 总是被调用。

通过调节 tm 的值，我们可以控制程序在 sleep 阶段或者在 calculation 阶段停止。当在 sleep 阶段停止时，任务会以抛出异常的方式退出，而在 calculation 阶段停止时，任务会在 while() 的判断处被中断。