Java创建线程的4种方式：
Java使用Thread类代表线程，所有线程对象都必须是Thread类或者其子类的实例。Java可以用以下4种方式来创建线程：
1）继承Thread类创建线程；
2）实现Runnable接口创建线程；
3）实现Callable接口，通过FutureTask包装器来创建Thread线程；
4）使用ExecutorService、Callable(或者Runnable)、Future实现由返回结果的线程。
接下来，针对这四种方式详细介绍及其用法：
1）继承Thread类创建线程
Thread类本质上是实现了Runnable接口的一个实例，代表一个线程的实例。启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法。这种方式实现多线程很简单，通过自己的类直接extends Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。
例如：
/**
* 无返回值的
*/
class MyThread extends Thread {
CountDownLatch countDownLatch; public MyThread(CountDownLatch countDownLatch) {
this.countDownLatch = countDownLatch;
} @Override
public void run() {
try {
Thread.sleep(2000);
System.out.println(Thread.currentThread().getName() + ":my thread ");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
countDownLatch.countDown();
}
}
}
main调用：
public static void main(String[] args) {
// 第一種：使用extends Thread方式
CountDownLatch countDownLatch1 = new CountDownLatch(2);
for (int i = 0; i < 2; i++) {
MyThread myThread1 = new MyThread(countDownLatch1);
myThread1.start();
}
try {
countDownLatch1.await();
System.out.println("thread complete...");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
2）实现Runnable接口创建线程
如果自己的类已经extends另一个类，就无法直接extends Thread，此时，可以实现一个Runnable接口，如下：
/**
* 无返回值的
*/
class MyRunnable implements Runnable {
CountDownLatch countDownLatch; public MyRunnable(CountDownLatch countDownLatch) {
this.countDownLatch = countDownLatch;
} public void run() {
try {
Thread.sleep(2000);
System.out.println(Thread.currentThread().getName() + ":my runnable");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
countDownLatch.countDown();
}
}
}
为了启动MyRunnable，需要首先实例化一个Thread，并传入自己的MyRunnable实例：
public static void main(String[] args) {
// 第二種：使用implements Runnable方式
CountDownLatch countDownLatch2 = new CountDownLatch(2);
MyRunnable myRunnable = new MyRunnable(countDownLatch2);
for (int i = 0; i < 2; i++) {
new Thread(myRunnable).start();
}
try {
countDownLatch2.await();
System.out.println("runnable complete...");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
事实上，当传入一个Runnable target参数给Thread后，Thread的run()方法就会调用target.run()，参考JDK源代码：
public void run() {
if (target != null) {
target.run();
}
}
3）实现Callable接口，通过FutureTask包装器来创建Thread线程
Callable接口（也只有一个方法）定义如下：
public interface Callable<V> {
V call（） throws Exception;
}
如果自己的类已经extends另一个类，就无法直接extends Thread，此时，可以实现一个Callable接口(它是一个具有返回值的)，如下：
/**
* 有返回值的
*/
class MyCallable implements Callable<Integer> {
CountDownLatch countDownLatch; public MyCallable(CountDownLatch countDownLatch) {
this.countDownLatch = countDownLatch;
} public Integer call() throws Exception {
try {
Thread.sleep(2000); int sum = 0;
for (int i = 0; i <= 100; i++) {
sum += i;
} System.out.println(Thread.currentThread().getName() + ":my callable"); return sum;
} finally {
countDownLatch.countDown();
}
}
}
和Runnable接口不一样，Callable接口提供了一个call（）方法作为线程执行体，call()方法比run()方法功能要强大。
1）call()方法可以有返回值
2）call()方法可以声明抛出异常
Java5提供了Future接口来代表Callable接口里call()方法的返回值，并且为Future接口提供了一个实现类FutureTask，这个实现类既实现了Future接口，还实现了Runnable接口，因此可以作为Thread类的target。在Future接口里定义了几个公共方法来控制它关联的Callable任务。
boolean cancel(boolean mayInterruptIfRunning)：//视图取消该Future里面关联的Callable任务
V get()：//返回Callable里call（）//方法的返回值，调用这个方法会导致程序阻塞，必须等到子线程结束后才会得到返回值
V get(long timeout,TimeUnit unit)：//返回Callable里call（）方法的返回值，最多阻塞timeout时间，经过指定时间没有返回抛出TimeoutException
boolean isDone();//若Callable任务完成，返回True
boolean isCancelled();//如果在Callable任务正常完成前被取消，返回True
介绍了相关的概念之后，创建并启动有返回值的线程的步骤如下：
1】创建Callable接口的实现类，并实现call()方法，然后创建该实现类的实例（从java8开始可以直接使用Lambda表达式创建Callable对象）。
2】使用FutureTask类来包装Callable对象，该FutureTask对象封装了Callable对象的call()方法的返回值
3】使用FutureTask对象作为Thread对象的target创建并启动线程（因为FutureTask实现了Runnable接口）
4】调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
main调用：
public static void main(String[] args) {
// 第三種：使用implements Callable方式,具有返回值
List<FutureTask<Integer>> resultItems1 = new ArrayList<FutureTask<Integer>>();
CountDownLatch countDownLatch3 = new CountDownLatch(2);
for (int i = 0; i < 2; i++) {
MyCallable myCallable = new MyCallable(countDownLatch3);
FutureTask<Integer> futureTask = new FutureTask<Integer>(myCallable);
new Thread(futureTask).start();
resultItems1.add(futureTask);
}
try {
countDownLatch3.await();
Iterator<FutureTask<Integer>> iterator = resultItems1.iterator();
while (iterator.hasNext()) {
try {
System.out.println(iterator.next().get());
} catch (ExecutionException e) {
e.printStackTrace();
}
}
System.out.println("callable complete...");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
4）使用ExecutorService、Callable(或者Runnable)、Future实现由返回结果的线程
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()方法，会阻塞直到计算完成。
下边以MyCallable为例，展示下具体的用法（MyCallable与3）中的定义一样）：
public static void main(String[] args) {
// 第四種：使用使用線程池方式
// 接受返回參數
List<Future> resultItems2 = new ArrayList<Future>();
// 給線程池初始化5個線程
ExecutorService executorService = Executors.newFixedThreadPool(5);
CountDownLatch countDownLatch4 = new CountDownLatch(10);
for (int i = 0; i < 10; i++) {
MyCallable myCallable = new MyCallable(countDownLatch4);
Future result = executorService.submit(myCallable);
resultItems2.add(result);
}
// 等待线程池中分配的任务完成后才关闭(关闭之后不允许有新的线程加入，但是它并不会等待线程结束)，而executorService.shutdownNow();是立即关闭不管是否线程池中是否有其他未完成的线程。
executorService.shutdown();
try {
countDownLatch4.await();
Iterator<Future> iterator = resultItems2.iterator();
while (iterator.hasNext()) {
try {
System.out.println(iterator.next().get());
} catch (ExecutionException e) {
e.printStackTrace();
}
}
System.out.println("callable complete...");
} catch (InterruptedException e) {
e.printStackTrace();
}
}