java進程間通信

㈠ java多線程程序設計詳細解析

一、理解多線程
多線程是這樣一種機制，它允許在程序中並發執行多個指令流，每個指令流都稱為一個線程，彼此間互相獨立。
線程又稱為輕量級進程，它和進程一樣擁有獨立的執行控制，由操作系統負責調度，區別在於線程沒有獨立的存儲空間，而是和所屬進程中的其它線程共享一個存儲空間，這使得線程間的通信遠較進程簡單。
多個線程的執行是並發的，也就是在邏輯上「同時」，而不管是否是物理上的「同時」。如果系統只有一個CPU，那麼真正的「同時」是不可能的，但是由於CPU的速度非常快，用戶感覺不到其中的區別，因此我們也不用關心它，只需要設想各個線程是同時執行即可。
多線程和傳統的單線程在程序設計上最大的區別在於，由於各個線程的控制流彼此獨立，使得各個線程之間的代碼是亂序執行的，由此帶來的線程調度，同步等問題，將在以後探討。
二、在Java中實現多線凱液慎程
我們不妨設想，為了創建一個新的線程，我們需要做些什麼？很顯然，我們必須指明這個線程所要執行的代碼，而這就是在Java中實現多線程我們所需要做的一切！
真是神奇！Java是如何做到這一點的？通過類！作為一個完全面向對象的語言，Java提供了類java.lang.Thread來方便多線程編程，這個類提供了大量的方法來方便我們控制自己的各個線程，我們以後的討論都將圍繞這個類進行。
那麼如何提供給 Java 我們要線程執行的代碼呢？讓我們來看一看 Thread 類。Thread 類最重要的方法是run()，它為Thread類的方法start()所調用，提供我們的線程所要執行的代碼。為了指定我們自己的代碼，只需要覆蓋它！
方法一：繼承 Thread 類，覆蓋方法 run()，我們在創建的 Thread 類的子類中重寫 run() ,加入線程所要執行的代碼即可。下面是一個例子：
public class MyThread extends Thread
{
int count= 1, number;
public MyThread(int num)
{
number = num;
System.out.println
("創建線程 " + number);
}
public void run() {
while(true) {
System.out.println
("線程 " + number + ":計數 " + count);
if(++count== 6) return;
}
}
public static void main(String args[])
{
for(int i = 0;
i 〈 5; i++) new MyThread(i+1).start();
}
}
這種方法簡單明了，符合大家的習慣，但是，它也有一個很大的缺點，那就是如果我們的類已經從一個類繼承（如小程序必須繼承自 Applet 類），則無法再繼承 Thread 類，這時如果我們又不想建立一個新的類，應該怎麼辦呢？
我們不妨來探索一種新的方法：我們不創建Thread類的子類，而是直接使用它，那麼我們只能將我們的方法作為參數傳遞給 Thread 類的實例，有點類似回調函數。但是 Java 沒有指針，我們只能傳遞一個包含這個方法的類的實例。
那麼如何限制這個類盯敬必須包含這一方法呢？當然是使用介面！（雖然抽象類也可滿足，但是需要繼承，而我們之所以要採用這種新方法，不就是為了避免繼承帶來的限制嗎？）
Java 提供了介面 java.lang.Runnable 來支持這種方法。
方法二：實現 Runnable 介面
Runnable介面只有一個方法run()，我們聲明自己的類實現Runnable介面並提供這一方法，將我們的線程代碼寫入其中，就完成了這一部分的任務。但是Runnable介面並沒有任何對線程的支持，我們還必須創建Thread類的實例，這一點通過Thread類的構造函數public Thread(Runnable target);來實現。下面埋禪是一個例子：
public class MyThread implements Runnable
{
int count= 1, number;
public MyThread(int num)
{
number = num;
System.out.println("創建線程 " + number);
}
public void run()
{
while(true)
{
System.out.println
("線程 " + number + ":計數 " + count);
if(++count== 6) return;
}
}
public static void main(String args[])
{
for(int i = 0; i 〈 5;
i++) new Thread(new MyThread(i+1)).start();
}
}
嚴格地說，創建Thread子類的實例也是可行的，但是必須注意的是，該子類必須沒有覆蓋 Thread 類的 run 方法，否則該線程執行的將是子類的 run 方法，而不是我們用以實現Runnable 介面的類的 run 方法，對此大家不妨試驗一下。
使用 Runnable 介面來實現多線程使得我們能夠在一個類中包容所有的代碼，有利於封裝，它的缺點在於，我們只能使用一套代碼，若想創建多個線程並使各個線程執行不同的代碼，則仍必須額外創建類，如果這樣的話，在大多數情況下也許還不如直接用多個類分別繼承 Thread 來得緊湊。
綜上所述，兩種方法各有千秋，大家可以靈活運用。
下面讓我們一起來研究一下多線程使用中的一些問題。
三、線程的四種狀態
1. 新狀態：線程已被創建但尚未執行（start() 尚未被調用）。
2. 可執行狀態：線程可以執行，雖然不一定正在執行。CPU 時間隨時可能被分配給該線程，從而使得它執行。
3. 死亡狀態：正常情況下 run() 返回使得線程死亡。調用 stop()或 destroy() 亦有同樣效果，但是不被推薦，前者會產生異常，後者是強制終止，不會釋放鎖。
4. 阻塞狀態：線程不會被分配 CPU 時間，無法執行。
四、線程的優先順序
線程的優先順序代表該線程的重要程度，當有多個線程同時處於可執行狀態並等待獲得 CPU 時間時，線程調度系統根據各個線程的優先順序來決定給誰分配 CPU 時間，優先順序高的線程有更大的機會獲得 CPU 時間，優先順序低的線程也不是沒有機會，只是機會要小一些罷了。
你可以調用 Thread 類的方法 getPriority() 和 setPriority()來存取線程的優先順序，線程的優先順序界於1(MIN_PRIORITY)和10(MAX_PRIORITY)之間，預設是5(NORM_PRIORITY)。
五、線程的同步
由於同一進程的多個線程共享同一片存儲空間，在帶來方便的同時，也帶來了訪問沖突這個嚴重的問題。Java語言提供了專門機制以解決這種沖突，有效避免了同一個數據對象被多個線程同時訪問。
由於我們可以通過 private 關鍵字來保證數據對象只能被方法訪問，所以我們只需針對方法提出一套機制，這套機制就是 synchronized 關鍵字，它包括兩種用法：synchronized 方法和 synchronized 塊。
1. synchronized 方法：通過在方法聲明中加入 synchronized關鍵字來聲明 synchronized 方法。如：
public synchronized void accessVal(int newVal);
synchronized 方法控制對類成員變數的訪問：每個類實例對應一把鎖，每個 synchronized 方法都必須獲得調用該方法的類實例的鎖方能執行，否則所屬線程阻塞，方法一旦執行，就獨占該鎖，直到從該方法返回時才將鎖釋放，此後被阻塞的線程方能獲得該鎖，重新進入可執行狀態。
這種機制確保了同一時刻對於每一個類實例，其所有聲明為 synchronized 的成員函數中至多隻有一個處於可執行狀態（因為至多隻有一個能夠獲得該類實例對應的鎖），從而有效避免了類成員變數的訪問沖突（只要所有可能訪問類成員變數的方法均被聲明為 synchronized）。
在 Java 中，不光是類實例，每一個類也對應一把鎖，這樣我們也可將類的靜態成員函數聲明為 synchronized ，以控制其對類的靜態成員變數的訪問。
synchronized 方法的缺陷：若將一個大的方法聲明為synchronized 將會大大影響效率，典型地，若將線程類的方法 run() 聲明為 synchronized ，由於在線程的整個生命期內它一直在運行，因此將導致它對本類任何 synchronized 方法的調用都永遠不會成功。當然我們可以通過將訪問類成員變數的代碼放到專門的方法中，將其聲明為 synchronized ，並在主方法中調用來解決這一問題，但是 Java 為我們提供了更好的解決辦法，那就是 synchronized 塊。
2. synchronized 塊：通過 synchronized關鍵字來聲明synchronized 塊。語法如下：
synchronized(syncObject)
{
//允許訪問控制的代碼
}
#p#副標題#e#
synchronized 塊是這樣一個代碼塊，其中的代碼必須獲得對象 syncObject （如前所述，可以是類實例或類）的鎖方能執行，具體機制同前所述。由於可以針對任意代碼塊，且可任意指定上鎖的對象，故靈活性較高。
六、線程的阻塞為了解決對共享存儲區的訪問沖突，Java 引入了同步機制，現在讓我們來考察多個線程對共享資源的訪問，顯然同步機制已經不夠了，因為在任意時刻所要求的資源不一定已經准備好了被訪問，反過來，同一時刻准備好了的資源也可能不止一個。為了解決這種情況下的訪問控制問題，Java 引入了對阻塞機制的支持。
阻塞指的是暫停一個線程的執行以等待某個條件發生（如某資源就緒），學過操作系統的同學對它一定已經很熟悉了。Java 提供了大量方法來支持阻塞，下面讓我們逐一分析。
1. sleep() 方法：sleep() 允許 指定以毫秒為單位的一段時間作為參數，它使得線程在指定的時間內進入阻塞狀態，不能得到CPU 時間，指定的時間一過，線程重新進入可執行狀態。典型地，sleep() 被用在等待某個資源就緒的情形：測試發現條件不滿足後，讓線程阻塞一段時間後重新測試，直到條件滿足為止。
2. suspend() 和 resume() 方法：兩個方法配套使用，suspend()使得線程進入阻塞狀態，並且不會自動恢復，必須其對應的resume() 被調用，才能使得線程重新進入可執行狀態。典型地，suspend() 和 resume() 被用在等待另一個線程產生的結果的情形：測試發現結果還沒有產生後，讓線程阻塞，另一個線程產生了結果後，調用 resume() 使其恢復。
3. yield() 方法：yield() 使得線程放棄當前分得的 CPU 時間，但是不使線程阻塞，即線程仍處於可執行狀態，隨時可能再次分得 CPU 時間。調用 yield() 的效果等價於調度程序認為該線程已執行了足夠的時間從而轉到另一個線程。
4. wait() 和 notify() 方法：兩個方法配套使用，wait() 使得線程進入阻塞狀態，它有兩種形式，一種允許 指定以毫秒為單位的一段時間作為參數，另一種沒有參數，前者當對應的 notify() 被調用或者超出指定時間時線程重新進入可執行狀態，後者則必須對應的 notify() 被調用。
初看起來它們與 suspend() 和 resume() 方法對沒有什麼分別，但是事實上它們是截然不同的。區別的核心在於，前面敘述的所有方法，阻塞時都不會釋放佔用的鎖（如果佔用了的話），而這一對方法則相反。
上述的核心區別導致了一系列的細節上的區別。
首先，前面敘述的所有方法都隸屬於 Thread 類，但是這一對卻直接隸屬於 Object 類，也就是說，所有對象都擁有這一對方法。初看起來這十分不可思議，但是實際上卻是很自然的，因為這一對方法阻塞時要釋放佔用的鎖，而鎖是任何對象都具有的，調用任意對象的 wait() 方法導致線程阻塞，並且該對象上的鎖被釋放。
而調用 任意對象的notify()方法則導致因調用該對象的 wait() 方法而阻塞的線程中隨機選擇的一個解除阻塞（但要等到獲得鎖後才真正可執行）。
其次，前面敘述的所有方法都可在任何位置調用，但是這一對方法卻必須在 synchronized 方法或塊中調用，理由也很簡單，只有在synchronized 方法或塊中當前線程才佔有鎖，才有鎖可以釋放。
同樣的道理，調用這一對方法的對象上的鎖必須為當前線程所擁有，這樣才有鎖可以釋放。因此，這一對方法調用必須放置在這樣的 synchronized 方法或塊中，該方法或塊的上鎖對象就是調用這一對方法的對象。若不滿足這一條件，則程序雖然仍能編譯，但在運行時會出現IllegalMonitorStateException 異常。
wait() 和 notify() 方法的上述特性決定了它們經常和synchronized 方法或塊一起使用，將它們和操作系統的進程間通信機製作一個比較就會發現它們的相似性：synchronized方法或塊提供了類似於操作系統原語的功能，它們的執行不會受到多線程機制的干擾，而這一對方法則相當於 block 和wakeup 原語（這一對方法均聲明為 synchronized）。
它們的結合使得我們可以實現操作系統上一系列精妙的進程間通信的演算法（如信號量演算法），並用於解決各種復雜的線程間通信問題。
關於 wait() 和 notify() 方法最後再說明兩點：
第一：調用 notify() 方法導致解除阻塞的線程是從因調用該對象的 wait() 方法而阻塞的線程中隨機選取的，我們無法預料哪一個線程將會被選擇，所以編程時要特別小心，避免因這種不確定性而產生問題。
第二：除了 notify()，還有一個方法 notifyAll() 也可起到類似作用，唯一的區別在於，調用 notifyAll() 方法將把因調用該對象的 wait() 方法而阻塞的所有線程一次性全部解除阻塞。當然，只有獲得鎖的那一個線程才能進入可執行狀態。
談到阻塞，就不能不談一談死鎖，略一分析就能發現，suspend() 方法和不指定超時期限的 wait() 方法的調用都可能產生死鎖。遺憾的是，Java 並不在語言級別上支持死鎖的避免，我們在編程中必須小心地避免死鎖。
以上我們對 Java 中實現線程阻塞的各種方法作了一番分析，我們重點分析了 wait() 和 notify()方法，因為它們的功能最強大，使用也最靈活，但是這也導致了它們的效率較低，較容易出錯。實際使用中我們應該靈活使用各種方法，以便更好地達到我們的目的。
七、守護線程
守護線程是一類特殊的線程，它和普通線程的區別在於它並不是應用程序的核心部分，當一個應用程序的所有非守護線程終止運行時，即使仍然有守護線程在運行，應用程序也將終止，反之，只要有一個非守護線程在運行，應用程序就不會終止。守護線程一般被用於在後台為其它線程提供服務。
可以通過調用方法 isDaemon() 來判斷一個線程是否是守護線程，也可以調用方法 setDaemon() 來將一個線程設為守護線程。
八、線程組
線程組是一個 Java 特有的概念，在 Java 中，線程組是類ThreadGroup 的對象，每個線程都隸屬於唯一一個線程組，這個線程組在線程創建時指定並在線程的整個生命期內都不能更改。
你可以通過調用包含 ThreadGroup 類型參數的 Thread 類構造函數來指定線程屬的線程組，若沒有指定，則線程預設地隸屬於名為 system 的系統線程組。
在 Java 中，除了預建的系統線程組外，所有線程組都必須顯式創建。在 Java 中，除系統線程組外的每個線程組又隸屬於另一個線程組，你可以在創建線程組時指定其所隸屬的線程組，若沒有指定，則預設地隸屬於系統線程組。這樣，所有線程組組成了一棵以系統線程組為根的樹。
Java 允許我們對一個線程組中的所有線程同時進行操作，比如我們可以通過調用線程組的相應方法來設置其中所有線程的優先順序，也可以啟動或阻塞其中的所有線程。
Java 的線程組機制的另一個重要作用是線程安全。線程組機制允許我們通過分組來區分有不同安全特性的線程，對不同組的線程進行不同的處理，還可以通過線程組的分層結構來支持不對等安全措施的採用。
Java 的 ThreadGroup 類提供了大量的方法來方便我們對線程組樹中的每一個線程組以及線程組中的每一個線程進行操作。
九、總結
在本文中，我們講述了 Java 多線程編程的方方面面，包括創建線程，以及對多個線程進行調度、管理。我們深刻認識到了多線程編程的復雜性，以及線程切換開銷帶來的多線程程序的低效性，這也促使我們認真地思考一個問題：我們是否需要多線程？何時需要多線程？
多線程的核心在於多個代碼塊並發執行，本質特點在於各代碼塊之間的代碼是亂序執行的。我們的程序是否需要多線程，就是要看這是否也是它的內在特點。
假如我們的程序根本不要求多個代碼塊並發執行，那自然不需要使用多線程；假如我們的程序雖然要求多個代碼塊並發執行，但是卻不要求亂序，則我們完全可以用一個循環來簡單高效地實現，也不需要使用多線程；只有當它完全符合多線程的特點時，多線程機制對線程間通信和線程管理的強大支持才能有用武之地，這時使用多線程才是值得的。
#p#副標題#e#

㈡ 進程間通信方式

在操作系統中，一個進程可以理解為是關於計算機資源集合的一次運行活動，其就是一個正在執行的程序的實例。從概念上來說，一個進程擁有它自己的虛擬CPU和虛擬地址空間，任何一個進程對於彼此而言都是相互獨立的，這也引入了一個問題 —— 如何讓進程之間互相通信？

由於進程之間是互相獨立的，沒有任何手段直接通信，因此我們需要藉助操作系統來輔助它們。舉個通俗的例子，假如A與B之間是獨立的，不能彼此聯系，如果它們想要通信的話可以藉助第三方C，比如A將信息交給C，C再將信息轉交給B —— 這就是進程間通信的主要思想 —— 共享資源。

這里要解決的一個重要的問題就是如何避免競爭，即避免多個進程同時訪問臨界區的資源。

共享內存是進程間通信中最簡單的方式之一。共享內存允許兩個或更多進程訪問同一塊內存。當一個進程改變了這塊地址中的內容的時候，其它進程都會察覺到這個更改。

你可能會想到，我直接創建一個文件，然後進程不就都可以訪問了？

是的，但這個方法有幾個缺陷：

Linux下採用共享內存的方式來使進程完成對共享資源的訪問，它將磁碟文件復制到內存，並創建虛擬地址到該內存的映射，就好像該資源本來就在進程空間之中，此後我們就可以像操作本地變數一樣去操作它們了，實際的寫入磁碟將由系統選擇最佳方式完成，例如操作系統可能會批量處理加排序，從而大大提高IO速度。

如同上圖一樣，進程將共享內存映射到自己的虛擬地址空間中，進程訪問共享進程就好像在訪問自己的虛擬內存一樣，速度是非常快的。

共享內存的模型應該是比較好理解的：在物理內存中創建一個共享資源文件，進程將該共享內存綁定到自己的虛擬內存之中。

這里要解決的一個問題是如何將同一塊共享內存綁定到自己的虛擬內存中，要知道在不同進程中使用 malloc 函數是會順序分配空閑內存，而不會分配同一塊內存，那麼要如何去解決這個問題呢？

Linux操作系統已經想辦法幫我們解決了這個問題，在 #include <sys/ipc.h> 和 #include <sys/shm.h> 頭文件下，有如下幾個shm系列函數：

通過上述幾個函數，每個獨立的進程只要有統一的共享內存標識符便可以建立起虛擬地址到物理地址的映射，每個虛擬地址將被翻譯成指向共享區域的物理地址，這樣就實現了對共享內存的訪問。

還有一種相像的實現是採用mmap函數，mmap通常是直接對磁碟的映射——因此不算是共享內存，存儲量非常大，但訪問慢； shmat與此相反，通常將資源保存在內存中創建映射，訪問快，但存儲量較小。

不過要注意一點，操作系統並不保證任何並發問題，例如兩個進程同時更改同一塊內存區域，正如你和你的朋友在線編輯同一個文檔中的同一個標題，這會導致一些不好的結果，所以我們需要藉助信號量或其他方式來完成同步。

信號量是迪傑斯特拉最先提出的一種為解決 同步不同執行線程問題 的一種方法，進程與線程抽象來看大同小異，所以 信號量同樣可以用於同步進程間通信 。

信號量 s 是具有非負整數值的全局變數，由兩種特殊的 原子操作 來實現，這兩種原子操作稱為 P 和 V ：

信號量並不用來傳送資源，而是用來保護共享資源，理解這一點是很重要的，信號量 s 的表示的含義為 同時允許最大訪問資源的進程數量 ，它是一個全局變數。來考慮一個上面簡單的例子：兩個進程同時修改而造成錯誤，我們不考慮讀者而僅僅考慮寫者進程，在這個例子中共享資源最多允許一個進程修改資源，因此我們初始化 s 為1。

開始時，A率先寫入資源，此時A調用P(s)，將 s 減一，此時 s = 0，A進入共享區工作。

此時，進程B也想進入共享區修改資源，它調用P(s)發現此時s為0，於是掛起進程，加入等待隊列。

A工作完畢，調用V(s)，它發現s為0並檢測到等待隊列不為空，於是它隨機喚醒一個等待進程，並將s加1，這里喚醒了B。

B被喚醒，繼續執行P操作，此時s不為0，B成功執行將s置為0並進入工作區。

此時C想要進入工作區......

可以發現，在無論何時只有一個進程能夠訪問共享資源，這就是信號量做的事情，他控制進入共享區的最大進程數量，這取決於初始化s的值。此後，在進入共享區之前調用P操作，出共享區後調用V操作，這就是信號量的思想。

在Linux下並沒有直接的P&V函數，而是需要我們根據這幾個基本的sem函數族進行封裝：

正如其名，管道就如同生活中的一根管道，一端輸送，而另一端接收，雙方不需要知道對方，只需要知道管道就好了。

管道是一種最 基本的進程間通信機制。 管道由pipe函數來創建： 調用pipe函數，會在內核中開辟出一塊緩沖區用來進行進程間通信，這塊緩沖區稱為管道，它有一個讀端和一個寫端。管道被分為匿名管道和有名管道。

匿名管道通過pipe函數創建，這個函數接收一個長度為2的Int數組，並返回1或0表示成功或者失敗：

int pipe(int fd[2])

這個函數打開兩個文件描述符，一個讀端文件，一個寫端，分別存入fd[0]和fd[1]中，然後可以作為參數調用 write 和 read 函數進行寫入或讀取，注意fd[0]只能讀取文件，而fd[1]只能用於寫入文件。

你可能有個疑問，這要怎麼實現通信？其他進程又不知道這個管道，因為進程是獨立的，其他進程看不到某一個進程進行了什麼操作。

是的，『其他』進程確實是不知道，但是它的子進程卻可以！這里涉及到fork派生進程的相關知識，一個進程派生一個子進程，那麼子進程將會復制父進程的內存空間信息，注意這里是復制而不是共享，這意味著父子進程仍然是獨立的，但是在這一時刻，它們所有的信息又是相等的。因此子進程也知道該全局管道，並且也擁有兩個文件描述符與管道掛鉤，所以 匿名管道只能在具有親緣關系的進程間通信。

還要注意，匿名管道內部採用環形隊列實現，只能由寫端到讀端，由於設計技術問題，管道被設計為半雙工的，一方要寫入則必須關閉讀描述符，一方要讀出則必須關閉寫入描述符。因此我們說 管道的消息只能單向傳遞。

注意管道是堵塞的，如何堵塞將依賴於讀寫進程是否關閉文件描述符。如果讀管道，如果讀到空時，假設此時寫埠還沒有被完全關閉，那麼操作系統會假設還有數據要讀，此時讀進程將會被堵塞，直到有新數據或寫埠被關閉；如果管道為空，且寫埠也被關閉，此時操作系統會認為已經沒有東西可讀，會直接退出，並關閉管道。

對於寫一個已經滿了的管道同理而言。

管道內部由內核管理，在半雙工的條件下，保證數據不會出現並發問題。

了解了匿名管道之後，有名管道便很好理解了。在匿名管道的介紹中，我們說其他進程不知道管道和文件描述符的存在，所以匿名管道只適用於具有親緣關系的進程，而命名管道則很好的解決了這個問題 —— 現在管道有一個唯一的名稱了，任何進程都可以訪問這個管道。

注意，操作系統將管道看作一個抽象的文件，但管道並不是普通的文件，管道存在於內核空間中而不放置在磁碟(有名管道文件系統上有一個標識符，沒有數據塊)，訪問速度更快，但存儲量較小，管道是臨時的，是隨進程的，當進程銷毀，所有埠自動關閉，此時管道也是不存在的，操作系統將所有IO抽象的看作文件，例如網路也是一種文件，這意味著我們可以採用任何文件方法操作管道，理解這種抽象是很重要的，命名管道就利用了這種抽象。

Linux下，採用mkfifo函數創建，可以傳入要指定的『文件名』，然後其他進程就可以調用open方法打開這個特殊的文件，並進行write和read操作(那肯定是位元組流對吧)。

注意，命名管道適用於任何進程，除了這一點不同外，其餘大多數都與匿名管道相同。

消息隊列亦稱報文隊列，也叫做信箱，是Linux的一種通信機制，這種通信機制傳遞的數據會被拆分為一個一個獨立的數據塊，也叫做消息體，消息體中可以定義類型與數據，克服了無格式承載位元組流的缺陷(現在收到void*後可以知道其原本的格式惹):

同管道類似，它有一個不足就是每個消息的最大長度是有上限的，整個消息隊列也是長度限制的。

內核為每個IPC對象維護了一個數據結構struct ipc_perm，該數據結構中有指向鏈表頭與鏈表尾部的指針，保證每一次插入取出都是O(1)的時間復雜度。

一個進程可以發送信號給另一個進程，一個信號就是一條消息，可以用於通知一個進程組發送了某種類型的事件，該進程組中的進程可以採取處理程序處理事件。

Linux下 unistd.h 頭文件下定義了如圖中的常量，當你在shell命令行鍵入 ctrl + c 時，內核就會前台進程組的每一個進程發送 SIGINT 信號，中止進程。

我們可以看到上述只有30個信號，因此操作系統會為每一個進程維護一個int類型變數sig，利用其中30位代表是否有對應信號事件，每一個進程還有一個int類型變數block，與sig對應，其30位表示是否堵塞對應信號(不調用處理程序)。如果存在多個相同的信號同時到來，多餘信號會被存儲在一個等待隊列中等待。

我們要理解進程組是什麼，每個進程屬於一個進程組，可以有多個進程屬於同一個組。每個進程擁有一個進程ID，稱為 pid ，而每個進程組擁有一個進程組ID，稱為 pgid ，默認情況下，一個進程與其子進程屬於同一進程組。

軟體方面(諸如檢測鍵盤輸入是硬體方面)可以利用kill函數發送信號，kill函數接受兩個參數，進程ID和信號類型，它將該信號類型發送到對應進程，如果該pid為0，那麼會發送到屬於自身進程組的所有進程。

接收方可以採用signal函數給對應事件添加處理程序，一旦事件發生，如果未被堵塞，則調用該處理程序。

Linux下有一套完善的函數用以處理信號機制。

Socket套接字是用與網路中不同主機的通信方式，多用於客戶端與伺服器之間，在Linux下也有一系列C語言函數，諸如socket、connect、bind、listen與accept，我們無需花太多時間研究這些函數，因為我們可能一輩子都不會與他們打交道，對於原理的學習，後續我會對Java中的套接字socket源碼進行剖析。

對於工作而言，我們可能一輩子都用不上這些操作，但作為對於操作系統的學習，認識到進程間是如何通信還是很有必要的。

面試的時候對於這些方法我們不需要掌握到很深的程度，但我們必須要講的來有什麼通信方式，這些方式都有什麼特點，適用於什麼條件，大致是如何操作的，能說出這些，基本足以讓面試官對你十分滿意了。

㈢ java如何實現進程間的通信

傳統的進程間通信的方式有大致如下幾種：

(1) 管道(PIPE)
(2) 命名管道(FIFO)
(3) 信號量(Semphore)
(4) 消息隊列(MessageQueue)
(5) 共享內存(SharedMemory)
(6) Socket

Java如何支持進程間通信。我們把Java進程理解為JVM進程。很明顯，傳統的這些大部分技術是無法被我們的應用程序利用了（這些進程間通信都是靠系統調用來實現的）。但是Java也有很多方法可以進行進程間通信的。
除了上面提到的Socket之外，當然首選的IPC可以使用Rmi，或者Corba也可以。另外Java nio的MappedByteBuffer也可以通過內存映射文件來實現進程間通信(共享內存)。