JAVA多執行緒的實現方式是JAVA基礎的一個重點，看過好多次，但不經常用就容易忘記，今天做一個總結，算是把JAVA基礎再夯實一下。

Java多執行緒實現方式主要有四種：繼承Thread類、實現Runnable介面、實現Callable介面通過FutureTask包裝器來建立Thread執行緒、使用ExecutorService、Callable、Future實現有返回結果的多執行緒。

1、繼承Thread類建立執行緒
Thread類本質上是實現了Runnable介面的一個例項，代表一個執行緒的例項。啟動執行緒的唯一方法就是通過Thread類的start()例項方法。start()方法是一個native方法，它將啟動一個新執行緒，並執行run()方法。這種方式實現多執行緒很簡單，通過自己的類直接extend Thread，並複寫run()方法，就可以啟動新執行緒並執行自己定義的run()方法。例如：

public class MyThread extends Thread {
	public void run() {
		while(true) {
			System.out.println(this.getName()+" running...");
			try {
                Thread.sleep(1000); // 休息1000ms
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
		}
	}
	public static void main(String[]args) {
		MyThread thread1 = new MyThread();
		MyThread thread2 = new MyThread();
		thread1.start();
		thread2.start();
	}
}

//執行結果
Thread-1 running...
Thread-0 running...
Thread-1 running...
Thread-0 running...
Thread-1 running...
Thread-0 running...
Thread-1 running...
Thread-0 running...
Thread-1 running...
Thread-0 running...
Thread-1 running...
Thread-0 running...
 

注意：此時除了建立的兩個執行緒外，還有main執行緒也就是主執行緒在執行，另外還有負責垃圾回收的執行緒同樣在執行，這裡不予研究。執行緒的名字在建立執行緒是預設配置，也可以在建立執行緒時傳入執行緒名字，例如

 MultiThreadDemo td1 = new MultiThreadDemo("t1"); // 指定執行緒的名字

2、實現Runnable介面

實現Runnable介面也是一種常見的建立執行緒的方式。使用介面的方式可以讓我們的程式降低耦合度。Runnable介面中僅僅定義了一個方法，就是run。

其實Runnable就是一個執行緒任務，執行緒任務和執行緒的控制分離，這也就是上面所說的解耦。我們要實現一個執行緒，可以藉助Thread類，Thread類要執行的任務就可以由實現了Runnable介面的類來處理。 這就是Runnable的精髓之所在！

例如：

//整合Runnable介面定義任務類
public class ThreadTask implements Runnable {

	@Override
	public void run() {
			while(true) {
			System.out.println(Thread.currentThread().getName()+" is running...");
			try {
	            Thread.sleep(1000);
	        } catch (InterruptedException e) {
	            e.printStackTrace();
	        }
		}
	}
}


//在main方法中建立執行緒去完成該任務
public class Main extends ThreadTask {
	public static void main(String[]args) {
		ThreadTask task = new ThreadTask();//新建任務類
		Thread t1 = new Thread(task);
		t1.start();
		Thread t2 = new Thread(task);
		t2.start();
	}
}

下面通過多個售票員同時執行售票任務的例子來認識多執行緒

//建立售票任務
public class TicketSailTask implements Runnable{
	public static int number = 100;//總共有100張票
	public Object lock = new Object();//建立鎖，防止多個執行緒同時賣同一張票
	@Override
	public void run() {
		while(true) {
			//進行同步
			synchronized(lock) {
				try{
					Thread.sleep(100);
				}catch(InterruptedException e){
					e.printStackTrace();
				}
			}
			if(number>0) {
				System.out.println(Thread.currentThread().getName()+"正在賣第"+number+"張票");
				number--;
			}else {
				break;
			}
		}
	}
}

//建立多個執行緒，執行任務
public class Main extends ThreadTask {
	public static void main(String[]args) {
		TicketSailTask task = new TicketSailTask();//新建任務類
		Thread t1 = new Thread(task,"小王");
		t1.start();
		Thread t2 = new Thread(task,"小劉");
		t2.start();
		Thread t3 = new Thread(task,"小李");
	}
}

//執行結果
小王正在賣第100張票
小劉正在賣第99張票
小劉正在賣第98張票
小王正在賣第97張票
小劉正在賣第96張票
小王正在賣第95張票
小劉正在賣第94張票
小劉正在賣第93張票
小王正在賣第92張票
小劉正在賣第91張票
小王正在賣第90張票
小劉正在賣第89張票
小王正在賣第88張票
小劉正在賣第87張票
。。。。

3、實現Callable介面實現多執行緒

與實現Runnable介面實現多執行緒類似，也有不同

相同點：
兩者都可用來編寫多執行緒程式；
兩者都需要呼叫Thread.start()啟動執行緒；
 

不同點：

兩者最大的不同點是：實現Callable介面的任務執行緒能返回執行結果；而實現Runnable介面的任務執行緒不能返回結果；
Callable介面的call()方法允許丟擲異常；而Runnable介面的run()方法的異常只能在內部消化，不能繼續上拋；

package com.callable.runnable;

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

public class CallableImpl implements Callable<String> {

    public CallableImpl(String acceptStr) {
        this.acceptStr = acceptStr;
    }

    private String acceptStr;

    @Override
    public String call() throws Exception {
        // 任務阻塞 1 秒
        Thread.sleep(1000);
        return this.acceptStr + " append some chars and return it!";
    }


    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<String> callable = new CallableImpl("my callable test!");
        FutureTask<String> task = new FutureTask<>(callable);
        long beginTime = System.currentTimeMillis();
        // 建立執行緒
        new Thread(task).start();
        // 呼叫get()阻塞主執行緒，反之，執行緒不會阻塞
        String result = task.get();
        long endTime = System.currentTimeMillis();
        System.out.println("hello : " + result);
        System.out.println("cast : " + (endTime - beginTime) / 1000 + " second!");
    }
}

//執行結果

hello : my callable test! append some chars and return it!
cast : 1 second!

Process finished with exit code 0

4、通過執行緒池來實現多執行緒

public class ThreadDemo05{

    private static int POOL_NUM = 10;     //執行緒池數量

    /**
     * @param args
     * @throws InterruptedException 
     */
    public static void main(String[] args) throws InterruptedException {
        // TODO Auto-generated method stub
        ExecutorService executorService = Executors.newFixedThreadPool(5);  
        for(int i = 0; i<POOL_NUM; i++)  
        {  
            RunnableThread thread = new RunnableThread();

            //Thread.sleep(1000);
            executorService.execute(thread);  
        }
        //關閉執行緒池
        executorService.shutdown(); 
    }   

}

class RunnableThread implements Runnable  
{     
    @Override
    public void run()  
    {  
        System.out.println("通過執行緒池方式建立的執行緒：" + Thread.currentThread().getName() + " ");  

    }  
}

執行結果
通過執行緒池方式建立的執行緒：pool-1-thread-3  
通過執行緒池方式建立的執行緒：pool-1-thread-4  
通過執行緒池方式建立的執行緒：pool-1-thread-1  
通過執行緒池方式建立的執行緒：pool-1-thread-5  
通過執行緒池方式建立的執行緒：pool-1-thread-2  
通過執行緒池方式建立的執行緒：pool-1-thread-5  
通過執行緒池方式建立的執行緒：pool-1-thread-1  
通過執行緒池方式建立的執行緒：pool-1-thread-4  
通過執行緒池方式建立的執行緒：pool-1-thread-3  
通過執行緒池方式建立的執行緒：pool-1-thread-2

這裡增加一點執行緒狀態的知識

執行緒總共有5大狀態，通過上面第二個知識點的介紹，理解起來就簡單了。

新建狀態：新建執行緒物件，並沒有呼叫start()方法之前

就緒狀態：呼叫start()方法之後執行緒就進入就緒狀態，但是並不是說只要呼叫start()方法執行緒就馬上變為當前執行緒，在變為當前執行緒之前都是為就緒狀態。值得一提的是，執行緒在睡眠和掛起中恢復的時候也會進入就緒狀態哦。

執行狀態：執行緒被設定為當前執行緒，開始執行run()方法。就是執行緒進入執行狀態

阻塞狀態：執行緒被暫停，比如說呼叫sleep()方法後執行緒就進入阻塞狀態

死亡狀態：執行緒執行結束