Java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。Java可以用四种方式来创建线程：
- 继承Thread创建线程
- 实现Runnable接口创建线程
- 实现callable接口实现线程
- 使用线程池Executor创建线程
1.继承Thread实现线程
我们先来看一下Thread的源码，它是一个类，同样也实现了Runnable接口
public class Thread implements Runnable { /* Make sure registerNatives is the first thing <clinit> does. */ private static native void registerNatives(); static { registerNatives(); } private volatile String name; private int priority; private Thread threadQ; private long eetop; /* Whether or not to single_step this thread. */ private boolean single_step; /* Whether or not the thread is a daemon thread. */ private boolean daemon = false; /* JVM state */ private boolean stillborn = false; /* What will be run. */ private Runnable target; /* The group of this thread */ private ThreadGroup group; /* The context ClassLoader for this thread */ private ClassLoader contextClassLoader; /* The inherited AccessControlContext of this thread */ private AccessControlContext inheritedAccessControlContext; /* For autonumbering anonymous threads. */ private static int threadInitNumber; private static synchronized int nextThreadNum() { return threadInitNumber++; } /* ThreadLocal values pertaining to this thread. This map is maintained * by the ThreadLocal class. */ ThreadLocal.ThreadLocalMap threadLocals = null; /* * InheritableThreadLocal values pertaining to this thread. This map is * maintained by the InheritableThreadLocal class. */ ThreadLocal.ThreadLocalMap inheritableThreadLocals = null; /* * The requested stack size for this thread, or 0 if the creator did * not specify a stack size. It is up to the VM to do whatever it * likes with this number; some VMs will ignore it. */ private long stackSize; /* * JVM-private state that persists after native thread termination. */ private long nativeParkEventPointer; /* * Thread ID */ private long tid; /* For generating thread ID */ private static long threadSeqNumber; /* Java thread status for tools, * initialized to indicate thread 'not yet started' */ private volatile int threadStatus = 0; //...... }
通过继承Thread类来创建并启动多线程的一般步骤如下
- 1】d定义Thread类的子类，并重写该类的run()方法，该方法的方法体就是线程需要完成的任务，run()方法也称为线程执行体。
- 2】创建Thread子类的实例，也就是创建了线程对象
- 3】启动线程，即调用线程的start()方法
代码示例：
public class ThreadTest { public static void main(String[] args) { new MyThread().start(); } static class MyThread extends Thread {//继承Thread public void run() { System.out.println("我是继承Thread类！！ "); } } }
2.实现Runnable接口创建线程
我们来看一下Runnable的源码，它是一个接口：
@FunctionalInterface public interface Runnable { /** * When an object implementing interface <code>Runnable</code> is used * to create a thread, starting the thread causes the object's * <code>run</code> method to be called in that separately executing * thread. * <p> * The general contract of the method <code>run</code> is that it may * take any action whatsoever. * * @see java.lang.Thread#run() */ public abstract void run(); }
由于run()方法返回值为void类型，所以在执行完任务之后无法返回任何结果。
通过实现Runnable接口创建并启动线程一般步骤如下：
- 1】定义Runnable接口的实现类，一样要重写run()方法，这个run（）方法和Thread中的run()方法一样是线程的执行体
- 2】创建Runnable实现类的实例，并用这个实例作为Thread的target来创建Thread对象，这个Thread对象才是真正的线程对象
- 3】第三部依然是通过调用线程对象的start()方法来启动线程
代码示例：
public class RunnableTest { public static void main(String[] args) { MyThread2 myThread=new MyThread2(); Thread thread = new Thread(myThread); thread.start(); } static class MyThread2 implements Runnable { @Override public void run() { System.out.println("我是实现Runnable接口！！ "); } } }
3.实现callable接口实现线程
我们来看一下callable源码，它是一个接口：
@FunctionalInterface public interface Callable<V> { /** * Computes a result, or throws an exception if unable to do so. * * @return computed result * @throws Exception if unable to compute a result */ V call() throws Exception; }
它和Runnable接口不一样的是，call()方法提供了2个额外功能：
- call()方法可以有返回值
- all()方法可以声明抛出异常
java5提供了Future接口来代表Callable接口里call()方法的返回值，并且为Future接口提供了一个实现类FutureTask，这个实现类既实现了Future接口，还实现了Runnable接口，因此可以作为Thread类的target。在Future接口里定义了几个公共方法来控制它关联的Callable任务。
那么怎么使用Callable呢？一般情况下是配合ExecutorService来使用的，在ExecutorService接口中声明了若干个submit方法的重载版本：
<T> Future<T> submit(Callable<T> task); <T> Future<T> submit(Runnable task, T result); Future<?> submit(Runnable task);
第一个submit方法里面的参数类型就是Callable。
暂时只需要知道Callable一般是和ExecutorService配合来使用的，具体的使用方法讲在后面讲述。
一般情况下我们使用第一个submit方法和第三个submit方法，第二个submit方法很少使用。
3.1 Future
我们来看一下Future的源码，它是一个接口：
public interface Future<V> { /** * Attempts to cancel execution of this task. This attempt will * fail if the task has already completed, has already been cancelled, * or could not be cancelled for some other reason. If successful, * and this task has not started when {@code cancel} is called, * this task should never run. If the task has already started, * then the {@code mayInterruptIfRunning} parameter determines * whether the thread executing this task should be interrupted in * an attempt to stop the task. * * <p>After this method returns, subsequent calls to {@link #isDone} will * always return {@code true}. Subsequent calls to {@link #isCancelled} * will always return {@code true} if this method returned {@code true}. * * @param mayInterruptIfRunning {@code true} if the thread executing this * task should be interrupted; otherwise, in-progress tasks are allowed * to complete * @return {@code false} if the task could not be cancelled, * typically because it has already completed normally; * {@code true} otherwise */ boolean cancel(boolean mayInterruptIfRunning); /** * Returns {@code true} if this task was cancelled before it completed * normally. * * @return {@code true} if this task was cancelled before it completed */ boolean isCancelled(); /** * Returns {@code true} if this task completed. * * Completion may be due to normal termination, an exception, or * cancellation -- in all of these cases, this method will return * {@code true}. * * @return {@code true} if this task completed */ boolean isDone(); /** * Waits if necessary for the computation to complete, and then * retrieves its result. * * @return the computed result * @throws CancellationException if the computation was cancelled * @throws ExecutionException if the computation threw an * exception * @throws InterruptedException if the current thread was interrupted * while waiting */ V get() throws InterruptedException, ExecutionException; /** * Waits if necessary for at most the given time for the computation * to complete, and then retrieves its result, if available. * * @param timeout the maximum time to wait * @param unit the time unit of the timeout argument * @return the computed result * @throws CancellationException if the computation was cancelled * @throws ExecutionException if the computation threw an * exception * @throws InterruptedException if the current thread was interrupted * while waiting * @throws TimeoutException if the wait timed out */ V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException; }
我们来看一下它的各个方法：
- boolean cancel(boolean mayInterruptIfRunning)：用来取消任务，如果取消任务成功则返回true，如果取消任务失败则返回false。参数mayInterruptIfRunning表示是否允许取消正在执行却没有执行完毕的任务，如果设置true，则表示可以取消正在执行过程中的任务。如果任务已经完成，则无论mayInterruptIfRunning为true还是false，此方法肯定返回false，即如果取消已经完成的任务会返回false；如果任务正在执行，若mayInterruptIfRunning设置为true，则返回true，若mayInterruptIfRunning设置为false，则返回false；如果任务还没有执行，则无论mayInterruptIfRunning为true还是false，肯定返回true。
-
boolean isCancelled()：如果在Callable任务正常完成前被取消，返回True
-
boolean isDone()：若Callable任务完成，返回True
-
V get() throws InterruptedException, ExecutionException：返回Callable里call（）方法的返回值，调用这个方法会导致程序阻塞，必须等到子线程结束后才会得到返回值
-
V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException：用来获取执行结果，如果在指定时间内，还没获取到结果，就直接返回null
因为Future只是一个接口，所以是无法直接用来创建对象使用的，因此就有了下面的FutureTask
3.2 FutureTask
我们先来看一下FutureTask的实现：
public class FutureTask<V> implements RunnableFuture<V> {
FutureTask类实现了RunnableFuture接口，我们看一下RunnableFuture接口的实现：
public interface RunnableFuture<V> extends Runnable, Future<V> { /** * Sets this Future to the result of its computation * unless it has been cancelled. */ void run(); }
可以看出RunnableFuture继承了Runnable接口和Future接口，而FutureTask实现了RunnableFuture接口。所以它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。
FutureTask提供了2个构造器：
public FutureTask(Callable<V> callable) { if (callable == null) throw new NullPointerException(); this.callable = callable; this.state = NEW; // ensure visibility of callable }
public FutureTask(Runnable runnable, V result) { this.callable = Executors.callable(runnable, result); this.state = NEW; // ensure visibility of callable }
事实上，FutureTask是Future接口的一个唯一实现类。
3.3 使用FutureTask对象作为Thread对象的target创建并启动线程
接下来我们看如何创建并启动有返回值的线程：
- 1】创建Callable接口的实现类，并实现call()方法，然后创建该实现类的实例（从java8开始可以直接使用Lambda表达式创建Callable对象）。
- 2】使用FutureTask类来包装Callable对象，该FutureTask对象封装了Callable对象的call()方法的返回值
- 3】使用FutureTask对象作为Thread对象的target创建并启动线程（因为FutureTask实现了Runnable接口）
- 4】调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
代码示例：
public class CallableAndFuture { public static void main(String[] args) { Callable<Integer> call = new Callable<Integer>() { public Integer call() throws Exception { System.out.println("计算线程正在计算结果..."); Thread.sleep(3000); return 1; } }; FutureTask<Integer> future = new FutureTask<>(call); new Thread(future,"有返回值的线程").start();//实质上还是以Callable对象来创建并启动线程 try { System.out.println("子线程的返回值：" + future.get());//get()方法会阻塞，直到子线程执行结束才返回 } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } } }
3.4 使用executor创建线程
3.4.1.使用Callable+Future获取执行结果
代码示例：
public class CallableAndFuture { public static void main(String[] args) { /** Executors提供了一系列工厂方法用于创先线程池，返回的线程池都实现了ExecutorService接口。 */ ExecutorService executor = Executors.newCachedThreadPool(); Task task = new Task(); Future<Integer> result = executor.submit(task); executor.shutdown(); try { Thread.sleep(1000); } catch (InterruptedException e1) { e1.printStackTrace(); } System.out.println("主线程在执行任务"); try { System.out.println("task运行结果"+result.get()); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } System.out.println("所有任务执行完毕"); } static class Task implements Callable<Integer> { @Override public Integer call() throws Exception { System.out.println("子线程在进行计算"); Thread.sleep(3000); int sum = 0; for(int i=0;i<100;i++) sum += i; return sum; } } }
3.4.2.使用Callable+FutureTask获取执行结果
public class CallableAndFuture2 { public static void main(String[] args) { //第一种方式 ExecutorService executor = Executors.newCachedThreadPool(); Task task = new Task(); FutureTask<Integer> futureTask = new FutureTask<Integer>(task); executor.submit(futureTask); executor.shutdown(); //第二种方式，注意这种方式和第一种方式效果是类似的，只不过一个使用的是ExecutorService，一个使用的是Thread /*Task task = new Task(); FutureTask<Integer> futureTask = new FutureTask<Integer>(task); Thread thread = new Thread(futureTask); thread.start();*/ try { Thread.sleep(1000); } catch (InterruptedException e1) { e1.printStackTrace(); } System.out.println("主线程在执行任务"); try { System.out.println("task运行结果"+futureTask.get()); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } System.out.println("所有任务执行完毕"); } static class Task implements Callable<Integer> { @Override public Integer call() throws Exception { System.out.println("子线程在进行计算"); Thread.sleep(3000); int sum = 0; for(int i=0;i<100;i++) sum += i; return sum; } } }
4.使用线程池Executor创建线程
4.1 Executor执行Runnable
public class Executor执行Runnable { /** * 从结果中可以看出，pool-1-thread-1和pool-1-thread-2均被调用了两次，这是随机的，execute会首先在线程池中选择 * 一个已有空闲线程来执行任务，如果线程池中没有空闲线程，它便会创建一个新的线程来执行任务。 */ public static void main(String[] args){ ExecutorService executorService = Executors.newCachedThreadPool(); // ExecutorService executorService = Executors.newFixedThreadPool(5); // ExecutorService executorService = Executors.newSingleThreadExecutor(); for (int i = 0; i < 5; i++){ executorService.execute(new TestRunnable()); System.out.println("************* a" + i + " *************"); } executorService.shutdown(); } } class TestRunnable implements Runnable { public void run() { System.out.println(Thread.currentThread().getName() + "线程被调用了。"); } }
执行结果：
************* a1 ************* ************* a2 ************* pool-1-thread-2线程被调用了。 ************* a3 ************* pool-1-thread-1线程被调用了。 pool-1-thread-2线程被调用了。 ************* a4 ************* pool-1-thread-3线程被调用了。
4.2Executor执行Callable
public class Executor执行Callable { /** * 从结果中可以同样可以看出，submit也是首先选择空闲线程来执行任务，如果没有，才会创建新的线程来执行任务。 * 另外，需要注意：如果Future的返回尚未完成，则get（）方法会阻塞等待，直到Future完成返回，可以通过 * 调用isDone（）方法判断Future是否完成了返回。 */ public static void main(String[] args){ ExecutorService executorService = Executors.newCachedThreadPool(); List<Future<String>> resultList = new ArrayList<Future<String>>(); //创建10个任务并执行 for (int i = 0; i < 10; i++){ //使用ExecutorService执行Callable类型的任务，并将结果保存在future变量中 Future<String> future = executorService.submit(new TaskWithResult(i)); //将任务执行结果存储到List中 resultList.add(future); } //遍历任务的结果 for (Future<String> fs : resultList){ try{ while(!fs.isDone());//Future返回如果没有完成，则一直循环等待，直到Future返回完成 System.out.println(fs.get()); //打印各个线程（任务）执行的结果 }catch(InterruptedException e){ e.printStackTrace(); }catch(ExecutionException e){ e.printStackTrace(); }finally{ //启动一次顺序关闭，执行以前提交的任务，但不接受新任务 executorService.shutdown(); } } } } class TaskWithResult implements Callable<String> { private int id; public TaskWithResult(int id){ this.id = id; } /** * 任务的具体过程，一旦任务传给ExecutorService的submit方法， * 则该方法自动在一个线程上执行 */ public String call() throws Exception { System.out.println("call()方法被自动调用！！！ " + Thread.currentThread().getName()); //该返回结果将被Future的get方法得到 return "call()方法被自动调用，任务返回的结果是：" + id + " " + Thread.currentThread().getName(); } }
执行结果：
call()方法被自动调用！！！ pool-1-thread-1 call()方法被自动调用，任务返回的结果是：0 pool-1-thread-1 call()方法被自动调用！！！ pool-1-thread-2 call()方法被自动调用，任务返回的结果是：1 pool-1-thread-2 call()方法被自动调用！！！ pool-1-thread-3 call()方法被自动调用，任务返回的结果是：2 pool-1-thread-3 call()方法被自动调用！！！ pool-1-thread-5 call()方法被自动调用！！！ pool-1-thread-6 call()方法被自动调用！！！ pool-1-thread-7 call()方法被自动调用！！！ pool-1-thread-9 call()方法被自动调用！！！ pool-1-thread-4 call()方法被自动调用，任务返回的结果是：3 pool-1-thread-4 call()方法被自动调用，任务返回的结果是：4 pool-1-thread-5 call()方法被自动调用，任务返回的结果是：5 pool-1-thread-6 call()方法被自动调用，任务返回的结果是：6 pool-1-thread-7 call()方法被自动调用！！！ pool-1-thread-8 call()方法被自动调用，任务返回的结果是：7 pool-1-thread-8 call()方法被自动调用，任务返回的结果是：8 pool-1-thread-9 call()方法被自动调用！！！ pool-1-thread-10 call()方法被自动调用，任务返回的结果是：9 pool-1-thread-10