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

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

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

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

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

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

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

什么是線程？

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

什么是自旋鎖？

什么是Java內存模型？

什么是CAS？

什么是樂觀鎖和悲觀鎖？

什么是AQS？

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

什么是Executors框架？

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

什么是Callable和Future?

什么是FutureTask?

什么是同步容器和并發(fā)容器的實現(xiàn)？

什么是多線程？優(yōu)缺點？

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

ThreadLocal的設計理念與作用？

ThreadPool（線程池）用法與優(yōu)勢？

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

synchronized和ReentrantLock的區(qū)別？

Semaphore有什么作用？

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

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

ConcurrentHashMap的并發(fā)度是什么？

ReentrantReadWriteLock讀寫鎖的使用？

CyclicBarrier和CountDownLatch的用法及區(qū)別？

LockSupport工具？

Condition接口及其實現(xiàn)原理？

Fork/Join框架的理解?

wait()和sleep()的區(qū)別?

線程的五個狀態(tài)（五種狀態(tài)，創(chuàng)建、就緒、運行、阻塞和死亡）?

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

Runnable接口和Callable接口的區(qū)別？

volatile關鍵字的作用？

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

線程和進程有什么區(qū)別？

線程實現(xiàn)的方式有幾種（四種）？

高并發(fā)、任務執(zhí)行時間短的業(yè)務怎樣使用線程池？并發(fā)不高、任務執(zhí)行時間長的業(yè)務怎樣使用線程池？并發(fā)高、業(yè)務執(zhí)行時間長的業(yè)務怎樣使用線程池？

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

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

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

并發(fā)編程（concurrency）并行編程（parallellism）有什么區(qū)別？

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

一個線程如果出現(xiàn)了運行時異常會怎么樣?

如何在兩個線程之間共享數(shù)據(jù)?

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

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

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

單例模式的線程安全性?

線程類的構造方法、靜態(tài)塊是被哪個線程調用的?

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

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

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

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

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

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

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

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

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

下面舉個例子說明：

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("線程執(zhí)行結束。。。。");  
    }  
  
    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+"結束，其他任務繼續(xù)");  
            }  
        }  
    }  
}  

輸出結果：

id:1
線程組任務1結束，其他任務繼續(xù)
id:0
線程組任務0結束，其他任務繼續(xù)
id:2
線程組任務2結束，其他任務繼續(xù)
id:3
線程組任務3結束，其他任務繼續(xù)
id:4
線程組任務4結束，其他任務繼續(xù)
線程執(zhí)行結束。。。。

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

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

CyclicBarrier提供2個構造器：

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

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

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

//讓這些線程等待至一定的時間，如果還有線程沒有到達barrier狀態(tài)就直接讓到達barrier的線程執(zhí)行后續(xù)任務  
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("線程組執(zhí)行結束");  
            }  
        });  
        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 + "結束，其他任務繼續(xù)");  
                } catch (Exception e) {  
                    e.printStackTrace();  
                }  
            }  
        }  
    }  
} 

輸出結果：

id:1
id:2
id:4
id:0
id:3
線程組執(zhí)行結束
線程組任務3結束，其他任務繼續(xù)
線程組任務1結束，其他任務繼續(xù)
線程組任務4結束，其他任務繼續(xù)
線程組任務0結束，其他任務繼續(xù)
線程組任務2結束，其他任務繼續(xù)

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

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

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

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

park()/park(Object)

等待通行準許。

parkNanos(long)/parkNanos(Object, long)

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

parkUntil(long)/parkUntil(Object, long)

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

unpark(Thread)

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

getBlocker(Thread)

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

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

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

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

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

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

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

LockSupport是不可重入 的，如果一個線程連續(xù)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的時候，線程無法獲取許可出現(xiàn)死鎖。

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包提供的一種獨占鎖的實現(xiàn)

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

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

但是在Lock中怎么實現(xiàn)這種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("我發(fā)了一個信號！！");
            reentrantLock.unlock();
    }, "signalThread");
     
    thread1.start();
}

運行后，結果如下：

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

可以看到

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

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

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

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

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

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

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

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

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

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

直到釋放所整個過程執(zhí)行完畢。

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

怎么理解Condition

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

深入理解Condition

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

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

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

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

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

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

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

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

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

下面是計算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());
    }
}

代碼執(zhí)行結果為：

15

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

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

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

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

sleep()

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

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

wait()

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

線程通常都有五種狀態(tài)，創(chuàng)建、就緒、運行、阻塞和死亡。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

虛擬機性能監(jiān)控與故障處理工具 詳解

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

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

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

創(chuàng)建進程的開銷大，包括創(chuàng)建虛擬地址空間等需要大量系統(tǒng)資源

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

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

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

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

繼承Thread類，重寫run方法

實現(xiàn)Runnable接口，重寫run方法，實現(xiàn)Runnable接口的實現(xiàn)類的實例對象作為Thread構造函數(shù)的target

實現(xiàn)Callable接口通過FutureTask包裝器來創(chuàng)建Thread線程

通過線程池創(chuàng)建線程

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

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

創(chuàng)建Callable接口的實現(xiàn)類 ，并實現(xiàn)Call方法

創(chuàng)建Callable實現(xiàn)類的實現(xiàn)，使用FutureTask類包裝Callable對象，該FutureTask對象封裝了Callable對象的Call方法的返回值

使用FutureTask對象作為Thread對象的target創(chuàng)建并啟動線程

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

public class ThreadDemo03 {

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

        Callable