多线程1（线程的创建和启动）

    Java 使用Thread 类来代表线程，所有的线程对象都必须是Thread 或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流（一段顺寻执行的代码）。Java 使用线程执行体来代表这段程序流。

    1、继承Thread 类创建线程类

    通过继承Thread 类来创建并启动多线程的步骤如下：

    ① 定义Thread 类的子类，并创建该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务。因此把run()方法称为线程执行体。

    ② 创建Thread 子类的实例，即创建了线程对象。

    ③ 调用线程对象的start() 方法来启动该线程。

    下面程序示范了通过继承Thread 类来创建并启动多线程。

// 通过继承Thread 类来创建线程类
public class FirstThread extends Thread {

    private int i;
    // 重写run() 方法，run() 方法的方法体就是线程执行体
    public void run(){
        for(; i < 100; i++){
            // 当线程类继承Thread 类时，直接使用this即可获取当前线程
            // Thread 对象的getName()返回当前线程的名字
            // 因此可以直接调用getName() 方法返回当前线程的名字
            System.out.println(getName() + " " + i);
        }
    }

    public static void main(String[] args) {
        for(int i = 0; i < 100; i++){
            // 调用Thread 的currentThread()方法获取当前线程
            System.out.println(Thread.currentThread().getName()
                    + " " + i);
            if(i == 20){
                // 创建并启动第一个线程
                new FirstThread().start();
                // 创建并启动第二个线程
                new FirstThread().start();
            }
        }
    }

}

运行结果如下：

    上面程序中的FirstThread 类继承了Thread类，并实现了run()方法，该run()方法里的代码执行流就是该线程所需要完成的任务。程序的主方法中包含了一个循环，当循环变量i等于20时创建并启动两个新线程。运行后会得到上面的界面。

    虽然上面程序只显示地创建了2个线程，但实际上程序有三个线程，即程序显示创建的2个子线程和主线程。当Java 程序开始运行后，程序至少会创建一个主线程，主线程的线程执行体不是由run()方法确的，而是由main()方法确定的——main()方法的方法体代表主线程的线程执行体。

    注：使用继承Thread 类的方法来创建线程类时，多个线程之间无法共享线程的实例变量。

    2、实现Runnable接口创建线程类

    实现Runnable接口来创建并启动多个线程的步骤：

    ① 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。

    ② 创建Runnable实现类的实例，并以此实例作为Thread的target 来创建Thread对象，该Thread对象才是真正的线程对象。代码如下所示：

    

    // 创建Runnable实现类的对象
    SecondThread st = new SecondThread();
    // 以Runnable实现类的对象作为Thread的target来创建Thread对象，即线程对象。
    new Thread(st);
    也可以在创建Thread对象时为该Thread对象指定一个名字，代码如下所示：
    // 创建Thread对象时指定target和新线程的名字
    new Thread(st, "新线程1");

    注意：Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run()方法仅作为线程执行体。而实际的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run()方法。

    ③ 调用线程对象的start()方法来启动线程。

下面程序示范了通过实现Runnable接口来创建并启动多线程。

// 通过实现Runnable接口来创建线程类
public class SecondThread implements Runnable {

    private int i;
    // run()方法同样是线程执行体
    public void run() {
        for(; i < 100; i++){
            // 当线程实现Runnable接口时
            // 如果想获取当前线程，只能用Thread.currentThread()方法
            System.out.println(Thread.currentThread().getName()
                    + " " + i);
        }
    }

    public static void main(String[] args) {
        for(int i = 0; i < 100; i++){
            System.out.println(Thread.currentThread().getName()
                    + " " + i);
            if(i == 20){
                SecondThread st = new SecondThread();
                // 通过new Thread(target, name)方法创建新线程
                new Thread(st, "新线程1").start();
                new Thread(st, "新线程2").start();
            }
        }
    }

}

运行结果如下：

    上面程序中的run()方法，定义了该线程的线程执行体。对比FirstThread中的run()方法和SecondThread中的run()方法体不难发现，通过继承Thread类来获得当前线程对象比较简单，直接使用this就可以了；但通过实现Runnable接口获取当前线程对象，则必须使用Thread.currentThread()方法。

    除此之外，上面程序创建了两个Thread对象，并调用start()方法来启动着两个线程。在FirstThread和SecondThread中创建线程对象的方式有所区别：前者直接创建的Thread子类即可代表线程对象；后者创建的Runnable对象只能作为线程对象的target。

    从运行结果来看，两个子线程的i变量是连续的，也就是采用Runnable接口的方式创建的多个线程可以共享线程类的实例变量。这是因为在这种方式下，程序所创建的Runnable对象只是线程的target，而多个线程可以共享一个target，所以多个线程可以共享同一个线程类(实际上应该是线程的target类)。

3、使用Callable和Future创建线程

    从Java 5 开始，Java提供了Callable接口，该接口提供了一个call()方法可以作为线程执行体，但call()方法比run()方法功能更强大。

• call()方法可以有返回值。
• call()方法可以声明抛出异常。

    因此完全可以提供一个Callable对象作为Thread的target，而该线程的线程执行体就是该Callable对象的call()方法。问题是：Callable接口是Java 5 新增的接口，而且它不是Runnable接口的子接口，所以Callable对象不能直接作为Thread的target。而且call()方法还有一个返回值——call()方法并不能直接调用，它是作为线程执行体被调用的。那么如何获取call()方法的返回值呢？

    Java 5 提供了Future 接口来代表Callable接口里call()方法的返回值，并为Future接口提供了一个FutureTask实现类，该实现类实现了Future接口，并实现了Runnable接口——可以作为Thread类的target。

    在Future接口里定义了如下几个公共方法来控制它关联的Callable任务。

• boolean cancel(boolean mayInterrupIfRunning): 试图取消该Future里关联的Callable任务。
• V get(long timeout, TimeUnit unit): 返回Callable任务里call()方法的返回值。该方法让程序最多阻塞timeout和unit指定的时间，如果经过指定时间后Callable任务依然没有返回值，将会抛出TimeoutException异常。
• boolean isCancelled(): 如果在Callable任务正常完成前被取消。则返回true。
• boolean isDone(): 如果Callable任务已完成，则返回true。 

    创建并启动有返回值的线程的步骤如下：

    ① 创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，且该call()方法有返回值，在创建Callable实现类的实例。

    ② 使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。

    ③ 使用FutureTask对象作为Thread对象的target创建并启动新线程。

    ④ 调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。

下面程序通过实现Callable()接口来实现线程类，并启动该线程。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class ThirdThread {

    public static void main(String[] args) {
        // 创建Callable对象
        ThirdThread rt = new ThirdThread();
        // 先使用Lambda表达式创建Callable<Integer>对象
        // 使用FutureTask来包装Callable对象
        FutureTask<Integer> task = new FutureTask<Integer>((Callable<Integer>)()->{
            int i = 0;
            for(; i < 100; i++){
                System.out.println(Thread.currentThread().getName()
                        + " 的循环变量i的值： " + i);
            }
            // call()方法可以有返回值
            return i;
        });
        for(int i = 0; i < 100; i++){
            System.out.println(Thread.currentThread().getName()
                    + " 的循环变量i的值： " + i);
            if(i == 20){
                // 实质还是以Callable对象来创建并启动线程的
                new Thread(task, "有返回值的线程").start();
            }
        }

        try {
            System.out.println("子线程的返回值：" + task.get());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

    上面程序中的粗体字代码是以Callable对象来启动线程的关键代码。程序先使用Lambda表达式创建一个Callable对象，然后将该实例包装成一个FutureTask对象。主线程中当线程变量i等于20时，程序启动以FutureTask对象为target的线程。程序最后调用FutureTask对象的get()方法来返回call()方法的返回值——该方法将导致主线程被阻塞，知道call()方法结束并返回为止。

    在运行程序结果中，将看到主线程和call()方法所代表的线程交替执行的情形，程序最后还会输出call()方法的返回值。

4、创建线程的三种方式对比

    通过继承Thread类或实现Runnable、Callable接口都可以实现多线程，不过实现Runnable接口与实现callable接口的方式基本相同，只是Callable接口里定义的方法有返回值，可以声明抛出异常而已。因此可以将实现Runnable接口和实现Callable接口归并为一种方式。这种方式与继承Thread方式之间的主要差别如下。

    采用实现Runnable、Callable接口的方式创建多线程的优缺点：

• 线程类只是实现了Runnable接口或Callable接口，还可以继承其他类。
• 在这种情况下，多个线程可以共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。
• 劣势是，变成稍稍复杂，如果需要访问当前线程，则必须使用Thread.currentThread()方法。

    采用继承Thread类的方式创建多线程的优缺点：

• 劣势是，因为线程类已经继承了Thread，所以不能在继承其他父类。
• 优势是变成简单，如果需要访问当前线程，则无须使用Thread.currentThread()方法，直接使用this即可获得当前线程。

    鉴于上面分析，因此一般推荐采用实现Runnable接口，Callable接口的方式来创建线程。