很多核心Java面試題來源於多線程(Multi-Threading)和集合框架(Collections Framework)，理解核心線程概念時，嫻熟的實際經驗是必需的。這篇文章收集了Java線程方面一些典型的問題，這些問題經常被高級工程師所問到。
0、Java中多線程同步是什么？
在多線程程序下，同步能控制對共享資源的訪問。如果沒有同步，當一個Java線程在修改一個共享變量時，另外一個線程正在使用或者更新同一個變量，這樣容易導致程序出現錯誤的結果。
1、解釋實現多線程的幾種方法?
一Java線程可以實現Runnable接口或者繼承Thread類來實現，當你打算多重繼承時，優先選擇實現Runnable。
2、Thread.start()與Thread.run()有什么區別？
Thread.start()方法(native)啟動線程，使之進入就緒狀態，當cpu分配時間該線程時，由JVM調度執行run()方法。
3、為什么需要run()和start()方法，我們可以只用run()方法來完成任務嗎？
我們需要run()&start()這兩個方法是因為JVM創建一個單獨的線程不同於普通方法的調用， 所以這項工作由線程的start方法來完成，start由本地方法實現，需要顯示地被調用，使用這倆個方法的另外一個好處是任何一個對象都可以作為線程運 行，只要實現了Runnable接口，這就避免因繼承了Thread類而造成的Java的多繼承問題。
4、什么是ThreadLocal類，怎么使用它？
ThreadLocal是一個線程級別的局部變量，並非“本地線程”。ThreadLocal為每個使用該變量的線程提供了一個獨立的變量副本，每個線程修改副本時不影響其它線程對象的副本(譯者注)。
下面是線程局部變量(ThreadLocal variables)的關鍵點：
一個線程局部變量(ThreadLocal variables)為每個線程方便地提供了一個單獨的變量。
ThreadLocal實例通常作為靜態的私有的(private static)字段出現在一個類中，這個類用來關聯一個線程。
當多個線程訪問ThreadLocal實例時，每個線程維護ThreadLocal提供的獨立的變量副本。
常用的使用可在DAO模式中見到，當DAO類作為一個單例類時，數據庫鏈接(connection)被每一個線程獨立的維護，互不影響。(基於線程的單例)
ThreadLocal難於理解，下面這些引用連接有助於你更好的理解它。
《Good article on ThreadLocal on IBM DeveloperWorks 》、《理解ThreadLocal》、《Managing data : Good example》、《Refer Java API Docs》
5、什么時候拋出InvalidMonitorStateException異常，為什么？
調用wait()/notify()/notifyAll()中的任何一個方法時，如果當前線程沒有獲得該對象 的鎖，那么就會拋出IllegalMonitorStateException的異常(也就是說程序在沒有執行對象的任何同步塊或者同步方法時，仍然嘗試 調用wait()/notify()/notifyAll()時)。由於該異常是RuntimeExcpetion的子類，所以該異常不一定要捕獲(盡管 你可以捕獲只要你願意).作為RuntimeException，此類異常不會在wait(),notify(),notifyAll()的方法簽名提 及。
6、Sleep()、suspend()和wait()之間有什么區別？
Thread.sleep()使當前線程在指定的時間處於“非運行”（Not Runnable）狀態。線程一直持有對象的監視器。比如一個線程當前在一個同步塊或同步方法中，其它線程不能進入該塊或方法中。如果另一線程調用了 interrupt()方法，它將喚醒那個“睡眠的”線程。
注意：sleep()是一個靜態方法。這意味着只對當前線程有效，一個常見的錯誤是調用t.sleep()，（這里的t是一個不同於當前線程的線 程）。即便是執行t.sleep()，也是當前線程進入睡眠，而不是t線程。t.suspend()是過時的方法，使用suspend()導致線程進入停 滯狀態，該線程會一直持有對象的監視器，suspend()容易引起死鎖問題。
object.wait()使當前線程出於“不可運行”狀態，和sleep()不同的是wait是object的方法而不是thread。調用 object.wait()時，線程先要獲取這個對象的對象鎖，當前線程必須在鎖對象保持同步，把當前線程添加到等待隊列中，隨后另一線程可以同步同一個 對象鎖來調用object.notify()，這樣將喚醒原來等待中的線程，然后釋放該鎖。基本上wait()/notify()與sleep() /interrupt()類似，只是前者需要獲取對象鎖。
7、在靜態方法上使用同步時會發生什么事？
同步靜態方法時會獲取該類的“Class”對象，所以當一個線程進入同步的靜態方法中時，線程監視器獲取類本身的對象鎖，其它線程不能進入這個類的任何靜態同步方法。它不像實例方法，因為多個線程可以同時訪問不同實例同步實例方法。
8、當一個同步方法已經執行，線程能夠調用對象上的非同步實例方法嗎？
可以，一個非同步方法總是可以被調用而不會有任何問題。實際上，Java沒有為非同步方法做任何檢查，鎖對象僅 僅在同步方法或者同步代碼塊中檢查。如果一個方法沒有聲明為同步，即使你在使用共享數據Java照樣會調用，而不會做檢查是否安全，所以在這種情況下要特 別小心。一個方法是否聲明為同步取決於臨界區訪問(critial section access),如果方法不訪問臨界區(共享資源或者數據結構)就沒必要聲明為同步的。
下面有一個示例說明：Common類有兩個方法synchronizedMethod1()和method1()，MyThread類在獨立的線程中調用這兩個方法。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
public class Common {
public synchronized void synchronizedMethod1() {
System.out.println("synchronizedMethod1 called");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("synchronizedMethod1 done");
}
public void method1() {
System.out.println("Method 1 called");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Method 1 done");
}
}
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
public class MyThread extends Thread {
private int id = 0;
private Common common;
public MyThread(String name, int no, Common object) {
super(name);
common = object;
id = no;
}
public void run() {
System.out.println("Running Thread" + this.getName());
try {
if (id == 0) {
common.synchronizedMethod1();
} else {
common.method1();
}
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
Common c = new Common();
MyThread t1 = new MyThread("MyThread-1", 0, c);
MyThread t2 = new MyThread("MyThread-2", 1, c);
t1.start();
t2.start();
}
}
|
|
1
|
|
這里是程序的輸出：
|
1
2
3
4
5
6
|
Running ThreadMyThread-1
synchronizedMethod1 called
Running ThreadMyThread-2
Method 1 called
synchronizedMethod1 done
Method 1 done
|
結果表明即使synchronizedMethod1()方法執行了，method1()也會被調用。
9、 在一個對象上兩個線程可以調用兩個不同的同步實例方法嗎？
不能，因為一個對象已經同步了實例方法，線程獲取了對象的對象鎖。所以只有執行完該方法釋放對象鎖后才能執行其 它同步方法。看下面代碼示例非常清晰：Common 類 有synchronizedMethod1()和synchronizedMethod2()方法，MyThread調用這兩個方法。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
public class Common {
public synchronized void synchronizedMethod1() {
System.out.println("synchronizedMethod1 called");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("synchronizedMethod1 done");
}
public synchronized void synchronizedMethod2() {
System.out.println("synchronizedMethod2 called");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("synchronizedMethod2 done");
}
}
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
public class MyThread extends Thread {
private int id = 0;
private Common common;
public MyThread(String name, int no, Common object) {
super(name);
common = object;
id = no;
}
public void run() {
System.out.println("Running Thread" + this.getName());
try {
if (id == 0) {
common.synchronizedMethod1();
} else {
common.synchronizedMethod2();
}
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
Common c = new Common();
MyThread t1 = new MyThread("MyThread-1", 0, c);
MyThread t2 = new MyThread("MyThread-2", 1, c);
t1.start();
t2.start();
}
}
|
10、 什么是死鎖
死鎖就是兩個或兩個以上的線程被無限的阻塞，線程之間相互等待所需資源。這種情況可能發生在當兩個線程嘗試獲取其它資源的鎖，而每個線程又陷入無限等待其它資源鎖的釋放，除非一個用戶進程被終止。就JavaAPI而言，線程死鎖可能發生在一下情況。
●當兩個線程相互調用Thread.join()
●當兩個線程使用嵌套的同步塊，一個線程占用了另外一個線程必需的鎖，互相等待時被阻塞就有可能出現死鎖。
11、什么是線程餓死，什么是活鎖？
線程餓死和活鎖雖然不想是死鎖一樣的常見問題，但是對於並發編程的設計者來說就像一次邂逅一樣。
當所有線程阻塞，或者由於需要的資源無效而不能處理，不存在非阻塞線程使資源可用。JavaAPI中線程活鎖可能發生在以下情形：
●當所有線程在程序中執行Object.wait(0)，參數為0的wait方法。程序將發生活鎖直到在相應的對象上有線程調用Object.notify()或者Object.notifyAll()。
●當所有線程卡在無限循環中。
轉載自 ：http://blog.jobbole.com/18571/