摘要：大多數待遇豐厚的開發職位都要求開發者精通多線程技術并且有豐富的程序開發調試優化經驗，所以線程相關的問題在面試中經常會被提到。掌握了這些技巧，你就可以輕松應對多線程和并發面試了。進入等待通行準許時，所提供的對象。

最近看到網上流傳著，各種面試經驗及面試題，往往都是一大堆技術題目貼上去，而沒有答案。

不管你是新程序員還是老手，你一定在面試中遇到過有關線程的問題。Java語言一個重要的特點就是內置了對并發的支持，讓Java大受企業和程序員的歡迎。大多數待遇豐厚的Java開發職位都要求開發者精通多線程技術并且有豐富的Java程序開發、調試、優化經驗，所以線程相關的問題在面試中經常會被提到。
在典型的Java面試中， 面試官會從線程的基本概念問起

如：為什么你需要使用線程， 如何創建線程，用什么方式創建線程比較好（比如：繼承thread類還是調用Runnable接口），然后逐漸問到并發問題像在Java并發編程的過程中遇到了什么挑戰，Java內存模型，JDK1.5引入了哪些更高階的并發工具，并發編程常用的設計模式，經典多線程問題如生產者消費者，哲學家就餐，讀寫器或者簡單的有界緩沖區問題。僅僅知道線程的基本概念是遠遠不夠的， 你必須知道如何處理死鎖，競態條件，內存沖突和線程安全等并發問題。掌握了這些技巧，你就可以輕松應對多線程和并發面試了。
許多Java程序員在面試前才會去看面試題，這很正常。

因為收集面試題和練習很花時間，所以我從許多面試者那里收集了Java多線程和并發相關的50個熱門問題。

下面是Java線程相關的熱門面試題，你可以用它來好好準備面試。

前25題想進大廠？50個多線程面試題，你會多少？（一）

什么是線程？

什么是線程安全和線程不安全？

什么是自旋鎖？

什么是Java內存模型？

什么是CAS？

什么是樂觀鎖和悲觀鎖？

什么是AQS？

什么是原子操作？在Java Concurrency API中有哪些原子類(atomic classes)？

什么是Executors框架？

什么是阻塞隊列？如何使用阻塞隊列來實現生產者-消費者模型？

什么是Callable和Future?

什么是FutureTask?

什么是同步容器和并發容器的實現？

什么是多線程？優缺點？

什么是多線程的上下文切換？

ThreadLocal的設計理念與作用？

ThreadPool（線程池）用法與優勢？

Concurrent包里的其他東西：ArrayBlockingQueue、CountDownLatch等等。

synchronized和ReentrantLock的區別？

Semaphore有什么作用？

Java Concurrency API中的Lock接口(Lock interface)是什么？對比同步它有什么優勢？

Hashtable的size()方法中明明只有一條語句”return count”，為什么還要做同步？

ConcurrentHashMap的并發度是什么？

ReentrantReadWriteLock讀寫鎖的使用？

CyclicBarrier和CountDownLatch的用法及區別？

LockSupport工具？

Condition接口及其實現原理？

Fork/Join框架的理解?

wait()和sleep()的區別?

線程的五個狀態（五種狀態，創建、就緒、運行、阻塞和死亡）?

start()方法和run()方法的區別？

Runnable接口和Callable接口的區別？

volatile關鍵字的作用？

Java中如何獲取到線程dump文件？

線程和進程有什么區別？

線程實現的方式有幾種（四種）？

高并發、任務執行時間短的業務怎樣使用線程池？并發不高、任務執行時間長的業務怎樣使用線程池？并發高、業務執行時間長的業務怎樣使用線程池？

如果你提交任務時，線程池隊列已滿，這時會發生什么？

鎖的等級：方法鎖、對象鎖、類鎖?

如果同步塊內的線程拋出異常會發生什么？

并發編程（concurrency）并行編程（parallellism）有什么區別？

如何保證多線程下 i++ 結果正確？

一個線程如果出現了運行時異常會怎么樣?

如何在兩個線程之間共享數據?

生產者消費者模型的作用是什么?

怎么喚醒一個阻塞的線程?

Java中用到的線程調度算法是什么

單例模式的線程安全性?

線程類的構造方法、靜態塊是被哪個線程調用的?

同步方法和同步塊，哪個是更好的選擇?

如何檢測死鎖？怎么預防死鎖？

前25題 想進大廠？50個多線程面試題，你會多少？（一）

CyclicBarrier和CountDownLatch 都位于java.util.concurrent 這個包下

CountDownLatch類只提供了一個構造器：

public CountDownLatch(int count) {  };  //參數count為計數值  

然后下面這3個方法是CountDownLatch類中最重要的方法：

public void await() throws InterruptedException { };   //調用await()方法的線程會被掛起，它會等待直到count值為0才繼續執行  
public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };  //和await()類似，只不過等待一定的時間后count值還沒變為0的話就會繼續執行  
public void countDown() { };  //將count值減1  

CountDownLatch， 一個同步輔助類，在完成一組正在其他線程中執行的操作之前，它允許一個或多個線程一直等待。

下面舉個例子說明：

package main.java.CountDownLatch;  
  
import java.util.concurrent.CountDownLatch;  
  
/** 
 * PROJECT_NAME:downLoad 
 * Author:lucaifang 
 * Date:2016/3/18 
 */  
public class countDownlatchTest {  
    public static void main(String[] args) throws InterruptedException {  
        CountDownLatch countDownLatch = new CountDownLatch(5);  
        for(int i=0;i<5;i++){  
            new Thread(new readNum(i,countDownLatch)).start();  
        }  
        countDownLatch.await();  
        System.out.println("線程執行結束。。。。");  
    }  
  
    static class readNum  implements Runnable{  
        private int id;  
        private CountDownLatch latch;  
        public readNum(int id,CountDownLatch latch){  
            this.id = id;  
            this.latch = latch;  
        }  
        @Override  
        public void run() {  
            synchronized (this){  
                System.out.println("id:"+id);  
                latch.countDown();  
                System.out.println("線程組任務"+id+"結束，其他任務繼續");  
            }  
        }  
    }  
}  

輸出結果：

id:1
線程組任務1結束，其他任務繼續
id:0
線程組任務0結束，其他任務繼續
id:2
線程組任務2結束，其他任務繼續
id:3
線程組任務3結束，其他任務繼續
id:4
線程組任務4結束，其他任務繼續
線程執行結束。。。。

線程在countDown()之后，會繼續執行自己的任務

CyclicBarrier會在所有線程任務結束之后，才會進行后續任務，具體可以看下面例子。

CyclicBarrier提供2個構造器：

public CyclicBarrier(int parties, Runnable barrierAction) {  
}  
   
public CyclicBarrier(int parties) {  
}  

參數parties指讓多少個線程或者任務等待至barrier狀態；參數barrierAction為當這些線程都達到barrier狀態時會執行的內容。
CyclicBarrier中最重要的方法就是await方法

//掛起當前線程，直至所有線程都到達barrier狀態再同時執行后續任務；  
public int await() throws InterruptedException, BrokenBarrierException { };

//讓這些線程等待至一定的時間，如果還有線程沒有到達barrier狀態就直接讓到達barrier的線程執行后續任務  
public int await(long timeout, TimeUnit unit)throws InterruptedException,BrokenBarrierException,TimeoutException { };

舉例說明

package main.java.countOff;  
  
import java.util.concurrent.CyclicBarrier;  
  
/** 
 * PROJECT_NAME:downLoad 
 * Author:lucaifang 
 * Date:2016/3/18 
 */  
public class cyclicBarrierTest {  
    public static void main(String[] args) throws InterruptedException {  
        CyclicBarrier cyclicBarrier = new CyclicBarrier(5, new Runnable() {  
            @Override  
            public void run() {  
                System.out.println("線程組執行結束");  
            }  
        });  
        for (int i = 0; i < 5; i++) {  
            new Thread(new readNum(i,cyclicBarrier)).start();  
        }  
        //CyclicBarrier 可以重復利用，  
        // 這個是CountDownLatch做不到的  
//        for (int i = 11; i < 16; i++) {  
//            new Thread(new readNum(i,cyclicBarrier)).start();  
//        }  
    }  
    static class readNum  implements Runnable{  
        private int id;  
        private CyclicBarrier cyc;  
        public readNum(int id,CyclicBarrier cyc){  
            this.id = id;  
            this.cyc = cyc;  
        }  
        @Override  
        public void run() {  
            synchronized (this){  
                System.out.println("id:"+id);  
                try {  
                    cyc.await();  
                    System.out.println("線程組任務" + id + "結束，其他任務繼續");  
                } catch (Exception e) {  
                    e.printStackTrace();  
                }  
            }  
        }  
    }  
} 

輸出結果：

id:1
id:2
id:4
id:0
id:3
線程組執行結束
線程組任務3結束，其他任務繼續
線程組任務1結束，其他任務繼續
線程組任務4結束，其他任務繼續
線程組任務0結束，其他任務繼續
線程組任務2結束，其他任務繼續

http://blog.csdn.net/tolcf/article/details/50925145

1、LockSupport基本介紹與基本使用

LockSupport是JDK中比較底層的類，用來創建鎖和其他同步工具類的基本線程阻塞。java鎖和同步器框架的核心 AQS: AbstractQueuedSynchronizer，就是通過調用 LockSupport .park()和 LockSupport .unpark()實現線程的阻塞和喚醒 的。

LockSupport 很類似于二元信號量(只有1個許可證可供使用)，如果這個許可還沒有被占用，當前線程獲取許可并繼 續 執行；如果許可已經被占用，當前線 程阻塞，等待獲取許可。

park()/park(Object)

等待通行準許。

parkNanos(long)/parkNanos(Object, long)

在指定運行時間（即相對時間）內，等待通行準許。

parkUntil(long)/parkUntil(Object, long)

在指定到期時間（即絕對時間）內，等待通行準許。

unpark(Thread)

發放通行準許或提前發放。（注：不管提前發放多少次，只用于一次性使用。）

getBlocker(Thread)

進入等待通行準許時，所提供的對象。

當前線程需要喚醒另一個線程，但是只確定它會進入阻塞，但不確定它是否已經進入阻塞，因此不管是否已經進入阻塞，還是準備進入阻塞，都將發放一個通行準許。

把LockSupport視為一個sleep()來用，只是sleep()是定時喚醒，LockSupport既可以定時喚醒，也可以由其它線程喚醒。

public static void main(String[] args)
{
     LockSupport.park();
     System.out.println("block.");
}

運行該代碼，可以發現主線程一直處于阻塞狀態。因為 許可默認是被占用的 ，調用park()時獲取不到許可，所以進入阻塞狀態。

如下代碼：先釋放許可，再獲取許可，主線程能夠正常終止。LockSupport許可的獲取和釋放，一般來說是對應的，如果多次unpark，只有一次park也不會出現什么問題，結果是許可處于可用狀態。

public static void main(String[] args)
{
     Thread thread = Thread.currentThread();
     LockSupport.unpark(thread);//釋放許可
     LockSupport.park();// 獲取許可
     System.out.println("b");
}

LockSupport是不可重入 的，如果一個線程連續2次調用 LockSupport .park()，那么該線程一定會一直阻塞下去。

public static void main(String[] args) throws Exception
{
  Thread thread = Thread.currentThread();
  
  LockSupport.unpark(thread);
  
  System.out.println("a");
  LockSupport.park();
  System.out.println("b");
  LockSupport.park();
  System.out.println("c");
}

這段代碼打印出a和b，不會打印c，因為第二次調用park的時候，線程無法獲取許可出現死鎖。

LockSupport基本介紹與基本使用

https://www.cnblogs.com/hvicen/p/6217303.html

LockSupport基本介紹與基本使用

http://www.tianshouzhi.com/api/tutorials/mutithread/303

在java.util.concurrent包中，有兩個很特殊的工具類，Condition和ReentrantLock，使用過的人都知道，ReentrantLock（重入鎖）是jdk的concurrent包提供的一種獨占鎖的實現

我們知道在線程的同步時可以使一個線程阻塞而等待一個信號，同時放棄鎖使其他線程可以能競爭到鎖

在synchronized中我們可以使用Object的wait()和notify方法實現這種等待和喚醒

但是在Lock中怎么實現這種wait和notify呢？

答案是Condition，學習Condition主要是為了方便以后學習blockqueue和concurrenthashmap的源碼，同時也進一步理解ReentrantLock。

ReentrantLock和Condition的使用方式通常是這樣的：

public static void main(String[] args) {
    final ReentrantLock reentrantLock = new ReentrantLock();
    final Condition condition = reentrantLock.newCondition();
 
    Thread thread = new Thread((Runnable) () -> {
            try {
                reentrantLock.lock();
                System.out.println("我要等一個新信號" + this);
                condition.wait();
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("拿到一個信號！！" + this);
            reentrantLock.unlock();
    }, "waitThread1");
 
    thread.start();
     
    Thread thread1 = new Thread((Runnable) () -> {
            reentrantLock.lock();
            System.out.println("我拿到鎖了");
            try {
                Thread.sleep(3000);
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
            condition.signalAll();
            System.out.println("我發了一個信號！！");
            reentrantLock.unlock();
    }, "signalThread");
     
    thread1.start();
}

運行后，結果如下：

我要等一個新信號lock.ReentrantLockTest$1@a62fc3
我拿到鎖了
我發了一個信號！！
拿到一個信號！！

可以看到

Condition的執行方式，是當在線程1中調用await方法后，線程1將釋放鎖，并且將自己沉睡，等待喚醒，

線程2獲取到鎖后，開始做事，完畢后，調用Condition的signal方法，喚醒線程1，線程1恢復執行。

以上說明Condition是一個多線程間協調通信的工具類，使得某個，或者某些線程一起等待某個條件（Condition）,只有當該條件具備( signal 或者 signalAll方法被帶調用)時 ，這些等待線程才會被喚醒，從而重新爭奪鎖。

Condition自己也維護了一個隊列，該隊列的作用是維護一個等待signal信號的隊列，兩個隊列的作用是不同，事實上，每個線程也僅僅會同時存在以上兩個隊列中的一個，流程是這樣的

線程1調用reentrantLock.lock時，線程被加入到AQS的等待隊列中。

線程1調用await方法被調用時，該線程從AQS中移除，對應操作是鎖的釋放。

接著馬上被加入到Condition的等待隊列中，以為著該線程需要signal信號。

線程2，因為線程1釋放鎖的關系，被喚醒，并判斷可以獲取鎖，于是線程2獲取鎖，并被加入到AQS的等待隊列中。

線程2調用signal方法，這個時候Condition的等待隊列中只有線程1一個節點，于是它被取出來，并被加入到AQS的等待隊列中。 注意，這個時候，線程1 并沒有被喚醒。

signal方法執行完畢，線程2調用reentrantLock.unLock()方法，釋放鎖。這個時候因為AQS中只有線程1，于是，AQS釋放鎖后按從頭到尾的順序喚醒線程時，線程1被喚醒，于是線程1回復執行。

直到釋放所整個過程執行完畢。

可以看到，整個協作過程是靠結點在AQS的等待隊列和Condition的等待隊列中來回移動實現的，Condition作為一個條件類，很好的自己維護了一個等待信號的隊列，并在適時的時候將結點加入到AQS的等待隊列中來實現的喚醒操作。

怎么理解Condition

http://www.importnew.com/9281.html

深入理解Condition

https://www.jianshu.com/p/6b5aa7b7684c

Oracle的官方給出的定義是：Fork/Join框架是一個實現了ExecutorService接口的多線程處理器。它可以把一個大的任務劃分為若干個小的任務并發執行，充分利用可用的資源，進而提高應用的執行效率。

我們再通過Fork和Join這兩個單詞來理解下Fork/Join框架，Fork就是把一個大任務切分為若干子任務并行的執行，Join就是合并這些子任務的執行結果，最后得到這個大任務的結果。

比如計算1+2+。。＋10000，可以分割成10個子任務，每個子任務分別對1000個數進行求和，最終匯總這10個子任務的結果。

工作竊取算法是指線程從其他任務隊列中竊取任務執行（可能你會很詫異，這個算法有什么用。待會你就知道了）。考慮下面這種場景：有一個很大的計算任務，為了減少線程的競爭，會將這些大任務切分為小任務并分在不同的隊列等待執行，然后為每個任務隊列創建一個線程執行隊列的任務。那么問題來了，有的線程可能很快就執行完了，而其他線程還有任務沒執行完，執行完的線程與其空閑下來不如幫助其他線程執行任務，這樣也能加快執行進程。所以，執行完的空閑線程從其他隊列的尾部竊取任務執行，而被竊取任務的線程則從隊列的頭部取任務執行（這里使用了雙端隊列，既不影響被竊取任務的執行過程又能加快執行進度）。

從以上的介紹中，能夠發現工作竊取算法的優點是充分利用線程提高并行執行的進度。當然缺點是在某些情況下仍然存在競爭，比如雙端隊列只有任務需要執行的時候

分割任務：首先需要創建一個ForkJoin任務，執行該類的fork方法可以對任務不斷切割，直到分割的子任務足夠小

合并任務執行結果：子任務執行的結果同一放在一個隊列中，通過啟動一個線程從隊列中取執行結果。

Fork/Join實現了ExecutorService，所以它的任務也需要放在線程池中執行。它的不同在于它使用了工作竊取算法，空閑的線程可以從滿負荷的線程中竊取任務來幫忙執行。

下面是計算1+2+3+4為例演示如何使用使用Fork/Join框架：

package com.rhwayfun.concurrency.r0406;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;

/**
 * Created by rhwayfun on 16-4-6.
 */
public class CountTask extends RecursiveTask{

    //閾值
    private static final int THRESHOLD = 2;
    //起始值
    private int start;
    //結束值
    private int end;

    public CountTask(int start, int end) {
        this.start = start;
        this.end = end;
    }


    @Override
    protected Integer compute() {
        boolean compute = (end - start) <= THRESHOLD;
        int res = 0;
        if (compute){
            for (int i = start; i <= end; i++){
                res += i;
            }
        }else {
            //如果長度大于閾值，則分割為小任務
            int mid = (start + end) / 2;
            CountTask task1 = new CountTask(start,mid);
            CountTask task2 = new CountTask(mid + 1, end);
            //計算小任務的值
            task1.fork();
            task2.fork();
            //得到兩個小任務的值
            int task1Res = task1.join();
            int task2Res = task2.join();
            res = task1Res + task2Res;
        }
        return res;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ForkJoinPool pool = new ForkJoinPool();
        CountTask task = new CountTask(1,5);
        ForkJoinTask submit = pool.submit(task);
        System.out.println("Final result:" + submit.get());
    }
}

代碼執行結果為：

15

代碼中使用了FokJoinTask，其與一般任務的區別在于它需要實現compute方法，在方法需要判斷任務是否在閾值區間內，如果不是則需要把任務切分到足夠小，直到能夠進行計算。

每個被切分的子任務又會重新進入compute方法，再繼續判斷是否需要繼續切分，如果不需要則直接得到子任務執行的結果，如果需要的話則繼續切分，如此循環，直到調用join方法得到最終的結果。
**
可以發現Fork/Join框架的需要把提交給ForkJoinPool，ForkJoinPool由ForkJoinTask數組和ForkJoinWorkerThread數組組成，前者負責將存放程序提交給ForkJoinPool的任務，后者則負責執行這些任務。關鍵在于在于fork方法與join方法**

Java并發編程系列之二十：Fork/Join框架

http://blog.csdn.net/u011116672/article/details/51073683

sleep()

方法是線程類（Thread）的靜態方法，讓調用線程進入睡眠狀態，讓出執行機會給其他線程，等到休眠時間結束后，線程進入就緒狀態和其他線程一起競爭cpu的執行時間。

因為sleep() 是static靜態的方法，他不能改變對象的機鎖，當一個synchronized塊中調用了sleep() 方法，線程雖然進入休眠，但是對象的機鎖沒有被釋放，其他線程依然無法訪問這個對象。

wait()

wait()是Object類的方法，當一個線程執行到wait方法時，它就進入到一個和該對象相關的等待池，同時釋放對象的機鎖，使得其他線程能夠訪問，可以通過notify，notifyAll方法來喚醒等待的線程

線程通常都有五種狀態，創建、就緒、運行、阻塞和死亡。

第一是創建狀態。在生成線程對象，并沒有調用該對象的start方法，這是線程處于創建狀態。

第二是就緒狀態。當調用了線程對象的start方法之后，該線程就進入了就緒狀態，但是此時線程調度程序還沒有把該線程設置為當前線程，此時處于就緒狀態。在線程運行之后，從等待或者睡眠中回來之后，也會處于就緒狀態。

第三是運行狀態。線程調度程序將處于就緒狀態的線程設置為當前線程，此時線程就進入了運行狀態，開始運行run函數當中的代碼。

第四是阻塞狀態。線程正在運行的時候，被暫停，通常是為了等待某個時間的發生(比如說某項資源就緒)之后再繼續運行。sleep,suspend，wait等方法都可以導致線程阻塞。

第五是死亡狀態。如果一個線程的run方法執行結束或者調用stop方法后，該線程就會死亡。對于已經死亡的線程，無法再使用start方法令其進入就緒

每個線程都是通過某個特定Thread對象所對應的方法run()來完成其操作的，方法run()稱為線程體。通過調用Thread類的start()方法來啟動一個線程。

start()方法來啟動一個線程，真正實現了多線程運行。這時無需等待run方法體代碼執行完畢，可以直接繼續執行下面的代碼；
這時此線程是處于就緒狀態， 并沒有運行。 然后通過此Thread類調用方法run()來完成其運行狀態， 這里方法run()稱為線程體，它包含了要執行的這個線程的內容， Run方法運行結束， 此線程終止。然后CPU再調度其它線程。

run()方法是在本線程里的，只是線程里的一個函數,而不是多線程的。
如果直接調用run(),其實就相當于是調用了一個普通函數而已，直接待用run()方法必須等待run()方法執行完畢才能執行下面的代碼，所以執行路徑還是只有一條，根本就沒有線程的特征，所以在多線程執行時要使用start()方法而不是run()方法。

有點深的問題了，也看出一個Java程序員學習知識的廣度。

Runnable接口中的run()方法的返回值是void，它做的事情只是純粹地去執行run()方法中的代碼而已；

Callable接口中的call()方法是有返回值的，是一個泛型，和Future、FutureTask配合可以用來獲取異步執行的結果。

這其實是很有用的一個特性，因為多線程相比單線程更難、更復雜的一個重要原因就是因為多線程充滿著未知性，某條線程是否執行了？某條線程執行了多久？某條線程執行的時候我們期望的數據是否已經賦值完畢？無法得知，我們能做的只是等待這條多線程的任務執行完畢而已。而Callable+Future/FutureTask卻可以獲取多線程運行的結果，可以在等待時間太長沒獲取到需要的數據的情況下取消該線程的任務，真的是非常有用。

volatile關鍵字的作用主要有兩個：

（1）多線程主要圍繞可見性和原子性兩個特性而展開，使用volatile關鍵字修飾的變量，保證了其在多線程之間的可見性，即每次讀取到volatile變量，一定是最新的數據

（2）代碼底層執行不像我們看到的高級語言—-Java程序這么簡單，它的執行是Java代碼–>字節碼–>根據字節碼執行對應的C/C++代碼–>C/C++代碼被編譯成匯編語言–>和硬件電路交互，現實中，為了獲取更好的性能JVM可能會對指令進行重排序，多線程下可能會出現一些意想不到的問題。使用volatile則會對禁止語義重排序，當然這也一定程度上降低了代碼執行效率

從實踐角度而言，volatile的一個重要作用就是和CAS結合，保證了原子性，詳細的可以參見java.util.concurrent.atomic包下的類，比如AtomicInteger。

死循環、死鎖、阻塞、頁面打開慢等問題，打線程dump是最好的解決問題的途徑。所謂線程dump也就是線程堆棧，獲取到線程堆棧有兩步：

（1）獲取到線程的pid，可以通過使用jps命令，在Linux環境下還可以使用ps -ef | grep java

（2）打印線程堆棧，可以通過使用jstack pid命令，在Linux環境下還可以使用kill -3 pid

另外提一點，Thread類提供了一個getStackTrace()方法也可以用于獲取線程堆棧。這是一個實例方法，因此此方法是和具體線程實例綁定的，每次獲取獲取到的是具體某個線程當前運行的堆棧，

虛擬機性能監控與故障處理工具 詳解

http://www.ymq.io/2017/08/01/jvm-4/

進程是系統進行資源分配的基本單位，有獨立的內存地址空間

線程是CPU獨立運行和獨立調度的基本單位，沒有多帶帶地址空間，有獨立的棧，局部變量，寄存器， 程序計數器等。

創建進程的開銷大，包括創建虛擬地址空間等需要大量系統資源

創建線程開銷小，基本上只有一個內核對象和一個堆棧。

一個進程無法直接訪問另一個進程的資源；同一進程內的多個線程共享進程的資源。

進程切換開銷大，線程切換開銷小；進程間通信開銷大，線程間通信開銷小。

線程屬于進程，不能獨立執行。每個進程至少要有一個線程，成為主線程

繼承Thread類，重寫run方法

實現Runnable接口，重寫run方法，實現Runnable接口的實現類的實例對象作為Thread構造函數的target

實現Callable接口通過FutureTask包裝器來創建Thread線程

通過線程池創建線程

前面兩種可以歸結為一類：無返回值，原因很簡單，通過重寫run方法，run方式的返回值是void，所以沒有辦法返回結果

后面兩種可以歸結成一類：有返回值，通過Callable接口，就要實現call方法，這個方法的返回值是Object，所以返回的結果可以放在Object對象中

創建Callable接口的實現類 ，并實現Call方法

創建Callable實現類的實現，使用FutureTask類包裝Callable對象，該FutureTask對象封裝了Callable對象的Call方法的返回值

使用FutureTask對象作為Thread對象的target創建并啟動線程

調用FutureTask對象的get()來獲取子線程執行結束的返回值

public class ThreadDemo03 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Callable