1. 多線程的創建方式
（1）、繼承 Thread類：但Thread本質上也是實現了Runnable 接口的一個實例，它代表一個線程的實例，並且，啟動線程的唯一方法就是通過 Thread 類的 start()實例方法。start()方法是一個 native 方法，它將啟動一個新線程，並執行run()方法。這種方式實現多線程很簡單，通過自己的類直接extend Thread，並復寫run()方法，就可以啟動新線程並執行自己定義的run()方法。例如：繼承Thread類實現多線程，並在合適的地方啟動線程
1．public class MyThread extends Thread { 2． public void run() { 3． System.out.println("MyThread.run()"); 4． } 5．} 6．MyThread myThread1 = new MyThread(); 7．MyThread myThread2 = new MyThread(); 8．myThread1.start(); 9．myThread2.start();
（2）、實現Runnable接口的方式實現多線程，並且實例化Thread，傳入自己的Thread實例，調用run( )方法
1．public class MyThread implements Runnable { 2． public void run() { 3． System.out.println("MyThread.run()"); 4． } 5．} 6．MyThread myThread = new MyThread(); 7．Thread thread = new Thread(myThread); 8．thread.start();
（3）、使用ExecutorService、Callable、Future實現有返回結果的多線程：ExecutorService、Callable、Future這 個 對 象 實際 上 都是屬 於 Executor 框 架中 的 功 能 類。 想 要詳細 了 解 Executor 框架 的 可 以 訪問http://www.javaeye.com/topic/366591 ，這里面對該框架做了很詳細的解釋。返回結果的線程是在JDK1.5中引入的新特征，確實很實用，有了這種特征我就不需要再為了得到返回值而大費周折了，而且即便實現了也可能漏洞百出。可返回值的任務必須實現Callable接口，類似的，無返回值的任務必須Runnable接口。執行Callable任務后，可以獲取一個 Future 的對象，在該對象上調用 get 就可以獲取到 Callable 任務返回的 Object 了，再結合線程池接口ExecutorService就可以實現傳說中有返回結果的多線程了。下面提供了一個完整的有返回結果的多線程測試例子，在JDK1.5下驗證過沒問題可以直接使用。代碼如下：
1．import java.util.concurrent.*; 2．import java.util.Date; 3．import java.util.List; 4．import java.util.ArrayList; 5． 6．/** 7．* 有返回值的線程 8．*/ 9．@SuppressWarnings("unchecked") 10．public class Test { 11．public static void main(String[] args) throws ExecutionException, 12． InterruptedException { 13． System.out.println("----程序開始運行----"); 14． Date date1 = new Date(); 15． 16． int taskSize = 5; 17． // 創建一個線程池 18． ExecutorService pool = Executors.newFixedThreadPool(taskSize); 19． // 創建多個有返回值的任務 20． List<Future> list = new ArrayList<Future>(); 21． for (int i = 0; i < taskSize; i++) { 22． Callable c = new MyCallable(i + " "); 23． // 執行任務並獲取 Future 對象 24． Future f = pool.submit(c); 25． // System.out.println(">>>" + f.get().toString()); 26． list.add(f); 27． } 28． // 關閉線程池 29． pool.shutdown(); 30． 31． // 獲取所有並發任務的運行結果 32． for (Future f : list) { 33． // 從 Future 對象上獲取任務的返回值，並輸出到控制台 34． System.out.println(">>>" + f.get().toString()); 35． } 36． 37． Date date2 = new Date(); 38． System.out.println("----程序結束運行----，程序運行時間【" 39． + (date2.getTime() - date1.getTime()) + "毫秒】"); 40．} 41．} 42． 43．class MyCallable implements Callable<Object> { 44．private String taskNum; 45． 46．MyCallable(String taskNum) { 47． this.taskNum = taskNum; 48．} 49． 50．public Object call() throws Exception { 51． System.out.println(">>>" + taskNum + "任務啟動"); 52． Date dateTmp1 = new Date(); 53． Thread.sleep(1000); 54． Date dateTmp2 = new Date(); 55． long time = dateTmp2.getTime() - dateTmp1.getTime(); 56． System.out.println(">>>" + taskNum + "任務終止"); 57． return taskNum + "任務返回運行結果,當前任務時間【" + time + "毫秒】"; 58．} 59．}
2. 在 java 中 wait 和 sleep 方法的不同？
最大的不同是在等待時wait會釋放鎖，而sleep一直持有鎖。wait通常被用於線程間交互，sleep通常被用於暫停執行。
3. synchronized 和 volatile 關鍵字的作用
一旦一個共享變量（類的成員變量、類的靜態成員變量）被volatile修飾之后，那么就具備了兩層語義：
1）保證了不同線程對這個變量進行操作時的可見性，即一個線程修改了某個變量的值，這新值對其他線程來說是
立即可見的。
2）禁止進行指令重排序。
volatile本質是在告訴jvm當前變量在寄存器（工作內存）中的值是不確定的，需要從主存中讀取；
synchronized則是鎖定當前變量，只有當前線程可以訪問該變量，其他線程被阻塞住。
1.volatile僅能使用在變量級別；
synchronized則可以使用在變量、方法、和類級別的
2.volatile僅能實現變量的修改可見性，並不能保證原子性；
synchronized則可以保證變量的修改可見性和原子性
3.volatile不會造成線程的阻塞；
synchronized可能會造成線程的阻塞。
4.volatile標記的變量不會被編譯器優化；
synchronized標記的變量可以被編譯器優化
4. 分析線程並發訪問代碼解釋原因
1. public class Counter { 2. private volatile int count = 0; 3. public void inc(){ 4. try { 5. Thread.sleep(3); 6. } catch (InterruptedException e) { 7. e.printStackTrace(); 8. } 9. count++; 10. } 11. @Override 12. public String toString() { 13. return "[count=" + count + "]"; 14. } 15. } 16. //---------------------------------華麗的分割線----------------------------- 17. public class VolatileTest { 18. public static void main(String[] args) { 19. final Counter counter = new Counter(); 20. for(int i=0;i<1000;i++){ 21. new Thread(new Runnable() { 22. @Override 23. public void run() { 24. counter.inc(); 25. } 26. }).start(); 27. } 28. System.out.println(counter); 29. } 30. }
上面的代碼執行完后輸出的結果確定為1000嗎？
答案是不一定，或者不等於1000。這是為什么嗎？
在 java 的內存模型中每一個線程運行時都有一個線程棧，線程棧保存了線程運行時候變量值信息。當線程訪問某一個對象時候值的時候，首先通過對象的引用找到對應在堆內存的變量的值，然后把堆內存變量的具體值load到線程本地內存中，建立一個變量副本，之后線程就不再和對象在堆內存變量值有任何關系，而是直接修改副本變量的值，在修改完之后的某一個時刻（線程退出之前），自動把線程變量副本的值回寫到對象在堆中變量。這樣在堆中的對象的值就產生變化了。
也就是說上面主函數中開啟了 1000 個子線程，每個線程都有一個變量副本，每個線程修改變量只是臨時修改了自己的副本，當線程結束時再將修改的值寫入在主內存中，這樣就出現了線程安全問題。因此結果就不可能等於1000了，一般都會小於1000。
5. 什么是線程池，如何使用？
線程池就是事先將多個線程對象放到一個容器中，當使用的時候就不用new線程而是直接去池中拿線程即可，節省了開辟子線程的時間，提高的代碼執行效率。
在JDK的java.util.concurrent.Executors中提供了生成多種線程池的靜態方法。
1. ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
2. ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(4); 3. ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(4); 4. ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();
然后調用他們的 execute 方法即可。
6. 常用的線程池有哪些？
newSingleThreadExecutor：創建一個單線程的線程池，此線程池保證所有任務的執行順序按照任務的提交順序執行。
newFixedThreadPool：創建固定大小的線程池，每次提交一個任務就創建一個線程，直到線程達到線程池的最大大小。
newCachedThreadPool：創建一個可緩存的線程池，此線程池不會對線程池大小做限制，線程池大小完全依賴於操作系統（或者說JVM）能夠創建的最大線程大小。
newScheduledThreadPool：創建一個大小無限的線程池，此線程池支持定時以及周期性執行任務的需求。
newSingleThreadExecutor：創建一個單線程的線程池。此線程池支持定時以及周期性執行任務的需求。
7. 請敘述一下您對線程池的理解？
第一：降低資源消耗。通過重復利用已創建的線程降低線程創建和銷毀造成的消耗。
第二：提高響應速度。當任務到達時，任務可以不需要等到線程創建就能立即執行。
第三：提高線程的可管理性。線程是稀缺資源，如果無限制的創建，不僅會消耗系統資源，還會降低系統的穩定性，使用線程池可以進行統一的分配，調優和監控。
8. 線程池的啟動策略？
官方對線程池的執行過程描述如下：
26. /* 27. * Proceed in 3 steps: 28. * 29. * 1. If fewer than corePoolSize threads are running, try to 30. * start a new thread with the given command as its first 31. * task. The call to addWorker atomically checks runState and 32. * workerCount, and so prevents false alarms that would add 33. * threads when it shouldn't, by returning false. 34. * 35. * 2. If a task can be successfully queued, then we still need 36. * to double-check whether we should have added a thread 37. * (because existing ones died since last checking) or that 38. * the pool shut down since entry into this method. So we 39. * recheck state and if necessary roll back the enqueuing if 40. * stopped, or start a new thread if there are none. 41. * 42. * 3. If we cannot queue task, then we try to add a new 43. * thread. If it fails, we know we are shut down or saturated 44. * and so reject the task. 45. */
1、線程池剛創建時，里面沒有一個線程。任務隊列是作為參數傳進來的。不過，就算隊列里面有任務，線程池也不會馬上執行它們。
2、當調用execute() 方法添加一個任務時，線程池會做如下判斷：
a. 如果正在運行的線程數量小於 corePoolSize，那么馬上創建線程運行這個任務；
b. 如果正在運行的線程數量大於或等於 corePoolSize，那么將這個任務放入隊列。
c. 如果這時候隊列滿了，而且正在運行的線程數量小於 maximumPoolSize，那么還是要創建線程運行這個任務；
d. 如果隊列滿了，而且正在運行的線程數量大於或等於 maximumPoolSize，那么線程池會拋出異常，告訴調用者“我不能再接受任務了”。
3、當一個線程完成任務時，它會從隊列中取下一個任務來執行。
4、當一個線程無事可做，超過一定的時間（keepAliveTime）時，線程池會判斷，如果當前運行的線程數大於corePoolSize，那么這個線程就被停掉。所以線程池的所有任務完成后，它最終會收縮到 corePoolSize 的大小。
9. 如何控制某個方法允許並發訪問線程的個數？
可以使用Semaphore控制，第16行的構造函數創建了一個Semaphore對象，並且初始化了5個信號。這樣的效果是控件 test 方法最多只能有 5 個線程並發訪問，對於 5 個線程時就排隊等待，走一個來一下。第 33行，請求一個信號（消費一個信號），如果信號被用完了則等待，第45行釋放一個信號，釋放的信號新的線程就可以使用了。
10. 三個線程 a、b、c 並發運行，b,c 需要 a 線程的數據怎么實現
根據問題的描述，我將問題用以下代碼演示，ThreadA、ThreadB、ThreadC，ThreadA 用於初始化數據 num，只有當num初始化完成之后再讓ThreadB和ThreadC獲取到初始化后的變量num。
分析過程如下：
考慮到多線程的不確定性，因此我們不能確保ThreadA就一定先於ThreadB和ThreadC前執行，就算ThreadA先執行了，我們也無法保證ThreadA什么時候才能將變量num給初始化完成。因此我們必須讓ThreadB和ThreadC去等待ThreadA完成任何后發出的消息。
現在需要解決兩個難題，一是讓 ThreadB 和 ThreadC 等待 ThreadA 先執行完，二是 ThreadA 執行完之后給ThreadB和ThreadC發送消息。
解決上面的難題我能想到的兩種方案，一是使用純Java API的Semaphore類來控制線程的等待和釋放，二是使用Android提供的Handler消息機制。
1. package com.example; 2. /** 3. * 三個線程 a、b、c 並發運行，b,c 需要 a 線程的數據怎么實現（上海 3 期學員提供） 4. * 5. */ 6. public class ThreadCommunication { 7. private static int num;//定義一個變量作為數據 8. 9. public static void main(String[] args) { 10. 11. Thread threadA = new Thread(new Runnable() { 12. 13. @Override 14. public void run() { 15. try { 16. //模擬耗時操作之后初始化變量 num 17. Thread.sleep(1000); 18. num = 1; 19. 20. } catch (InterruptedException e) { 21. e.printStackTrace(); 22. } 23. } 24. }); 25. Thread threadB = new Thread(new Runnable() { 26. 27. @Override 28. public void run() { 29. System.out.println(Thread.currentThread().getName()+"獲取到 num 的值為："+num); 30. } 31. }); 32. Thread threadC = new Thread(new Runnable() { 33. 34. @Override 35. public void run() { 36. System.out.println(Thread.currentThread().getName()+"獲取到 num 的值為："+num); 37. } 38. }); 39. //同時開啟 3 個線程 40. threadA.start(); 41. threadB.start(); 42. threadC.start(); 43. 44. } 45. } 46.
解決方案:
1. public class ThreadCommunication { 2. private static int num; 3. /** 4. * 定義一個信號量，該類內部維持了多個線程鎖，可以阻塞多個線程，釋放多個線程， 5. 線程的阻塞和釋放是通過 permit 概念來實現的 6. * 線程通過 semaphore.acquire()方法獲取 permit，如果當前 semaphore 有 permit 則分配給該線程， 7. 如果沒有則阻塞該線程直到 semaphore 8. * 調用 release（）方法釋放 permit。 9. * 構造函數中參數：permit（允許） 個數， 10. */ 11. private static Semaphore semaphore = new Semaphore(0); 12. public static void main(String[] args) { 13. 14. Thread threadA = new Thread(new Runnable() { 15. 16. @Override 17. public void run() { 18. try { 19. //模擬耗時操作之后初始化變量 num 20. Thread.sleep(1000); 21. num = 1; 22. //初始化完參數后釋放兩個 permit 23. semaphore.release(2); 24. 25. } catch (InterruptedException e) { 26. e.printStackTrace(); 27. } 28. } 29. }); 30. Thread threadB = new Thread(new Runnable() { 31. 32. @Override 33. public void run() { 34. try { 35. //獲取 permit，如果 semaphore 沒有可用的 permit 則等待，如果有則消耗一個 36. semaphore.acquire(); 37. } catch (InterruptedException e) { 38. e.printStackTrace(); 39. } 40. System.out.println(Thread.currentThread().getName()+"獲取到 num 的值為："+num); 41. } 42. }); 43. Thread threadC = new Thread(new Runnable() { 44. 45. @Override 46. public void run() { 47. try { 48. //獲取 permit，如果 semaphore 沒有可用的 permit 則等待，如果有則消耗一個 49. semaphore.acquire(); 50. } catch (InterruptedException e) { 51. e.printStackTrace(); 52. } 53. System.out.println(Thread.currentThread().getName()+"獲取到 num 的值為："+num); 54. } 55. }); 56. //同時開啟 3 個線程 57. threadA.start(); 58. threadB.start(); 59. threadC.start(); 60. 61. } 62. }
11. 同一個類中的 2 個方法都加了同步鎖，多個線程能同時訪問同一個類中的這兩個方法嗎？
這個問題需要考慮到Lock與synchronized 兩種實現鎖的不同情形。因為這種情況下使用Lock 和synchronized 會有截然不同的結果。Lock可以讓等待鎖的線程響應中斷，Lock獲取鎖，之后需要釋放鎖。如下代碼，多個線程不可訪問同一個類中的2個加了Lock鎖的方法。
而synchronized卻不行，使用synchronized時，當我們訪問同一個類對象的時候，是同一把鎖，所以可以訪問該對象的其他synchronized方法。
12. 什么情況下導致線程死鎖，遇到線程死鎖該怎么解決?
11.1 死鎖的定義：所謂死鎖是指多個線程因競爭資源而造成的一種僵局（互相等待），若無外力作用，這些進程都將無法向前推進。
11.2 死鎖產生的必要條件：
互斥條件：線程要求對所分配的資源（如打印機）進行排他性控制，即在一段時間內某 資源僅為一個線程所占有。此時若有其他線程請求該資源，則請求線程只能等待。
不剝奪條件：線程所獲得的資源在未使用完畢之前，不能被其他線程強行奪走，即只能由獲得該資源的線程自己來釋放（只能是主動釋放)。
請求和保持條件：線程已經保持了至少一個資源，但又提出了新的資源請求，而該資源已被其他線程占有，此時請求進程被阻塞，但對自己已獲得的資源保持不放。
循環等待條件：存在一種線程資源的循環等待鏈，鏈中每一個線程已獲得的資源同時被鏈中下一個線程所請求。即存在一個處於等待狀態的線程集合{Pl, P2, ..., pn}，其中Pi等待的資源被P(i+1)占有（i=0, 1, ..., n-1)，Pn等待的資源被P0占有
產生死鎖的一個例子
1．package .com; 2．/** 3．* 一個簡單的死鎖類 4．* 當 DeadLock 類的對象 flag==1 時（td1），先鎖定 o1,睡眠 500 毫秒 5．* 而 td1 在睡眠的時候另一個 flag==0 的對象（td2）線程啟動，先鎖定 o2,睡眠 500 毫秒 6．* td1 睡眠結束后需要鎖定 o2 才能繼續執行，而此時 o2 已被 td2 鎖定； 7．* td2 睡眠結束后需要鎖定 o1 才能繼續執行，而此時 o1 已被 td1 鎖定； 8．* td1、td2 相互等待，都需要得到對方鎖定的資源才能繼續執行，從而死鎖。 9．*/ 10．public class DeadLock implements Runnable { 11． public int flag = 1; 12． //靜態對象是類的所有對象共享的 13． private static Object o1 = new Object(), o2 = new Object(); 14． public void run() { 15． System.out.println("flag=" + flag); 16． if (flag == 1) { 17． synchronized (o1) { 18． try { 19． Thread.sleep(500); 20． } catch (Exception e) { 21． e.printStackTrace(); 22． } 23． synchronized (o2) { 24． System.out.println("1"); 25． } 26． } 27． } 28． if (flag == 0) { 29． synchronized (o2) { 30． try { 31． Thread.sleep(500); 32． } catch (Exception e) { 33． e.printStackTrace(); 34． } 35． synchronized (o1) { 36． System.out.println("0"); 37． } 38． } 39． } 40． } 41． public static void main(String[] args) { 42． DeadLock td1 = new DeadLock(); 43． DeadLock td2 = new DeadLock(); 44． td1.flag = 1; 45． td2.flag = 0; 46． //td1,td2 都處於可執行狀態，但 JVM 線程調度先執行哪個線程是不確定的。 47． //td2 的 run()可能在 td1 的 run()之前運行 48． new Thread(td1).start(); 49． new Thread(td2).start(); 50． } 51．}
13. Java 中多線程間的通信怎么實現?
線程通信的方式：
1.共享變量
線程間通信可以通過發送信號，發送信號的一個簡單方式是在共享對象的變量里設置信號值。線程 A 在一個同步塊里設置 boolean 型成員變量 hasDataToProcess 為 true，線程 B 也在同步塊里讀取 hasDataToProcess這個成員變量。這個簡單的例子使用了一個持有信號的對象，並提供了 set 和 get 方法
1．package igeekhome.com; 2．public class MySignal{ 3． //共享的變量 4． private boolean hasDataToProcess=false; 5． //取值 6． public boolean getHasDataToProcess() { 7． return hasDataToProcess; 8． } 9． //存值 10． public void setHasDataToProcess(boolean hasDataToProcess) { 11． this.hasDataToProcess = hasDataToProcess; 12． } 13． public static void main(String[] args){ 14． //同一個對象 15． final MySignal my=new MySignal(); 16． //線程 1 設置 hasDataToProcess 值為 true 17． final Thread t1=new Thread(new Runnable(){ 18． public void run() { 19． my.setHasDataToProcess(true); 20． } 21． }); 22． t1.start(); 23． //線程 2 取這個值 hasDataToProcess 24． Thread t2=new Thread(new Runnable(){ 25． public void run() { 26． try { 27． //等待線程 1 完成然后取值 28． t1.join(); 29． } catch (InterruptedException e) { 30． e.printStackTrace(); 31． } 32． my.getHasDataToProcess(); 33． System.out.println("t1 改變以后的值：" + my.isHasDataToProcess()); 34． } 35． }); 36． t2.start(); 37．} 38．} 結果： t1 改變以后的值：true
2.wait/notify 機制
以資源為例，生產者生產一個資源，通知消費者就消費掉一個資源，生產者繼續生產資源，消費者消費資源，以此循環。代碼如下：
1．package igeekhome.com; 2．//資源類 3． class Resource{ 4． private String name; 5． private int count=1; 6． private boolean flag=false; 7． public synchronized void set(String name){ 8． //生產資源 9． while(flag) { 10． try{ 11． //線程等待。消費者消費資源 12． wait(); 13． }catch(Exception e){} 14． } 15． this.name=name+"---"+count++; 16． System.out.println(Thread.currentThread().getName()+"...生產者..."+this.name); 17． flag=true; 18． //喚醒等待中的消費者 19． this.notifyAll(); 20． } 21． public synchronized void out(){ 22． //消費資源 23． while(!flag) { 24． //線程等待，生產者生產資源 25． try{wait();}catch(Exception e){} 26． } 27． System.out.println(Thread.currentThread().getName()+"...消費者..."+this.name); 28． flag=false; 29． //喚醒生產者，生產資源 30． this.notifyAll(); 31． } 32．} 33． //生產者 34． class Producer implements Runnable{ 35． private Resource res; 36． Producer(Resource res){ 37． this.res=res; 38． } 39． //生產者生產資源 40． public void run(){ 41． while(true){ 42． res.set("商品"); 43． } 44． } 45． } 46． //消費者消費資源 47． class Consumer implements Runnable{ 48． private Resource res; 49． Consumer(Resource res){ 50． this.res=res; 51． } 52． public void run(){ 53． while(true){ 54． res.out(); 55． } 56． } 57． } 58．public class ProducerConsumerDemo{ 59． public static void main(String[] args){ 60． Resource r=new Resource(); 61． Producer pro=new Producer(r); 62． Consumer con=new Consumer(r); 63． Thread t1=new Thread(pro); 64． Thread t2=new Thread(con); 65． t1.start(); 66． t2.start(); 67． } 68．}
14. 線程和進程的區別
進程：具有一定獨立功能的程序關於某個數據集合上的一次運行活動，是操作系統進行資源分配和調度的一個獨立單位。
線程：是進程的一個實體，是cpu調度和分派的基本單位，是比進程更小的可以獨立運行的基本單位。
特點：線程的划分尺度小於進程，這使多線程程序擁有高並發性，進程在運行時各自內存單元相互獨立，線程之間內存共享，這使多線程編程可以擁有更好的性能和用戶體驗
注意：多線程編程對於其它程序是不友好的，占據大量cpu資源。
15. 請說出同步線程及線程調度相關的方法？
wait()：使一個線程處於等待（阻塞）狀態，並且釋放所持有的對象的鎖； sleep()：使一個正在運行的線程處於睡眠狀態，是一個靜態方法，調用此方法要處理InterruptedException異常； notify()：喚醒一個處於等待狀態的線程，當然在調用此方法的時候，並不能確切的喚醒某一個等待狀態的線程， 而是由JVM確定喚醒哪個線程，而且與優先級無關； notityAll()：喚醒所有處於等待狀態的線程，該方法並不是將對象的鎖給所有線程，而是讓它們競爭，只有獲得鎖 的線程才能進入就緒狀態； 注意：java 5 通過Lock接口提供了顯示的鎖機制，Lock接口中定義了加鎖（lock（）方法）和解鎖（unLock（） 方法），增強了多線程編程的靈活性及對線程的協調
16. 啟動一個線程是調用 run()方法還是 start()方法？
啟動一個線程是調用 start()方法，使線程所代表的虛擬處理機處於可運行狀態，這意味着它可以由 JVM 調度並執行，這並不意味着線程就會立即運行。
run()方法是線程啟動后要進行回調（callback）的方法。