Java线程

 

 

1. 并发：进程与线程

 

关于并发，一个最直观的例子就是你可以同时 听歌还能上网，能用Word。即使在同一个程序中，也可能要同时完成多个任务，比如音乐播放器，你一边听着一首歌，另一边还同时下载其他歌曲，你还想改变 一下外观，这些任务之所以能完成，就是基于并发的概念。Java语言从语言级别到API都提供了对并发的支持。

 

即使计算机只有一个单核的处理器，也经常存 在多个进程和线程。操作系统的时间片机制为多进程和多线程提供支持，此时在具体的某一个，只有一个线程能执行任务，但是由于时间片切换非常快，给人感觉好 像同时运行的样子。现在多处理器和多核单处理器越来越普遍，可以实现真正意义上的并发。但是要记住，即使是单个处理器，多个核也能实现并发。

 

1.1 进程

 

进程有自己独立的运行环境，包括完整的 系统资源，尤其是用于自己独立的内存空间。进程经常和应用程序（application、program）等同，但实际上一个应用程序背后可能有多个进程 存在，进程之间通过Inter Process Communication（IPC）机制进行通信，比如管道（pipes）和套接字（sockets）。IPC不仅用于同一台机器上的进程通信，也支持 不同机器上的进程之间的通信。Java虚拟机的实现一般都是单个进程，Java程序可以使用ProcessBuilder对象创建多个进程。多进程 Java程序不在这里讨论。

 

1.2 线程

 

线程存在于进程中，每个进程至少有一个 线程。同一个进程内的线程共享进程资源，比如内存空间、打开的文件等。线程也被称为轻量级进程，“轻量级”是指创建一个线程所需要的系统资源开销比进程 小，另外，线程之间的切换开销也比进程间小。这使得程序更加高效，但是由于共享进程资源，也可以导致问题，比如不同步。每个线程都定义了单独的执行路径， 是能够调度的最小代码单元。

 

2. 创建线程

 

在Java中创建线程一般有两种方式。1）实现Runnable接口，把要在线程中执行的代码放在run方法当中，然后将Runnable作为Thread的构造参数传递给Thread构造器。2）拓展Thread类，重写run方法执行想要的程序片段。

 

2.1 实现Runnable接口

 

Runnable接口定义了唯一的run方法，通过在自己的类中实现这一接口，然后将Runnable实例传递给线程类Thread构造函数。下面的代码中实现了一个FirstRunnable的类，实现了Runnable接口的run方法。简单输出一条语句。

 

<span style="font-family:SimHei;font-size:14px;">public class FirstRunnable implements Runnable {

    /*
     * The code to be executed in thread
     */
    @Override
    public void run() {
        System.out.println("I am born from: "
                + Thread.currentThread().getName());
        // 线程的静态方法都是针对当前线程的操作

    }

}</span>

实现完Runnable接口之后，在主线程中创建一个新的线程：

 

<span style="font-family:SimHei;font-size:14px;">public class Schedule {

    /**
     * @param args
     * @throws InterruptedException
     */
    public static void main(String[] args) throws InterruptedException {
        // create  a new thread from main thread
        Thread thread = new Thread(new FirstRunnable());
        thread.start();
        //thread.join();

        System.out.println("I am from: " + Thread.currentThread().getName());

    }

}

</span>

创建线程后，调用线程的start方法启动线程。这样，我们就实现了一个最简单的多线程程序。

 

2.2 继承Thread

 

除了实现Runnable接口以外，还可以直接继承Thread类，重写run方法。

 

<span style="font-family:SimHei;font-size:14px;">/**
 * @author Brandon B. Lin
 *
 */
public class SubclassThread extends Thread {

    @Override
    public void run() {
        System.out.println("I am born from: " + Thread.currentThread().getName());
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        SubclassThread thread = new SubclassThread();
        thread.start();

        System.out.println("I am born from: " + Thread.currentThread().getName());

    }

}
</span>

注意我们启动线程调用的是start方法，而不是run方法，如果我们直接调用run方法也没有问题，但是你会发现run方法中的代码不是在新的线程中执行的，而是在主线程中执行的，也就没有多线程的概念了。

 

2.3 选择哪一种方式

 

我们来看看Thread类的构造器和run方法是如何工作的，为什么可以选择这两种方式。第一种方法中，向Thread构造器传递了要执行的目标代码，这个构造器代码如下：

 

<span style="font-family:SimHei;font-size:14px;">    public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }</span>

我们发现它调用了某个内部方法，再来看看直接继承的情况下创建Thread对象的构造函数，

 

<span style="font-family:SimHei;font-size:14px;">    public Thread() {
        init(null, null, "Thread-" + nextThreadNum(), 0);
    }</span>

发现它们原来都调用同一个方法，知识参数不一样而已。那么它们要执行的代码又是怎么回事？对于第一种方式，传递Runnable对象，看一下Thread类的run方法：

 

<span style="font-family:SimHei;font-size:14px;">    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }</span>

由于Thread类实现了Runnable接口，所以必须实现run方法，在这个方法内部，如果我们传递了目标代码Runnable，它简单地调用目标的run方法。如果我们直接创建一个Thread对象，什么都不传递，此时这个线程什么也不执行。

 

当我们继承Thread类重写run方 法的时候，线程运行的就是run方法的代码，因此，这两种方式本质上都是一回事。那么到底实践中应该选择哪种方式？JDK给出的建议是，只有当类正在以某 种方式增强或者修改时，才应该对类进行拓展。因此，如果不重写Thread类中run之外的方法，最好的方式是实现Runnable接口。这样可以把线程 执行的代码和对线程的控制分离开来，是一种很好的编程风格。具体地，Thread类中还定义了其他一些管理线程的方法，比如start方法用于启动线 程，getName获取线程名字，getID获取线程ID等。这些方法都是对线程的管理和控制，而线程具体执行的内容，在Runnable的run方法定 义，这种分离，把任务实体和执行任务的实体分开，使得代码更加清晰，更加容易复用和维护。（这应该是一种设计模式，应该好好研究！）

 

另外，如果通过继承Thread类，也就意味着不能再继承其他的类。而实现Runnable接口，仍然允许我们继承其他类，这也是一个优点。

 

3. Thread类的几个方法

 

Thread类提供了多种形式的构造函数，除此以外还定义了一些用于管理的使用方法。这些方法大致上可以分为两类：静态和非静态。静态方法提供当前线程的一些信息或者影像当前线程的状态。所谓的当前线程，就是调用该方法的线程。比如我们在run方法中调用静态方法：

 

<span style="font-family:SimHei;font-size:14px;"> @Override
    public void run() {
        System.out.println("I am born from: "
                + Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        // 线程的静态方法都是针对当前线程的操作

    }</span>

调用Thread.sleep使得当前线程休眠一秒，也就是调用run方法的线程休眠一秒钟。当前就是指执行当前代码（比如Thread.sleep(1000)）的线程，理解这一点很重要。

 

对于Thread中的非静态方法，它们是由其他线程调用，用于管理线程对象。比如在main方法中：

 

<span style="font-family:SimHei;font-size:14px;"> public static void main(String[] args) throws InterruptedException {
        // create  a new thread from main thread
        Thread thread = new Thread(new FirstRunnable());
        thread.start();
        //thread.join();

        System.out.println("I am from: " + Thread.currentThread().getName());

    }</span>

对于创建的新线程thread，我们在主线程中调用它的start方法，用于启动该线程。

 

理解这两类方法的区别很重要，程序中的所有代码，都有一个特定的线程来执行它，单线程程序中就是由主线程执行。

 

3.1 Thread构造函数

 

Thread提供了多种构造函数。可以指定线程执行的Runnable目标、线程名称、线程所属线程组等。这里先列出没有指定线程组的几个构造函数，

 

<span style="font-family:SimHei;font-size:14px;">    public Thread()
    public Thread(Runnable target)
    public Thread(String name) </span>

<span style="font-family:SimHei;font-size:14px;">    public Thread(Runnable target, String name)</span>

其中target为线程要执行的目标代码，name为线程名称。

 

3.2 Thread方法

 

3.2.1 sleep：暂停当前线程

 

Thrad.sleep方法用于暂停当前线程的执行一段时间，给其他线程或者同一台电脑上的其他程序（进程）让出运行时间。这个方法有两种不同的重载形式：

 

<span style="font-family:SimHei;font-size:14px;">    public static native void sleep(long millis)        throws InterruptedException;
    public static void sleep(long millis, int nanos)    throws InterruptedException</span></span></span>

注 意到第一个方法是本地（native），而其实第二种形式也是通过调用第一种形式来完成的。方法两种方式都是将当前线程暂停一段时间，具体时间由参数决 定，第二种方法更精确一点。但是要注意的是，跟I/O中读入数据的方法类似，这里的时间也只是我们期望的，具体暂停多长时间，受到许多因素影响。比如操作 系统提供的时钟精度无法达到参数中的级别，那么暂时的时间将出现误差。另外，处于睡眠状态的线程可能会被中断，此时抛出 InterruptedException异常。

 

下面的例子每次循环中暂停主线程（当前线程）4秒：

 

<span style="font-family:SimHei;font-size:14px;"> public class SleepMessages {
    public static void main(String args[])
        throws InterruptedException {
        String importantInfo[] = {
            "Mares eat oats",
            "Does eat oats",
            "Little lambs eat ivy",
            "A kid will eat ivy too"
        };

        for (int i = 0;
             i < importantInfo.length;
             i++) {
            //Pause for 4 seconds
           Thread.sleep(4000);
            //Print a message
            System.out.println(importantInfo[i]);
        }
    }
}</span>

3.2.2 中断

 

中断是一种信号，用于提醒被中断的线程停下手头正在做的事情，转而做些其他事情。如何处理中断取决于我们的代码，但是结束线程是很常见的一种方式，或者用其他方式处理中断。下面是一个中断的例子，一个线程休眠10秒，主线程调用它的interrupt方法中断：

 

<span style="font-family:SimHei;font-size:14px;">public class FirstRunnable implements Runnable {

    /*
     * The code to be executed in a separately thread
     */
    @Override
    public void run() {
        System.out.println("I am born from: "
                + Thread.currentThread().getName());
        try {
            Thread.sleep(10_000);
        } catch (InterruptedException e) {
            System.out.println("Oh My God. I am interrupted!");
        }
        // 线程的静态方法都是针对当前线程的操作

    }

}

        public static void main(String[] args) throws InterruptedException {
        // create  a new thread from main thread
        Thread thread = new Thread(new FirstRunnable());
        thread.start();
        thread.interrupt();


    }</span>

出现中断异常是被中断的一个标志，但是没有抛出中断异常的线程也可以被中断，尤其是执行很费时的操作时，应该是不是地检查线程是否被中断，通过调用静态方法Thread.interrupted()检测当前线程是否被中断。看例子：

 

<span style="font-family:SimHei;font-size:14px;">/**
 * @author Brandon B. Lin
 *
 */
public class HeavyRunnable implements Runnable {


    @Override
    public void run() {
        for (int i=0; i<20; i++) {
            heavyWorh("" + i);
            if (Thread.interrupted()) {
                System.out.println("I am interrupted!");</span>

<span style="font-family:SimHei;font-size:14px;">                 return;
            }
        }

    }

    // do something taking long time
    private void heavyWorh(String input) {
        for(int i = 0; i 500_000_000; i ++) {
            new String(input);
        }
    }

}

</span>

<span style="font-family:SimHei;font-size:14px;"> public static void main(String[] args) throws InterruptedException {
        // create  a new thread from main thread
        Thread thread = new Thread(new HeavyRunnable());
        thread.start();
        Thread.sleep(2_000);
        thread.interrupt();

    }</span>

执 行heavyWork是一个比较费时的工作（注意这里循环次数一定要足够大，否则被中断之前它早就处理完了），每次调用这个费时的方法时，都检测一下当前 是不是被中断了，如果中断，就返回。更复杂的应用中，我们也许不是简单地返回，而是抛出异常，然后在异常处理中做更复杂的工作。

<span style="font-family:SimHei;font-size:14px;">if (Thread.interrupted()) {
    throw new InterruptedException();
}</span>

中断状态标记：

 

线程中断机制是通过内部一个叫中断状态标记来实现的。如果调用静态方法Thread.interrupted()，这个标记被清零，但是如果调用实例方法isInterrupted()查询某个线程的状态，该线程的中断标记不会改变。看一下源码：

 

<span style="font-family:SimHei;font-size:14px;">  public boolean isInterrupted() {
        return isInterrupted(false);
    }</span>

<span style="font-family:SimHei;font-size:14px;"> public static boolean interrupted() {
        return currentThread().isInterrupted(true);
    }</span>

<span style="font-family:SimHei;font-size:14px;">    private native boolean isInterrupted(boolean ClearInterrupted);</span>

前两个方法都调用最后一个方法。最后的方法是个本地方法，它检测线程是否被中断，返回，并且根据参数决定是否将标记清零。实例方法isInterrupted（）只是查询是否中断，而不对标记为产生影响，即：

 

如果在查询之前为false，则返回false，并保持状态位不变还是false。

 

如果状态为查询之前为true，返回true，一样保持状态位为true。

 

而对于interrupted这个静态方法，情况不一样：

 

如果查询之前为false，则返回false，且保持false不变。

 

如果查询之前为true，则返回true，并且将状态标记清零，即变为false。

 

另外，抛出InterruptedException异常一般也将标记清零。

 

3.2.3 Join方法

 

实例方法用于等待某个线程完成

 

 

http://blog.csdn.net/bingduanlbd/article/details/28872817