多线程——java实现多线程的方式

1、线程和进程
要理解多线程，我们必须首先弄清楚线程和进程的概念。在上一篇博文总已经较为详细的介绍过，本篇博文只做总结。

进程就是运行的程序，每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1–n个线程。

线程是程序执行的最小单位，同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换开销小。

线程和进程可以分为五个阶段：创建、就绪、运行、阻塞、终止。
多进程是指操作系统能同时运行多个任务（程序）。
多线程是指在同一程序中有多个顺序流在执行。

2、Java线程的五种基本状态

关于Java中线程的生命周期，首先看一下下面这张较为经典的图：

上图中基本上囊括了Java中多线程各重要知识点。主要包括：

新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread();

就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行；

运行状态（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。注：就 绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中；

阻塞状态（Blocked）：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才 有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同，阻塞状态又可以分为三种：

（1）等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；

（2）同步阻塞 – 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态；

（3）其他阻塞 – 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

3、Java多线程实现方式

Java多线程实现方式主要有三种：继承Thread类、实现Runnable接口和使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，最后一种是带返回值的。

3.1 继承Thread类实现多线程
继承Thread类的方法尽管被我列为一种多线程实现方式，但Thread本质上也是实现了Runnable接口的一个实例，它代表一个线程的实例，并且，启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法。这种方式实现多线程很简单，通过自己的类直接extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。例如：

import org.testng.annotations.Test;

/**
 * 使用继承Thread类方式实现
 * new一个thread或者写个thread子类，覆盖它的run方法。(new 一个thread并覆盖run方法实际上是匿名内部类的一种方式)
 * 继承Thread类，重写该类的run()方法
 *
 *
 * 使用Thread类模拟3个售票窗口共同卖10张火车票的程序
 *
 * 没有共享数据，每个线程各卖10张火车票
 *
 */

public class ThreadTest {
    @Test
    public  void main(){

//        //1、第一种实现方法
//        //不共享数据，各自卖各自的，共30
//        for(int i = 0; i < 3; i++) {
//            System.out.println("---------------" + i + "---------");
//            new Thread() {
//                @Override
//                public void run() {
//                    int tickets = 10;
//                    while (tickets > 0) {
//                        System.out.println(this.getName() + "卖出第【" + tickets-- + "】张火车票");
//                    }
//                }
//            }.start();
//        }


        //2、第一种实现方法
        //2.1 不共享数据，各自卖各自的，共30
//        for(int i = 0; i < 3; i++){
//            System.out.println(Thread.currentThread().getName()  + "--------" + i);
//            //创建一个新的线程  myThread  此线程进入新建状态
//            Thread myThread = new MyThread();
//            //调用start()方法使得线程进入就绪状态
//            //此时此线程并不一定会马上得以执行，这取决于CPU调度时机
//            //CPU调度就绪状态中的哪个线程具有一定的随机性
//            myThread.start();
//
//            //new Thread(new MyThread()).start();
//        }

        // 1.2  不共享数据，各自卖各自的，共30
        new MyThread().start();
        new MyThread().start();
        new MyThread().start();
    }

    public class MyThread extends Thread{
        private  int tickets = 10;//每个线程都拥有10张票

        // run()方法的方法体代表了线程需要完成的任务，称之为线程执行体
        @Override
        public void run() {
            while(tickets > 0){
                System.out.println(this.getName() + ": 卖出第【" + tickets-- + "】张火车票");
            }
        }
    }
}

结果：

Thread-0: 卖出第【10】张火车票
Thread-0: 卖出第【9】张火车票
Thread-0: 卖出第【8】张火车票
Thread-0: 卖出第【7】张火车票
Thread-0: 卖出第【6】张火车票
Thread-1: 卖出第【10】张火车票
Thread-2: 卖出第【10】张火车票
Thread-1: 卖出第【9】张火车票
Thread-0: 卖出第【5】张火车票
Thread-1: 卖出第【8】张火车票
Thread-2: 卖出第【9】张火车票
Thread-1: 卖出第【7】张火车票
Thread-0: 卖出第【4】张火车票
Thread-1: 卖出第【6】张火车票
Thread-2: 卖出第【8】张火车票
Thread-1: 卖出第【5】张火车票
Thread-1: 卖出第【4】张火车票
Thread-1: 卖出第【3】张火车票
Thread-0: 卖出第【3】张火车票
Thread-0: 卖出第【2】张火车票
Thread-0: 卖出第【1】张火车票
Thread-1: 卖出第【2】张火车票
Thread-2: 卖出第【7】张火车票
Thread-1: 卖出第【1】张火车票
Thread-2: 卖出第【6】张火车票
Thread-2: 卖出第【5】张火车票
Thread-2: 卖出第【4】张火车票
Thread-2: 卖出第【3】张火车票
Thread-2: 卖出第【2】张火车票
Thread-2: 卖出第【1】张火车票

如上所示，继承Thread类，通过重写run()方法定义了一个新的线程类MyThread，其中run()方法的方法体代表了线程需要完成的任务，称之为线程执行体。当创建此线程类对象时一个新的线程得以创建，并进入到线程新建状态。通过调用线程对象引用的start()方法，使得该线程进入到就绪状态，此时此线程并不一定会马上得以执行，这取决于CPU调度时机。

从结果可以看到，每个线程分别对应10张电影票，之间并无任何关系，这就说明每个线程之间是平等的，没有优先级关系，因此都有机会得到CPU的处理。但是结果显示这三个线程并不是依次交替执行，而是在三个线程同时被执行的情况下，有的线程被分配时间片的机会多，票被提前卖完，而有的线程被分配时间片的机会比较少，票迟一些卖完。

可见，利用扩展Thread类创建的多个线程，虽然执行的是相同的代码，但彼此相互独立，且各自拥有自己的资源，互不干扰。

3.2 通过实现Runnable接口来创建多线程
实现Runnable接口，并重写该接口的run()方法，该run()方法同样是线程执行体，创建Runnable实现类的实例，并以此实例作为Thread类的target来创建Thread对象，该Thread对象才是真正的线程对象。例如：

public class RunableTest {

    private static int tickets = 10;//每个线程都拥有10张票

    public static void main(String[] args) {

        // 1、第一种方法
//        for(int i = 0; i < 3; i++) {
//            System.out.println(Thread.currentThread().getName());
//            new Thread(new Runnable() {
//
//                @Override
//                public void run() {
//                    while (tickets > 0) {
//                        System.out.println(Thread.currentThread().getName() + ": 卖出第【" + tickets-- + "】张火车票");
//                    }
//                }
//            }).start();
//        }

        //2、第二种方法
        for(int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName());
            // 创建一个Runnable实现类的对象
            Runnable myRunnable = new MyThread();
            // 将myRunnable作为Thread target创建新的线程
            Thread thread = new Thread(myRunnable);
            // 调用start()方法使得线程进入就绪状态
            thread.start();
           // new Thread(new ThreadTest.MyThread()).start();
        }

        //1.2
//        Runnable runnable = new MyThread();
//        new Thread(runnable).start();
//        new Thread(runnable).start();
//        new Thread(runnable).start();

    }

    public static class MyThread implements Runnable{
        public void run() {
            while(tickets > 0){
                System.out.println(Thread.currentThread().getName() + ": 卖出第【" + tickets-- + "】张火车票");
            }
        }
    }
}

结果：

Thread-0: 卖出第【10】张火车票
Thread-0: 卖出第【8】张火车票
Thread-1: 卖出第【9】张火车票
Thread-1: 卖出第【5】张火车票
Thread-1: 卖出第【4】张火车票
Thread-1: 卖出第【3】张火车票
Thread-1: 卖出第【2】张火车票
Thread-1: 卖出第【1】张火车票
Thread-0: 卖出第【6】张火车票
Thread-2: 卖出第【7】张火车票

上面的程序中，创建了三个线程，每个线程调用的是同一个MyThread对象中的run()方法，访问的是同一个对象中的变量（tickets）的实例，这个程序满足了我们的需求。程序在内存中仅创建了一个资源，而新建的三个线程都是基于访问这同一资源的，并且由于每个线程上所运行的是相同的代码，因此它们执行的功能也是相同的。

我们可以看出，通过实现Runnable接口，我们实现了多个线程去处理同一个资源。我们只能创建一个资源对象，但要创建多个线程去处理这同一个资源对象，并且每个线程上所运行的是相同的程序代码。

可见，如果现实问题中要求必须创建多个线程来执行同一任务，而且这多个线程之间还将共享同一个资源，那么就可以使用实现Runnable接口的方式来创建多线程程序。而这一功能通过扩展Thread类是无法实现的。实现Runnable接口相对于扩展Thread类来说，具有无可比拟的优势。这种方式不仅有利于程序的健壮性，使代码能够被多个线程共享，而且代码和数据资源相对独立，从而特别适合多个具有相同代码的线程去处理同一资源的情况。这样一来，线程、代码和数据资源三者有效分离，很好地体现了面向对象程序设计的思想。因此，几乎所有的多线程程序都是通过实现Runnable接口的方式来完成的。

3.3 3、使用ExecutorService、Callable、Future实现有返回结果的多线程
ExecutorService、Callable、Future这个对象实际上都是属于Executor框架中的功能类。想要详细了解Executor框架的可以访问http://www.javaeye.com/topic/366591 ，这里面对该框架做了很详细的解释。返回结果的线程是在JDK1.5中引入的新特征，确实很实用，有了这种特征我就不需要再为了得到返回值而大费周折了，而且即便实现了也可能漏洞百出。

可返回值的任务必须实现Callable接口，类似的，无返回值的任务必须Runnable接口。执行Callable任务后，可以获取一个Future的对象，在该对象上调用get就可以获取到Callable任务返回的Object了，再结合线程池接口ExecutorService就可以实现传说中有返回结果的多线程了。下面提供了一个完整的有返回结果的多线程测试例子，在JDK1.5下验证过没问题可以直接使用。代码如下：

import java.util.concurrent.*;
import java.util.Date;
import java.util.List;
import java.util.ArrayList;

/**
* 有返回值的线程
*/
@SuppressWarnings("unchecked")
public class Test {
    public static void main(String[] args) throws ExecutionException,
        InterruptedException {
       System.out.println("----程序开始运行----");
       Date date1 = new Date();

       int taskSize = 5;
       // 创建一个线程池
       ExecutorService pool = Executors.newFixedThreadPool(taskSize);
       // 创建多个有返回值的任务
       List<Future> list = new ArrayList<Future>();
       for (int i = 0; i < taskSize; i++) {
        Callable c = new MyCallable(i + " ");
        // 执行任务并获取Future对象
        Future f = pool.submit(c);
        // System.out.println(">>>" + f.get().toString());
        list.add(f);
       }
       // 关闭线程池
       pool.shutdown();

       // 获取所有并发任务的运行结果
       for (Future f : list) {
        // 从Future对象上获取任务的返回值，并输出到控制台
        System.out.println(">>>" + f.get().toString());
       }

       Date date2 = new Date();
       System.out.println("----程序结束运行----，程序运行时间【"
         + (date2.getTime() - date1.getTime()) + "毫秒】");
    }
    }

    class MyCallable implements Callable<Object> {
    private String taskNum;

    MyCallable(String taskNum) {
       this.taskNum = taskNum;
    }

    public Object call() throws Exception {
       System.out.println(">>>" + taskNum + "任务启动");
       Date dateTmp1 = new Date();
       Thread.sleep(1000);
       Date dateTmp2 = new Date();
       long time = dateTmp2.getTime() - dateTmp1.getTime();
       System.out.println(">>>" + taskNum + "任务终止");
       return taskNum + "任务返回运行结果,当前任务时间【" + time + "毫秒】";
    }
}

代码说明：
上述代码中Executors类，提供了一系列工厂方法用于创先线程池，返回的线程池都实现了ExecutorService接口。

public static ExecutorService newFixedThreadPool(int nThreads) 创建固定数目线程的线程池。

public static ExecutorService newCachedThreadPool()创建一个可缓存的线程池，调用execute 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。

public static ExecutorService newSingleThreadExecutor() 创建一个单线程化的Executor。

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) 创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代Timer类。

ExecutoreService提供了submit()方法，传递一个Callable，或Runnable，返回Future。如果Executor后台线程池还没有完成Callable的计算，这调用返回Future对象的get()方法，会阻塞直到计算完成。

4、继承Thread类和实现Runable接口比较

4.1 为什么Java要提供继承Thread类和实现Runable接口来实现多线程线程

在Java中，类仅支持单继承，也就是说，当定义一个新的类的时候，它只能扩展一个外部类。这样，如果创建自定义线程类的时候是通过扩展 Thread类的方法来实现的，那么这个自定义类就不能再去扩展其他的类，也就无法实现更加复杂的功能。因此，如果自定义类必须扩展其他的类，那么就可以使用实现Runnable接口的方法来定义该类为线程类，这样就可以避免Java单继承所带来的局限性。

还有一点最重要的就是使用实现Runnable接口的方式创建的线程可以处理同一资源，从而实现资源的共享。

4.2 实现Runnable接口相对于继承Thread类好处

（1）适合多个相同程序代码的线程去处理同一资源的情况，把虚拟CPU（线程）同程序的代码，数据有效的分离，较好地体现了面向对象的设计思想。

（2）可以避免由于Java的单继承特性带来的局限。我们经常碰到这样一种情况，即当我们要将已经继承了某一个类的子类放入多线程中，由于一个类不能同时有两个父类，所以不能用继承Thread类的方式，那么，这个类就只能采用实现Runnable接口的方式了。

（3）有利于程序的健壮性，代码能够被多个线程共享，代码与数据是独立的。当多个线程的执行代码来自同一个类的实例时，即称它们共享相同的代码。多个线程操作相同的数据，与它们的代码无关。当共享访问相同的对象是，即它们共享相同的数据。当线程被构造时，需要的代码和数据通过一个对象作为构造函数实参传递进去，这个对象就是一个实现了Runnable接口的类的实例。

值得注意的是：main方法其实也是一个线程。在java中所以的线程都是同时启动的，至于什么时候，哪个先执行，完全看谁先得到CPU的资源。在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM就是在操作系统中启动了一个进程。