前言
多線程併發編程是Java編程中重要的一塊內容,也是面試重點覆蓋區域,所以學好多線程併發編程對我們來說極其重要,下面跟我一起開啓本次的學習之旅吧。
正文
線程與進程
1 線程:進程中負責程序執行的執行單元
線程本身依靠程序進行運行
線程是程序中的順序控制流,只能使用分配給程序的資源和環境
2 進程:執行中的程序
一個進程至少包含一個線程
3 單線程:程序中只存在一個線程,實際上主方法就是一個主線程
4 多線程:在一個程序中運行多個任務
目的是更好地使用CPU資源
線程的實現
繼承Thread類
在java.lang
包中定義, 繼承Thread類必須重寫run()
方法
1
2
3
4
5
6
7
8
9
10
11
12
|
class
MyThread extends
Thread{ private
static
int
num = 0 ; public
MyThread(){ num++; } @Override public
void
run() { System.out.println( "主動創建的第" +num+ "個線程" ); } } |
創建好了自己的線程類之後,就可以創建線程對象了,然後通過start()方法去啓動線程。注意,不是調用run()方法啓動線程,run方法中只是定義需要執行的任務,如果調用run方法,即相當於在主線程中執行run方法,跟普通的方法調用沒有任何區別,此時並不會創建一個新的線程來執行定義的任務。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
public
class
Test { public
static
void
main(String[] args) { MyThread
thread = new
MyThread(); thread.start(); } } class
MyThread extends
Thread{ private
static
int
num = 0 ; public
MyThread(){ num++; } @Override public
void
run() { System.out.println( "主動創建的第" +num+ "個線程" ); } } |
在上面代碼中,通過調用start()方法,就會創建一個新的線程了。爲了分清start()方法調用和run()方法調用的區別,請看下面一個例子:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
public
class
Test { public
static
void
main(String[] args) { System.out.println( "主線程ID:" +Thread.currentThread().getId()); MyThread
thread1 = new
MyThread( "thread1" ); thread1.start(); MyThread
thread2 = new
MyThread( "thread2" ); thread2.run(); } } class
MyThread extends
Thread{ private
String name; public
MyThread(String name){ this .name
= name; } @Override public
void
run() { System.out.println( "name:" +name+ "
子線程ID:" +Thread.currentThread().getId()); } } |
運行結果:
從輸出結果可以得出以下結論:
1)thread1和thread2的線程ID不同,thread2和主線程ID相同,說明通過run方法調用並不會創建新的線程,而是在主線程中直接運行run方法,跟普通的方法調用沒有任何區別;
2)雖然thread1的start方法調用在thread2的run方法前面調用,但是先輸出的是thread2的run方法調用的相關信息,說明新線程創建的過程不會阻塞主線程的後續執行。
實現Runnable接口
在Java中創建線程除了繼承Thread類之外,還可以通過實現Runnable接口來實現類似的功能。實現Runnable接口必須重寫其run方法。
下面是一個例子:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public
class
Test { public
static
void
main(String[] args) { System.out.println( "主線程ID:" +Thread.currentThread().getId()); MyRunnable
runnable = new
MyRunnable(); Thread
thread = new
Thread(runnable); thread.start(); } }
class
MyRunnable implements
Runnable{ public
MyRunnable() { } @Override public
void
run() { System.out.println( "子線程ID:" +Thread.currentThread().getId()); } } |
Runnable的中文意思是“任務”,顧名思義,通過實現Runnable接口,我們定義了一個子任務,然後將子任務交由Thread去執行。注意,這種方式必須將Runnable作爲Thread類的參數,然後通過Thread的start方法來創建一個新線程來執行該子任務。如果調用Runnable的run方法的話,是不會創建新線程的,這根普通的方法調用沒有任何區別。
事實上,查看Thread類的實現源代碼會發現Thread類是實現了Runnable接口的。
在Java中,這2種方式都可以用來創建線程去執行子任務,具體選擇哪一種方式要看自己的需求。直接繼承Thread類的話,可能比實現Runnable接口看起來更加簡潔,但是由於Java只允許單繼承,所以如果自定義類需要繼承其他類,則只能選擇實現Runnable接口。
使用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
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
|
/** *
有返回值的線程 */ @SuppressWarnings ( "unchecked" )
public
class
Test { public
static
void
main(String[] args) throws
ExecutionException, InterruptedException
{ System.out.println( "----程序開始運行----" );
Date
date1 = new
Date(); int
taskSize = 5 ;
//
創建一個線程池 ExecutorService
pool = Executors.newFixedThreadPool(taskSize); //
創建多個有返回值的任務 List<Future>
list = new
ArrayList<Future>(); for
( int
i = 0 ;
i < taskSize; i++) { Callable
c = new
MyCallable(i + "
" );
//
執行任務並獲取Future對象 Future
f = pool.submit(c); //
System.out.println(">>>" + f.get().toString()); list.add(f);
}
//
關閉線程池 pool.shutdown();
//
獲取所有併發任務的運行結果 for
(Future f : list) { //
從Future對象上獲取任務的返回值,並輸出到控制檯 System.out.println( ">>>"
+ f.get().toString()); }
Date
date2 = new
Date(); System.out.println( "----程序結束運行----,程序運行時間【" +
(date2.getTime() - date1.getTime()) + "毫秒】" );
}
}
class
MyCallable implements
Callable<Object> { private
String taskNum; MyCallable(String
taskNum) { this .taskNum
= taskNum; }
public
Object call() throws
Exception { System.out.println( ">>>"
+ taskNum + "任務啓動" );
Date
dateTmp1 = new
Date(); Thread.sleep( 1000 );
Date
dateTmp2 = new
Date(); long
time = dateTmp2.getTime() - dateTmp1.getTime(); System.out.println( ">>>"
+ taskNum + "任務終止" );
return
taskNum + "任務返回運行結果,當前任務時間【"
+ time + "毫秒】" ;
} } |
代碼說明:
上述代碼中Executors類,提供了一系列工廠方法用於創先線程池,返回的線程池都實現了ExecutorService接口。
public static ExecutorService newFixedThreadPool(int nThreads)
創建固定數目線程的線程池。
public static ExecutorService newCachedThreadPool()
創建一個可緩存的線程池,調用execute 將重用以前構造的線程(如果線程可用)。如果現有線程沒有可用的,則創建一個新線程並添加到池中。終止並從緩存中移除那些已有 60 秒鐘未被使用的線程。
public static ExecutorService newSingleThreadExecutor()
創建一個單線程化的Executor。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
創建一個支持定時及週期性的任務執行的線程池,多數情況下可用來替代Timer類。
ExecutoreService提供了submit()方法,傳遞一個Callable,或Runnable,返回Future。如果Executor後臺線程池還沒有完成Callable的計算,這調用返回Future對象的get()方法,會阻塞直到計算完成。
線程的狀態
在正式學習Thread類中的具體方法之前,我們先來了解一下線程有哪些狀態,這個將會有助於後面對Thread類中的方法的理解。
- 創建(new)狀態: 準備好了一個多線程的對象
- 就緒(runnable)狀態: 調用了
start()
方法, 等待CPU進行調度 - 運行(running)狀態: 執行
run()
方法 - 阻塞(blocked)狀態: 暫時停止執行, 可能將資源交給其它線程使用
- 終止(dead)狀態: 線程銷燬
當需要新起一個線程來執行某個子任務時,就創建了一個線程。但是線程創建之後,不會立即進入就緒狀態,因爲線程的運行需要一些條件(比如內存資源,在前面的JVM內存區域劃分一篇博文中知道程序計數器、Java棧、本地方法棧都是線程私有的,所以需要爲線程分配一定的內存空間),只有線程運行需要的所有條件滿足了,才進入就緒狀態。
當線程進入就緒狀態後,不代表立刻就能獲取CPU執行時間,也許此時CPU正在執行其他的事情,因此它要等待。當得到CPU執行時間之後,線程便真正進入運行狀態。
線程在運行狀態過程中,可能有多個原因導致當前線程不繼續運行下去,比如用戶主動讓線程睡眠(睡眠一定的時間之後再重新執行)、用戶主動讓線程等待,或者被同步塊給阻塞,此時就對應着多個狀態:time waiting(睡眠或等待一定的事件)、waiting(等待被喚醒)、blocked(阻塞)。
當由於突然中斷或者子任務執行完畢,線程就會被消亡。
下面這副圖描述了線程從創建到消亡之間的狀態:
在有些教程上將blocked、waiting、time waiting統稱爲阻塞狀態,這個也是可以的,只不過這裏我想將線程的狀態和Java中的方法調用聯繫起來,所以將waiting和time waiting兩個狀態分離出來。
注:sleep和wait的區別:
sleep
是Thread
類的方法,wait
是Object
類中定義的方法.Thread.sleep
不會導致鎖行爲的改變, 如果當前線程是擁有鎖的, 那麼Thread.sleep
不會讓線程釋放鎖.Thread.sleep
和Object.wait
都會暫停當前的線程. OS會將執行時間分配給其它線程. 區別是, 調用wait
後, 需要別的線程執行notify/notifyAll
才能夠重新獲得CPU執行時間.
上下文切換
對於單核CPU來說(對於多核CPU,此處就理解爲一個核),CPU在一個時刻只能運行一個線程,當在運行一個線程的過程中轉去運行另外一個線程,這個叫做線程上下文切換(對於進程也是類似)。
由於可能當前線程的任務並沒有執行完畢,所以在切換時需要保存線程的運行狀態,以便下次重新切換回來時能夠繼續切換之前的狀態運行。舉個簡單的例子:比如一個線程A正在讀取一個文件的內容,正讀到文件的一半,此時需要暫停線程A,轉去執行線程B,當再次切換回來執行線程A的時候,我們不希望線程A又從文件的開頭來讀取。
因此需要記錄線程A的運行狀態,那麼會記錄哪些數據呢?因爲下次恢復時需要知道在這之前當前線程已經執行到哪條指令了,所以需要記錄程序計數器的值,另外比如說線程正在進行某個計算的時候被掛起了,那麼下次繼續執行的時候需要知道之前掛起時變量的值時多少,因此需要記錄CPU寄存器的狀態。所以一般來說,線程上下文切換過程中會記錄程序計數器、CPU寄存器狀態等數據。
說簡單點的:對於線程的上下文切換實際上就是 存儲和恢復CPU狀態的過程,它使得線程執行能夠從中斷點恢復執行。
雖然多線程可以使得任務執行的效率得到提升,但是由於在線程切換時同樣會帶來一定的開銷代價,並且多個線程會導致系統資源佔用的增加,所以在進行多線程編程時要注意這些因素。
線程的常用方法
編號 | 方法 | 說明 |
---|---|---|
1 |
public void start() |
使該線程開始執行;Java 虛擬機調用該線程的 run 方法。 |
2 |
public void run() |
如果該線程是使用獨立的 Runnable 運行對象構造的,則調用該 Runnable 對象的 run 方法;否則,該方法不執行任何操作並返回。 |
3 |
public final void setName(String name) |
改變線程名稱,使之與參數 name 相同。 |
4 |
public final void setPriority(int priority) |
更改線程的優先級。 |
5 |
public final void setDaemon(boolean on) |
將該線程標記爲守護線程或用戶線程。 |
6 |
public final void join(long millisec) |
等待該線程終止的時間最長爲 millis 毫秒。 |
7 |
public void interrupt() |
中斷線程。 |
8 |
public final boolean isAlive() |
測試線程是否處於活動狀態。 |
9 |
public static void yield() |
暫停當前正在執行的線程對象,並執行其他線程。 |
10 |
public static void sleep(long millisec) |
在指定的毫秒數內讓當前正在執行的線程休眠(暫停執行),此操作受到系統計時器和調度程序精度和準確性的影響。 |
11 |
public static Thread currentThread() |
返回對當前正在執行的線程對象的引用。 |
靜態方法
currentThread()方法
currentThread()方法可以返回代碼段正在被哪個線程調用的信息。
1
2
3
4
5
|
public
class
Run1{ public
static
void
main(String[] args){ System.out.println(Thread.currentThread().getName()); } } |
sleep()方法
方法sleep()的作用是在指定的毫秒數內讓當前“正在執行的線程”休眠(暫停執行)。這個“正在執行的線程”是指this.currentThread()返回的線程。
sleep方法有兩個重載版本:
1
2
|
sleep( long
millis) //參數爲毫秒 sleep( long
millis, int
nanoseconds) //第一參數爲毫秒,第二個參數爲納秒 |
sleep相當於讓線程睡眠,交出CPU,讓CPU去執行其他的任務。
但是有一點要非常注意,sleep方法不會釋放鎖,也就是說如果當前線程持有對某個對象的鎖,則即使調用sleep方法,其他線程也無法訪問這個對象。看下面這個例子就清楚了:
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
32
|
public
class
Test { private
int
i = 10 ; private
Object object = new
Object(); public
static
void
main(String[] args) throws
IOException { Test
test = new
Test(); MyThread
thread1 = test. new
MyThread(); MyThread
thread2 = test. new
MyThread(); thread1.start(); thread2.start(); }
class
MyThread extends
Thread{ @Override public
void
run() { synchronized
(object) { i++; System.out.println( "i:" +i); try
{ System.out.println( "線程" +Thread.currentThread().getName()+ "進入睡眠狀態" ); Thread.currentThread().sleep( 10000 ); }
catch
(InterruptedException e) { //
TODO: handle exception } System.out.println( "線程" +Thread.currentThread().getName()+ "睡眠結束" ); i++; System.out.println( "i:" +i); } } } } |
輸出結果:
從上面輸出結果可以看出,當Thread-0進入睡眠狀態之後,Thread-1並沒有去執行具體的任務。只有當Thread-0執行完之後,此時Thread-0釋放了對象鎖,Thread-1纔開始執行。
注意,如果調用了sleep方法,必須捕獲InterruptedException異常或者將該異常向上層拋出。當線程睡眠時間滿後,不一定會立即得到執行,因爲此時可能CPU正在執行其他的任務。所以說調用sleep方法相當於讓線程進入阻塞狀態。
yield()方法
調用yield方法會讓當前線程交出CPU權限,讓CPU去執行其他的線程。它跟sleep方法類似,同樣不會釋放鎖。但是yield不能控制具體的交出CPU的時間,另外,yield方法只能讓擁有相同優先級的線程有獲取CPU執行時間的機會。
注意,調用yield方法並不會讓線程進入阻塞狀態,而是讓線程重回就緒狀態,它只需要等待重新獲取CPU執行時間,這一點是和sleep方法不一樣的。
代碼:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
public
class
MyThread extends
Thread{ @Override public
void
run() { long
beginTime=System.currentTimeMillis(); int
count= 0 ; for
( int
i= 0 ;i< 50000000 ;i++){ count=count+(i+ 1 ); //Thread.yield(); } long
endTime=System.currentTimeMillis(); System.out.println( "用時:" +(endTime-beginTime)+ "
毫秒!" ); } } public
class
Run { public
static
void
main(String[] args) { MyThread
t= new
MyThread(); t.start(); } } |
執行結果:
1
|
用時: 3
毫秒! |
如果將 //Thread.yield();
的註釋去掉,執行結果如下:
1
|
用時: 16080
毫秒! |
對象方法
start()方法
start()用來啓動一個線程,當調用start方法後,系統纔會開啓一個新的線程來執行用戶定義的子任務,在這個過程中,會爲相應的線程分配需要的資源。
run()方法
run()方法是不需要用戶來調用的,當通過start方法啓動一個線程之後,當線程獲得了CPU執行時間,便進入run方法體去執行具體的任務。注意,繼承Thread類必須重寫run方法,在run方法中定義具體要執行的任務。
getId()
getId()的作用是取得線程的唯一標識
代碼:
1
2
3
4
5
6
|
public
class
Test { public
static
void
main(String[] args) { Thread
t= Thread.currentThread(); System.out.println(t.getName()+ "
" +t.getId()); } } |
輸出:
1
|
main
1 |
isAlive()方法
方法isAlive()的功能是判斷當前線程是否處於活動狀態
代碼:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
public
class
MyThread extends
Thread{ @Override public
void
run() { System.out.println( "run=" + this .isAlive()); } } public
class
RunTest { public
static
void
main(String[] args) throws
InterruptedException { MyThread
myThread= new
MyThread(); System.out.println( "begin
==" +myThread.isAlive()); myThread.start(); System.out.println( "end
==" +myThread.isAlive()); } } |
程序運行結果:
1
2
3
|
begin
== false run= true end
== false |
方法isAlive()的作用是測試線程是否偶處於活動狀態。什麼是活動狀態呢?活動狀態就是線程已經啓動且尚未終止。線程處於正在運行或準備開始運行的狀態,就認爲線程是“存活”的。
有個需要注意的地方
1
|
System.out.println( "end
==" +myThread.isAlive()); |
雖然上面的實例中打印的值是true,但此值是不確定的。打印true值是因爲myThread線程還未執行完畢,所以輸出true。如果代碼改成下面這樣,加了個sleep休眠:
1
2
3
4
5
6
7
|
public
static
void
main(String[] args) throws
InterruptedException { MyThread
myThread= new
MyThread(); System.out.println( "begin
==" +myThread.isAlive()); myThread.start(); Thread.sleep( 1000 ); System.out.println( "end
==" +myThread.isAlive()); } |
則上述代碼運行的結果輸出爲false,因爲mythread對象已經在1秒之內執行完畢。
join()方法
在很多情況下,主線程創建並啓動了線程,如果子線程中藥進行大量耗時運算,主線程往往將早於子線程結束之前結束。這時,如果主線程想等待子線程執行完成之後再結束,比如子線程處理一個數據,主線程要取得這個數據中的值,就要用到join()方法了。方法join()的作用是等待線程對象銷燬。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
public
class
Thread4 extends
Thread{ public
Thread4(String name) { super (name); } public
void
run() { for
( int
i = 0 ;
i < 5 ;
i++) { System.out.println(getName()
+ "
"
+ i); } } public
static
void
main(String[] args) throws
InterruptedException { //
啓動子進程 new
Thread4( "new
thread" ).start(); for
( int
i = 0 ;
i < 10 ;
i++) { if
(i == 5 )
{ Thread4
th = new
Thread4( "joined
thread" ); th.start(); th.join(); } System.out.println(Thread.currentThread().getName()
+ "
"
+ i); } } } |
執行結果:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
main
0 main
1 main
2 main
3 main
4 new
thread 0 new
thread 1 new
thread 2 new
thread 3 new
thread 4 joined
thread 0 joined
thread 1 joined
thread 2 joined
thread 3 joined
thread 4 main
5 main
6 main
7 main
8 main
9 |
由上可以看出main主線程等待joined thread線程先執行完了才結束的。如果把th.join()這行註釋掉,運行結果如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
main
0 main
1 main
2 main
3 main
4 main
5 main
6 main
7 main
8 main
9 new
thread 0 new
thread 1 new
thread 2 new
thread 3 new
thread 4 joined
thread 0 joined
thread 1 joined
thread 2 joined
thread 3 joined
thread 4 |
getName和setName
用來得到或者設置線程名稱。
getPriority和setPriority
用來獲取和設置線程優先級。
setDaemon和isDaemon
用來設置線程是否成爲守護線程和判斷線程是否是守護線程。
守護線程和用戶線程的區別在於:守護線程依賴於創建它的線程,而用戶線程則不依賴。舉個簡單的例子:如果在main線程中創建了一個守護線程,當main方法運行完畢之後,守護線程也會隨着消亡。而用戶線程則不會,用戶線程會一直運行直到其運行完畢。在JVM中,像垃圾收集器線程就是守護線程。
在上面已經說到了Thread類中的大部分方法,那麼Thread類中的方法調用到底會引起線程狀態發生怎樣的變化呢?下面一幅圖就是在上面的圖上進行改進而來的:
停止線程
停止線程是在多線程開發時很重要的技術點,掌握此技術可以對線程的停止進行有效的處理。
停止一個線程可以使用Thread.stop()方法,但最好不用它。該方法是不安全的,已被棄用。
在Java中有以下3種方法可以終止正在運行的線程:
- 使用退出標誌,使線程正常退出,也就是當run方法完成後線程終止
- 使用stop方法強行終止線程,但是不推薦使用這個方法,因爲stop和suspend及resume一樣,都是作廢過期的方法,使用他們可能產生不可預料的結果。
- 使用interrupt方法中斷線程,但這個不會終止一個正在運行的線程,還需要加入一個判斷纔可以完成線程的停止。
暫停線程
interrupt()方法
線程的優先級
在操作系統中,線程可以劃分優先級,優先級較高的線程得到的CPU資源較多,也就是CPU優先執行優先級較高的線程對象中的任務。
設置線程優先級有助於幫“線程規劃器”確定在下一次選擇哪一個線程來優先執行。
設置線程的優先級使用setPriority()方法,此方法在JDK的源碼如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public
final
void
setPriority( int
newPriority) { ThreadGroup
g; checkAccess(); if
(newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) { throw
new
IllegalArgumentException(); } if ((g
= getThreadGroup()) != null )
{ if
(newPriority > g.getMaxPriority()) { newPriority
= g.getMaxPriority(); } setPriority0(priority
= newPriority); } } |
在Java中,線程的優先級分爲1~10這10個等級,如果小於1或大於10,則JDK拋出異常throw new IllegalArgumentException()。
JDK中使用3個常量來預置定義優先級的值,代碼如下:
1
2
3
|
public
final
static
int
MIN_PRIORITY = 1 ; public
final
static
int
NORM_PRIORITY = 5 ; public
final
static
int
MAX_PRIORITY = 10 ; |
線程優先級特性:
- 繼承性
比如A線程啓動B線程,則B線程的優先級與A是一樣的。 - 規則性
高優先級的線程總是大部分先執行完,但不代表高優先級線程全部先執行完。 - 隨機性
優先級較高的線程不一定每一次都先執行完。
守護線程
在Java線程中有兩種線程,一種是User Thread(用戶線程),另一種是Daemon Thread(守護線程)。
Daemon的作用是爲其他線程的運行提供服務,比如說GC線程。其實User Thread線程和Daemon Thread守護線程本質上來說去沒啥區別的,唯一的區別之處就在虛擬機的離開:如果User Thread全部撤離,那麼Daemon Thread也就沒啥線程好服務的了,所以虛擬機也就退出了。
守護線程並非虛擬機內部可以提供,用戶也可以自行的設定守護線程,方法:public final void setDaemon(boolean on) ;但是有幾點需要注意:
- thread.setDaemon(true)必須在thread.start()之前設置,否則會跑出一個IllegalThreadStateException異常。你不能把正在運行的常規線程設置爲守護線程。 (備註:這點與守護進程有着明顯的區別,守護進程是創建後,讓進程擺脫原會話的控制+讓進程擺脫原進程組的控制+讓進程擺脫原控制終端的控制;所以說寄託於虛擬機的語言機制跟系統級語言有着本質上面的區別)
- 在Daemon線程中產生的新線程也是Daemon的。 (這一點又是有着本質的區別了:守護進程fork()出來的子進程不再是守護進程,儘管它把父進程的進程相關信息複製過去了,但是子進程的進程的父進程不是init進程,所謂的守護進程本質上說就是“父進程掛掉,init收養,然後文件0,1,2都是/dev/null,當前目錄到/”)
- 不是所有的應用都可以分配給Daemon線程來進行服務,比如讀寫操作或者計算邏輯。因爲在Daemon Thread還沒來的及進行操作時,虛擬機可能已經退出了。
同步與死鎖
- 同步代碼塊
在代碼塊上加上”synchronized”關鍵字,則此代碼塊就稱爲同步代碼塊 - 同步代碼塊格式
123
synchronized
(同步對象){
需要同步的代碼塊;
}
- 同步方法
除了代碼塊可以同步,方法也是可以同步的 - 方法同步格式
1
synchronized
void
方法名稱(){}
synchronized後續會單獨來學習。(●’◡’●)
面試題
線程和進程有什麼區別?
答:一個進程是一個獨立(self contained)的運行環境,它可以被看作一個程序或者一個應用。而線程是在進程中執行的一個任務。線程是進程的子集,一個進程可以有很多線程,每條線程並行執行不同的任務。不同的進程使用不同的內存空間,而所有的線程共享一片相同的內存空間。別把它和棧內存搞混,每個線程都擁有單獨的棧內存用來存儲本地數據。
如何在Java中實現線程?
答:
創建線程有兩種方式:
一、繼承 Thread 類,擴展線程。
二、實現 Runnable 接口。
啓動一個線程是調用run()還是start()方法?
答:啓動一個線程是調用start()方法,使線程所代表的虛擬處理機處於可運行狀態,這意味着它可以由JVM 調度並執行,這並不意味着線程就會立即運行。run()方法是線程啓動後要進行回調(callback)的方法。
Thread類的sleep()方法和對象的wait()方法都可以讓線程暫停執行,它們有什麼區別?
答:sleep()方法(休眠)是線程類(Thread)的靜態方法,調用此方法會讓當前線程暫停執行指定的時間,將執行機會(CPU)讓給其他線程,但是對象的鎖依然保持,因此休眠時間結束後會自動恢復(線程回到就緒狀態,請參考第66題中的線程狀態轉換圖)。wait()是Object類的方法,調用對象的wait()方法導致當前線程放棄對象的鎖(線程暫停執行),進入對象的等待池(wait pool),只有調用對象的notify()方法(或notifyAll()方法)時才能喚醒等待池中的線程進入等鎖池(lock pool),如果線程重新獲得對象的鎖就可以進入就緒狀態。
線程的sleep()方法和yield()方法有什麼區別?
答:
① sleep()方法給其他線程運行機會時不考慮線程的優先級,因此會給低優先級的線程以運行的機會;yield()方法只會給相同優先級或更高優先級的線程以運行的機會;
② 線程執行sleep()方法後轉入阻塞(blocked)狀態,而執行yield()方法後轉入就緒(ready)狀態;
③ sleep()方法聲明拋出InterruptedException,而yield()方法沒有聲明任何異常;
④ sleep()方法比yield()方法(跟操作系統CPU調度相關)具有更好的可移植性。
請說出與線程同步以及線程調度相關的方法。
答:
- wait():使一個線程處於等待(阻塞)狀態,並且釋放所持有的對象的鎖;
- sleep():使一個正在運行的線程處於睡眠狀態,是一個靜態方法,調用此方法要處理InterruptedException異常;
- notify():喚醒一個處於等待狀態的線程,當然在調用此方法的時候,並不能確切的喚醒某一個等待狀態的線程,而是由JVM確定喚醒哪個線程,而且與優先級無關;
- notityAll():喚醒所有處於等待狀態的線程,該方法並不是將對象的鎖給所有線程,而是讓它們競爭,只有獲得鎖的線程才能進入就緒狀態;
總結
以上就是多線程的一些基礎概念,可能總結的不夠仔細,多多包涵。後續會針對一些比較重要的知識點單獨列出來總結。學好多線程是拿高薪的基礎,小夥伴一起加油吧!