㈠ java多線程開發的同步機制有哪些
Java同步
標簽： 分類：
一、關鍵字：
thread（線程）、thread-safe(線程安全)、intercurrent（並發的）
synchronized(同步的)、asynchronized(非同步的)、
volatile（易變的）、atomic（原子的）、share（共享）
二、總結背景：
一次讀寫共享文件編寫，嚯，好傢伙，竟然揪出這些零碎而又是一路的知識點。於是乎，Google和翻閱了《Java參考大全》、《Effective Java Second Edition》，特此總結一下供日後工作學習參考。
三、概念：
1、 什麼時候必須同步？什麼叫同步？如何同步？
要跨線程維護正確的可見性，只要在幾個線程之間共享非 final 變數，就必須使用 synchronized（或 volatile）以確保一個線程可以看見另一個線程做的更改。
為了在線程之間進行可靠的通信，也為了互斥訪問，同步是必須的。這歸因於java語言規范的內存模型，它規定了：一個線程所做的變化何時以及如何變成對其它線程可見。
因為多線程將非同步行為引進程序，所以在需要同步時，必須有一種方法強制進行。例如：如果2個線程想要通信並且要共享一個復雜的數據結構，如鏈表，此時需要
確保它們互不沖突，也就是必須阻止B線程在A線程讀數據的過程中向鏈表裡面寫數據（A獲得了鎖，B必須等A釋放了該鎖）。
為了達到這個目的，java在一個舊的的進程同步模型——監控器（Monitor）的基礎上實現了一個巧妙的方案：監控器是一個控制機制，可以認為是一個
很小的、只能容納一個線程的盒子，一旦一個線程進入監控器，其它的線程必須等待，直到那個線程退出監控為止。通過這種方式，一個監控器可以保證共享資源在
同一時刻只可被一個線程使用。這種方式稱之為同步。（一旦一個線程進入一個實例的任何同步方法，別的線程將不能進入該同一實例的其它同步方法，但是該實例
的非同步方法仍然能夠被調用）。
錯誤的理解：同步嘛，就是幾個線程可以同時進行訪問。
同步和多線程關系：沒多線程環境就不需要同步;有多線程環境也不一定需要同步。
鎖提供了兩種主要特性：互斥（mutual exclusion） 和可見性（visibility）。
互斥即一次只允許一個線程持有某個特定的鎖，因此可使用該特性實現對共享數據的協調訪問協議，這樣，一次就只有一個線程能夠使用該共享數據。
可見性要更加復雜一些，documents它必須確保釋放鎖之前對共享數據做出的更改對於隨後獲得該鎖的另一個線程是可見的 —— 如果沒有同步機制提供的這種可見性保證，線程看到的共享變數可能是修改前的值或不一致的值，這將引發許多嚴重問題
小結：為了防止多個線程並發對同一數據的修改，所以需要同步，否則會造成數據不一致（就是所謂的：線程安全。如java集合框架中Hashtable和
Vector是線程安全的。我們的大部分程序都不是線程安全的，因為沒有進行同步，而且我們沒有必要，因為大部分情況根本沒有多線程環境）。
2、 什麼叫原子的（原子操作）？
Java原子操作是指：不會被打斷地的操作。（就是做到互斥 和可見性？！）
那難道原子操作就可以真的達到線程安全同步效果了嗎？實際上有一些原子操作不一定是線程安全的。
那麼，原子操作在什麼情況下不是線程安全的呢？也許是這個原因導致的：java線程允許線程在自己的內存區保存變數的副本。允許線程使用本地的私有拷貝進
行工作而非每次都使用主存的值是為了提高性能（本人愚見：雖然原子操作是線程安全的，可各線程在得到變數（讀操作）後，就是各自玩
弄自己的副本了，更新操作（寫操作）因未寫入主存中，導致其它線程不可見）。
那該如何解決呢？因此需要通過java同步機制。
在java中，32位或者更少位數的賦值是原子的。在一個32位的硬體平台上，除了double和long型的其它原始類型通常都
是使用32位進行表示，而double和long通常使用64位表示。另外，對象引用使用本機指針實現，通常也是32位的。對這些32位的類型的操作是原
子的。
這些原始類型通常使用32位或者64位表示，這又引入了另一個小小的神話：原始類型的大小是由語言保證的。這是不對的。java語言保證的是原始類型的表
數范圍而非JVM中的存儲大小。因此，int型總是有相同的表數范圍。在一個JVM上可能使用32位實現，而在另一個JVM上可能是64位的。在此再次強
調：在所有平台上被保證的是表數范圍，32位以及更小的值的操作是原子的。
3、 不要搞混了：同步、非同步
舉個例子：普通B/S模式（同步）AJAX技術（非同步）
同步：提交請求->等待伺服器處理->處理完返回 這個期間客戶端瀏覽器不能幹任何事
非同步：請求通過事件觸發->伺服器處理（這是瀏覽器仍然可以作其他事情）->處理完畢
可見，彼「同步」非此「同步」——我們說的java中的那個共享數據同步（synchronized）
一個同步的對象是指行為（動作），一個是同步的對象是指物質（共享數據）。
4、 Java同步機制有4種實現方式：（部分引用網上資源）
① ThreadLocal ② synchronized( ) ③ wait() 與 notify() ④ volatile
目的：都是為了解決多線程中的對同一變數的訪問沖突
ThreadLocal
ThreadLocal 保證不同線程擁有不同實例，相同線程一定擁有相同的實例，即為每一個使用該變數的線程提供一個該變數值的副本，每一個線程都可以獨立改變自己的副本，而不是與其它線程的副本沖突。
優勢：提供了線程安全的共享對象
與其它同步機制的區別：同步機制是為了同步多個線程對相同資源的並發訪問，是為了多個線程之間進行通信；而 ThreadLocal 是隔離多個線程的數據共享，從根本上就不在多個線程之間共享資源，這樣當然不需要多個線程進行同步了。
volatile
volatile 修飾的成員變數在每次被線程訪問時，都強迫從共享內存中重讀該成員變數的值。而且，當成員變數發生變化時，強迫線程將變化值回寫到共享內存。
優勢：這樣在任何時刻，兩個不同的線程總是看到某個成員變數的同一個值。
緣由：Java
語言規范中指出，為了獲得最佳速度，允許線程保存共享成員變數的私有拷貝，而且只當線程進入或者離開同步代碼塊時才與共享成員變數的原
始值對比。這樣當多個線程同時與某個對象交互時，就必須要注意到要讓線程及時的得到共享成員變數的變化。而 volatile
關鍵字就是提示 VM ：對於這個成員變數不能保存它的私有拷貝，而應直接與共享成員變數交互。
使用技巧：在兩個或者更多的線程訪問的成員變數上使用 volatile 。當要訪問的變數已在 synchronized 代碼塊中，或者為常量時，不必使用。
線程為了提高效率，將某成員變數(如A)拷貝了一份（如B），線程中對A的訪問其實訪問的是B。只在某些動作時才進行A和B的同步，因此存在A和B不一致
的情況。volatile就是用來避免這種情況的。
volatile告訴jvm，它所修飾的變數不保留拷貝，直接訪問主內存中的（讀操作多時使用較好；線程間需要通信，本條做不到）
Volatile 變數具有 synchronized 的可見性特性，但是不具備原子特性。這就是說線程能夠自動發現 volatile
變數的最新值。Volatile
變數可用於提供線程安全，但是只能應用於非常有限的一組用例：多個變數之間或者某個變數的當前值與修改後值
之間沒有約束。
您只能在有限的一些情形下使用 volatile 變數替代鎖。要使 volatile 變數提供理想的線程安全，必須同時滿足下面兩個條件：
對變數的寫操作不依賴於當前值；該變數沒有包含在具有其他變數的不變式中。
sleep() vs wait()
sleep是線程類（Thread）的方法，導致此線程暫停執行指定時間，把執行機會給其他線程，但是監控狀態依然保持，到時後會自動恢復。調用sleep不會釋放對象鎖。
wait是Object類的方法，對此對象調用wait方法導致本線程放棄對象鎖，進入等待此對象的等待鎖定池，只有針對此對象發出notify方法（或notifyAll）後本線程才進入對象鎖定池准備獲得對象鎖進入運行狀態。
（如果變數被聲明為volatile，在每次訪問時都會和主存一致；如果變數在同步方法或者同步塊中被訪問，當在方法或者塊的入口處獲得鎖以及方法或者塊退出時釋放鎖時變數被同步。）
㈡ Java如何實現線程之間的互斥
臨界區（Critical Section）：適合一個進程內的多線程訪問公共區域或代碼段時使用
Java如何實現線程之間的互斥
互斥量 (Mutex)：適合不同進程內多線程訪問公共區域或代碼段時使用，與臨界區相似。
事件（Event）：通過線程間觸發事件實現同步互斥
信號量（Semaphore）：與臨界區和互斥量不同，可以實現多個線程同時訪問公共區域數據，原理與操作系統中PV操作類似，先設置一個訪問公共區域的線程最大連接數，每有一個線程訪問共享區資源數就減一，直到資源數小於等於零。
㈢ JAVA中線程在什麼時候需要同步和互斥
何時需要同步
在多個線程同時訪問互斥（可交換）數據時，應該同步以保護數據，確保兩個線程不會同時修改更改它。
對於非靜態欄位中可更改的數據，通常使用非靜態方法訪問
對於靜態欄位中可更改的數據，通常使用靜態方法訪問。
1、線程同步的目的是為了保護多個線程反問一個資源時對資源的破壞。
2、線程同步方法是通過鎖來實現，每個對象都有切僅有一個鎖，這個鎖與一個特定的對象關聯，線程一旦獲取了對象鎖，其他訪問該對象的線程就無法再訪問該對象的其他非同步方法。
3、對於靜態同步方法，鎖是針對這個類的，鎖對象是該類的Class對象。靜態和非靜態方法的鎖互不幹預。一個線程獲得鎖，當在一個同步方法中訪問另外對象上的同步方法時，會獲取這兩個對象鎖。
4、對於同步，要時刻清醒在哪個對象上同步，這是關鍵。
5、編寫線程安全的類，需要時刻注意對多個線程競爭訪問資源的邏輯和安全做出正確的判斷，對「原子」操作做出分析，並保證原子操作期間別的線程無法訪問競爭資源。
6、當多個線程等待一個對象鎖時，沒有獲取到鎖的線程將發生阻塞。
7、死鎖是線程間相互等待鎖鎖造成的，在實際中發生的概率非常的小。真讓你寫個死鎖程序，不一定好使，呵呵。但是，一旦程序發生死鎖，程序將死掉。
使用鎖定還有一些其他危險，如死鎖（當以不一致的順序獲得多個鎖定時會發生死鎖）。甚至沒有這種危險，鎖定也僅是相對的粗粒度協調機制，同樣非常適合管理簡單操作，如增加計數器或更新互斥擁有者。如果有更細粒度的機制來可靠管理對單獨變數的並發更新，則會更好一些；在大多數現代處理器都有這種機制。
㈣ 如何保證線程安全
不可變 在java語言中,不可變的對象一定是線程安全的,無論是對象的方法實現還是方法的...
2.絕對線程安全 絕對的線程安全完全滿足Brian GoetZ給出的線程安全的定義,這個定義...
3.相對線程安全 相對線程安全就是我們通常意義上所講的一個類是「線程安全」的。 它需要保證對...
4.線程兼容 線程兼容就是我們通常意義上所講的一個類不是線程安全的。 線程兼容是指對
㈤ java線程同步問題。。
需求講得不夠清楚，嘗試看你的代碼設計，也看不大明白，不過有些比較明顯的問題：
Thread的run方法你為何用synchronized 裝飾？synchronized 同步方法的互斥只發生在多個線程調用同個對象的方法時，在這里每個線程的run方法都是由主線程開啟，何來多個線程調用run?
另外 在線程內部調用wait();和notifyAll，相當於調用self.wait和self.notifyAll，這兩個方法的同步是通過同一個對象來進行互斥的，那麼各自線程各自利用自身進行互斥，線程之間並沒有任何交集的地方，怎麼實現會實現交互？舉個簡單的例子，線程t1調用wait()進入了自身的等待區，它現在不能再往下跑了，現在等的是別的線程來調用t1.notifyAll來激活，但是線程t2和t3都不知道t1這個東西，怎麼來激活呢？甚至可能t2和t3都自己進入了自身對象的等待區而自身難保了.. 這樣誰都救不了誰~~
猜想你的思路吧：140個客戶，每個客戶需要辦理的時間分別是確定的，一共有12個窗口可以辦理客戶，每個窗口處理完之後緊接著處理下一個客戶（每個窗口的運作時間都不會影響到其他窗口的運作），直到全部處理完是吧。那麼這就是一個生產者&消費者的問題了，這里的生產者就是客戶和他的時間，而且還是固定的量，消費者就是窗口，我們抽象為一個個的線程，於是：
抽象一個Routine類表示事務，裡面描述了用戶名稱和用戶需要辦理的時間：
class Routine{
String name;
long orderTime;
int custNumber; // 描述當前客戶的序號
}
抽象一個Routine的Provider類，用於向窗口提供事務，需要考慮同步：
class RoutineProvider{
private List<Routine> routines = new LinkedList<Routine>();
public void init(){
//在這里做初始化，為routines 添加140個實例，count置為140
}
//聲明fetchRoutine，用於向窗口線程提供一個Routine，需要注意的是，這里需要同步
public synchronized Routine fetchRoutine(){
if(routines.isEmpty())return null;
return routines.removeFirst();
}
}
此後是窗口線程類：
class WorkThread extends Thread{
private RoutineProvider provider;
private String name;
public WorkThread(String name, RoutineProvider provider){
this.name = name;
this.provider = provider;
}
public void run(){
while(true){
Routine r = provider.fetchRoutine()
if(r == null)break; //事務全部被窗口線程拿走了
System.out.println("窗口[" + name + "]正在處理第" + r.getCustNumber() + "個顧客(" + r.getName() + ")");
try{
sleep(r.getOrderTime())
}catch(InterrupttedException e){}
}
}
最後的處理簡單了：
1 新建一個RoutineProvider，為它初始化Routine列表
2 創建一系列的窗口線程（WorkThread），在構造函數中指定窗口名、還有Provider(全局唯一）
3 逐個調用線程的start()方法。
PS:1樓的解法很明顯有缺陷：兩個synchronized的方法並沒有真實的同步，在線程處理上面沒有考慮共享數據侵蝕的問題，比如取出一個用戶之後，count立馬需要-1，這個操作需要作為原子，這里便沒有考慮到。
㈥ 如何創建線程如何保證線程安全
線程安全等級
之前的博客中已有所提及「線程安全」問題，一般我們常說某某類是線程安全的，某某是非線程安全的。其實線程安全並不是一個「非黑即白」單項選擇題。按照「線程安全」的安全程度由強到弱來排序，我們可以將java語言中各種操作共享的數據分為以下5類：不可變、絕對線程安全、相對線程安全、線程兼容和線程對立。
1、不可變
在java語言中，不可變的對象一定是線程安全的，無論是對象的方法實現還是方法的調用者，都不需要再採取任何的線程安全保障措施。如final關鍵字修飾的數據不可修改，可靠性最高。
2、絕對線程安全
絕對的線程安全完全滿足Brian GoetZ給出的線程安全的定義，這個定義其實是很嚴格的，一個類要達到「不管運行時環境如何，調用者都不需要任何額外的同步措施」通常需要付出很大的代價。
3、相對線程安全
相對線程安全就是我們通常意義上所講的一個類是「線程安全」的。
它需要保證對這個對象單獨的操作是線程安全的，我們在調用的時候不需要做額外的保障措施，但是對於一些特定順序的連續調用，就可能需要在調用端使用額外的同步手段來保證調用的正確性。
在java語言中，大部分的線程安全類都屬於相對線程安全的，例如Vector、HashTable、Collections的synchronizedCollection（）方法保證的集合。
4、線程兼容
線程兼容就是我們通常意義上所講的一個類不是線程安全的。
線程兼容是指對象本身並不是線程安全的，但是可以通過在調用端正確地使用同步手段來保證對象在並發環境下可以安全地使用。Java API中大部分的類都是屬於線程兼容的。如與前面的Vector和HashTable相對應的集合類ArrayList和HashMap等。
5、線程對立
線程對立是指無論調用端是否採取了同步錯誤，都無法在多線程環境中並發使用的代碼。由於java語言天生就具有多線程特性，線程對立這種排斥多線程的代碼是很少出現的。
一個線程對立的例子是Thread類的supend()和resume()方法。如果有兩個線程同時持有一個線程對象，一個嘗試去中斷線程，另一個嘗試去恢復線程，如果並發進行的話，無論調用時是否進行了同步，目標線程都有死鎖風險。正因此如此，這兩個方法已經被廢棄啦。
二、線程安全的實現方法
保證線程安全以是否需要同步手段分類，分為同步方案和無需同步方案。
1、互斥同步
互斥同步是最常見的一種並發正確性保障手段。同步是指在多線程並發訪問共享數據時，保證共享數據在同一時刻只被一個線程使用（同一時刻，只有一個線程在操作共享數據）。而互斥是實現同步的一種手段，臨界區、互斥量和信號量都是主要的互斥實現方式。因此，在這4個字裡面，互斥是因，同步是果；互斥是方法，同步是目的。
在java中，最基本的互斥同步手段就是synchronized關鍵字，synchronized關鍵字編譯之後，會在同步塊的前後分別形成monitorenter和monitorexit這兩個位元組碼質量，這兩個位元組碼指令都需要一個reference類型的參數來指明要鎖定和解鎖的對象。
此外，ReentrantLock也是通過互斥來實現同步。在基本用法上，ReentrantLock與synchronized很相似，他們都具備一樣的線程重入特性。
互斥同步最主要的問題就是進行線程阻塞和喚醒所帶來的性能問題，因此這種同步也成為阻塞同步。從處理問題的方式上說，互斥同步屬於一種悲觀的並發策略，總是認為只要不去做正確地同步措施（例如加鎖），那就肯定會出現問題，無論共享數據是否真的會出現競爭，它都要進行加鎖。
2、非阻塞同步
隨著硬體指令集的發展，出現了基於沖突檢測的樂觀並發策略，通俗地說，就是先進行操作，如果沒有其他線程爭用共享數據，那操作就成功了；如果共享數據有爭用，產生了沖突，那就再採用其他的補償措施。（最常見的補償錯誤就是不斷地重試，直到成功為止），這種樂觀的並發策略的許多實現都不需要把線程掛起，因此這種同步操作稱為非阻塞同步。
非阻塞的實現CAS（compareandswap）：CAS指令需要有3個操作數，分別是內存地址（在java中理解為變數的內存地址，用V表示）、舊的預期值（用A表示）和新值（用B表示）。CAS指令執行時，CAS指令指令時，當且僅當V處的值符合舊預期值A時，處理器用B更新V處的值，否則它就不執行更新，但是無論是否更新了V處的值，都會返回V的舊值，上述的處理過程是一個原子操作。
CAS缺點：
ABA問題：因為CAS需要在操作值的時候檢查下值有沒有發生變化，如果沒有發生變化則更新，但是一個值原來是A，變成了B，又變成了A，那麼使用CAS進行檢查時會發現它的值沒有發生變化，但是實際上卻變化了。
ABA問題的解決思路就是使用版本號。在變數前面追加版本號，每次變數更新的時候把版本號加一，那麼A-B-A就變成了1A-2B-3C。JDK的atomic包里提供了一個類AtomicStampedReference來解決ABA問題。這個類的compareAndSet方法作用是首先檢查當前引用是否等於預期引用，並且當前標志是否等於預期標志，如果全部相等，則以原子方式將該引用和該標志的值設置為給定的更新值。
3、無需同步方案
要保證線程安全，並不是一定就要進行同步，兩者沒有因果關系。同步只是保證共享數據爭用時的正確性的手段，如果一個方法本來就不涉及共享數據，那它自然就無需任何同步操作去保證正確性，因此會有一些代碼天生就是線程安全的。
1）可重入代碼
可重入代碼（ReentrantCode）也稱為純代碼（Pure Code），可以在代碼執行的任何時刻中斷它，轉而去執行另外一段代碼，而在控制權返回後，原來的程序不會出現任何錯誤。所有的可重入代碼都是線程安全的，但是並非所有的線程安全的代碼都是可重入的。
可重入代碼的特點是不依賴存儲在堆上的數據和公用的系統資源、用到的狀態量都是由參數中傳入、不調用 非可重入的方法等。
（類比：synchronized擁有鎖重入的功能，也就是在使用synchronized時，當一個線程得到一個對象鎖後，再次請求此對象鎖時時可以再次得到該對象的鎖）
2）線程本地存儲
如果一段代碼中所需的數據必須與其他代碼共享，那就看看這些共享數據的代碼是否能保證在同一個線程中執行？如果能保證，我們就可以把共享數據的可見范圍限制在同一個線程之內。這樣無需同步也能保證線程之間不出現數據的爭用問題。
符合這種特點的應用並不少見，大部分使用消費隊列的架構模式（如「生產者-消費者」模式）都會將產品的消費過程盡量在一個線程中消費完。其中最重要的一個應用實例就是經典的Web交互模型中的「一個請求對應一個伺服器線程（Thread-per-Request）」的處理方式，這種處理方式的廣泛應用使得很多Web伺服器應用都可以使用線程本地存儲來解決線程安全問題。
㈦ java中多個線程訪問共享數據的方式有哪些
多個線程對共同數據的訪問的實現，要根據情況而定 （1）當訪問共同的代碼的時候：可以使用同一個Runnable對象，這個Runnable對象中有這個共享數據，比如賣票系統就可以這么做。或者這個共享數據封裝在一個對象當中，然後對這個對象加鎖，也可以實現數據安全訪問。 （2）當各個線程訪問的代碼不同時：這時候要使用不同的Runnable對象，有兩種實現方式： a)將共享數據封裝在另一個對象當中，然後將這個對象逐一的轉遞給各個Runnable對象。操作數據的方法也放進這個對象當中。這樣容易實現各個線程對這個數據的同步和共享。 b)將Runnable對象作為某一個類中的內部類，共享數據作為這個外部類的成員變數，每個線程對共享數據的訪問也交給外部類的方法，比便對共享數據的互斥和通信。Runnable對象調用外部類的操作這個共享數據的方法。 還有一種方式是a)和b)的結合實現，把共享數據封裝到一個對象當中去，這個對象也實現對這個共享數據的操作，這個對象作為外部類的成員變數。然後再創建多個Runnable對象做為內部類，操作這個對象。 總結：對於要是下同步互斥的代碼要放在不同的方法中，並且放在同一個對象當中，容易實現互斥和通信，並且也有利於日後的維護。這樣思路也很清晰。 如有不妥之處，敬請指正。
㈧ 如何在Java多線程編程中實現程序同與互斥
作為一個完全面向對象的語言，Java提供了類 Java.lang.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();
}
}
㈨ java 非同步、同步和互斥分別是什麼
舉例：有一群人要打你。
同步：大家一起打你；
非同步：大家排隊打你，一個一個的來打。
互斥：我不好比喻了。抱歉！