2. 程式人生 > >Java多執行緒學習（十）：AQS 原理以及 AQS 同步元件總結

Java多執行緒學習（十）：AQS 原理以及 AQS 同步元件總結

阿新 • • 發佈：2018-12-06

常見問題：AQS 原理？;CountDownLatch和CyclicBarrier瞭解嗎,兩者的區別是什麼？用過Semaphore嗎？

本節思維導圖：

併發程式設計面試必備：AQS 原理以及 AQS 同步元件總結

阿里雲產品 1888 代金券領取:https://promotion.aliyun.com/ntms/yunparter/invite.html?userCode=hf47liqn

1 AQS 簡單介紹

AQS的全稱為（AbstractQueuedSynchronizer），這個類在java.util.concurrent.locks包下面。

enter image description here

AQS是一個用來構建鎖和同步器的框架，使用AQS能簡單且高效地構造出應用廣泛的大量的同步器，比如我們提到的ReentrantLock，Semaphore，其他的諸如ReentrantReadWriteLock，SynchronousQueue，FutureTask等等皆是基於AQS的。當然，我們自己也能利用AQS非常輕鬆容易地構造出符合我們自己需求的同步器。

2 AQS 原理

在面試中被問到併發知識的時候，大多都會被問到“請你說一下自己對於AQS原理的理解”。下面給大家一個示例供大家參加，面試不是背題，大家一定要假如自己的思想，即使加入不了自己的思想也要保證自己能夠通俗的講出來而不是背出來。

下面大部分內容其實在AQS類註釋上已經給出了，不過是英語看著比較吃力一點，感興趣的話可以看看原始碼。

2.1 AQS 原理概覽

AQS核心思想是，如果被請求的共享資源空閒，則將當前請求資源的執行緒設定為有效的工作執行緒，並且將共享資源設定為鎖定狀態。如果被請求的共享資源被佔用，那麼就需要一套執行緒阻塞等待以及被喚醒時鎖分配的機制，這個機制AQS是用CLH佇列鎖實現的，即將暫時獲取不到鎖的執行緒加入到佇列中。

CLH(Craig,Landin,and Hagersten)佇列是一個虛擬的雙向佇列（虛擬的雙向佇列即不存在佇列例項，僅存在結點之間的關聯關係）。AQS是將每條請求共享資源的執行緒封裝成一個CLH鎖佇列的一個結點（Node）來實現鎖的分配。

看個AQS(AbstractQueuedSynchronizer)原理圖：

enter image description here

AQS使用一個int成員變數來表示同步狀態，通過內建的FIFO佇列來完成獲取資源執行緒的排隊工作。AQS使用CAS對該同步狀態進行原子操作實現對其值的修改。

private volatile int state;//共享變數，使用volatile修飾保證執行緒可見性

狀態資訊通過procted型別的getState，setState，compareAndSetState進行操作


//返回同步狀態的當前值
protected final int getState() {  
        return state;
}
 // 設定同步狀態的值
protected final void setState(int newState) { 
        state = newState;
}
//原子地（CAS操作）將同步狀態值設定為給定值update如果當前同步狀態的值等於expect（期望值）
protected final boolean compareAndSetState(int expect, int update) {
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

2.2 AQS 對資源的共享方式

AQS定義兩種資源共享方式

  • Exclusive（獨佔）：只有一個執行緒能執行，如ReentrantLock。又可分為公平鎖和非公平鎖：
    • 公平鎖：按照執行緒在佇列中的排隊順序，先到者先拿到鎖
    • 非公平鎖：當執行緒要獲取鎖時，無視佇列順序直接去搶鎖，誰搶到就是誰的
  • Share（共享）：多個執行緒可同時執行，如Semaphore/CountDownLatch。Semaphore、CountDownLatCh、 CyclicBarrier、ReadWriteLock 我們都會在後面講到。

ReentrantReadWriteLock 可以看成是組合式，因為ReentrantReadWriteLock也就是讀寫鎖允許多個執行緒同時對某一資源進行讀。

不同的自定義同步器爭用共享資源的方式也不同。自定義同步器在實現時只需要實現共享資源 state 的獲取與釋放方式即可，至於具體執行緒等待佇列的維護（如獲取資源失敗入隊/喚醒出隊等），AQS已經在上層已經幫我們實現好了。

2.3 AQS底層使用了模板方法模式

同步器的設計是基於模板方法模式的，如果需要自定義同步器一般的方式是這樣（模板方法模式很經典的一個應用）：

  1. 使用者繼承AbstractQueuedSynchronizer並重寫指定的方法。（這些重寫方法很簡單，無非是對於共享資源state的獲取和釋放）
  2. 將AQS組合在自定義同步元件的實現中，並呼叫其模板方法，而這些模板方法會呼叫使用者重寫的方法。

這和我們以往通過實現介面的方式有很大區別，這是模板方法模式很經典的一個運用，下面簡單的給大家介紹一下模板方法模式，模板方法模式是一個很容易理解的設計模式之一。

模板方法模式是基於”繼承“的，主要是為了在不改變模板結構的前提下在子類中重新定義模板中的內容以實現複用程式碼。舉個很簡單的例子假如我們要去一個地方的步驟是：購票buyTicket()->安檢securityCheck()->乘坐某某工具回家ride()->到達目的地arrive()。我們可能乘坐不同的交通工具回家比如飛機或者火車，所以除了ride()方法，其他方法的實現幾乎相同。我們可以定義一個包含了這些方法的抽象類，然後使用者根據自己的需要繼承該抽象類然後修改 ride()方法。

AQS使用了模板方法模式，自定義同步器時需要重寫下面幾個AQS提供的模板方法：

isHeldExclusively()//該執行緒是否正在獨佔資源。只有用到condition才需要去實現它。
tryAcquire(int)//獨佔方式。嘗試獲取資源，成功則返回true，失敗則返回false。
tryRelease(int)//獨佔方式。嘗試釋放資源，成功則返回true，失敗則返回false。
tryAcquireShared(int)//共享方式。嘗試獲取資源。負數表示失敗；0表示成功，但沒有剩餘可用資源；正數表示成功，且有剩餘資源。
tryReleaseShared(int)//共享方式。嘗試釋放資源，成功則返回true，失敗則返回false。

預設情況下，每個方法都丟擲 UnsupportedOperationException。 這些方法的實現必須是內部執行緒安全的，並且通常應該簡短而不是阻塞。AQS類中的其他方法都是final ，所以無法被其他類使用，只有這幾個方法可以被其他類使用。

以ReentrantLock為例，state初始化為0，表示未鎖定狀態。A執行緒lock()時，會呼叫tryAcquire()獨佔該鎖並將state+1。此後，其他執行緒再tryAcquire()時就會失敗，直到A執行緒unlock()到state=0（即釋放鎖）為止，其它執行緒才有機會獲取該鎖。當然，釋放鎖之前，A執行緒自己是可以重複獲取此鎖的（state會累加），這就是可重入的概念。但要注意，獲取多少次就要釋放多麼次，這樣才能保證state是能回到零態的。

再以CountDownLatch以例，任務分為N個子執行緒去執行，state也初始化為N（注意N要與執行緒個數一致）。這N個子執行緒是並行執行的，每個子執行緒執行完後countDown()一次，state會CAS(Compare and Swap)減1。等到所有子執行緒都執行完後(即state=0)，會unpark()主呼叫執行緒，然後主呼叫執行緒就會從await()函式返回，繼續後餘動作。

一般來說，自定義同步器要麼是獨佔方法，要麼是共享方式，他們也只需實現tryAcquire-tryRelease、tryAcquireShared-tryReleaseShared中的一種即可。但AQS也支援自定義同步器同時實現獨佔和共享兩種方式，如ReentrantReadWriteLock。

推薦兩篇 AQS 原理和相關原始碼分析的文章：

3 Semaphore(訊號量)-允許多個執行緒同時訪問

**synchronized 和 ReentrantLock 都是一次只允許一個執行緒訪問某個資源，Semaphore(訊號量)可以指定多個執行緒同時訪問某個資源。**示例程式碼如下：

/**
 * 
 * @author Snailclimb
 * @date 2018年9月30日
 * @Description: 需要一次性拿一個許可的情況
 */
public class SemaphoreExample1 {
	// 請求的數量
	private static final int threadCount = 550;

	public static void main(String[] args) throws InterruptedException {
		// 建立一個具有固定執行緒數量的執行緒池物件（如果這裡執行緒池的執行緒數量給太少的話你會發現執行的很慢）
		ExecutorService threadPool = Executors.newFixedThreadPool(300);
		// 一次只能允許執行的執行緒數量。
		final Semaphore semaphore = new Semaphore(20);

		for (int i = 0; i < threadCount; i++) {
			final int threadnum = i;
			threadPool.execute(() -> {// Lambda 表示式的運用
				try {
					semaphore.acquire();// 獲取一個許可，所以可執行執行緒數量為20/1=20
					test(threadnum);
					semaphore.release();// 釋放一個許可
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}

			});
		}
		threadPool.shutdown();
		System.out.println("finish");
	}

	public static void test(int threadnum) throws InterruptedException {
		Thread.sleep(1000);// 模擬請求的耗時操作
		System.out.println("threadnum:" + threadnum);
		Thread.sleep(1000);// 模擬請求的耗時操作
	}
}

執行 acquire 方法阻塞，直到有一個許可證可以獲得然後拿走一個許可證；每個 release 方法增加一個許可證，這可能會釋放一個阻塞的acquire方法。然而，其實並沒有實際的許可證這個物件，Semaphore只是維持了一個可獲得許可證的數量。 Semaphore經常用於限制獲取某種資源的執行緒數量。

當然一次也可以一次拿取和釋放多個許可，不過一般沒有必要這樣做：

					semaphore.acquire(5);// 獲取5個許可，所以可執行執行緒數量為20/5=4
					test(threadnum);
					semaphore.release(5);// 獲取5個許可，所以可執行執行緒數量為20/5=4

除了 acquire方法之外，另一個比較常用的與之對應的方法是tryAcquire方法，該方法如果獲取不到許可就立即返回false。

Semaphore 有兩種模式，公平模式和非公平模式。

  • 公平模式： 呼叫acquire的順序就是獲取許可證的順序，遵循FIFO；
  • 非公平模式： 搶佔式的。

Semaphore 對應的兩個構造方法如下：

   public Semaphore(int permits) {
        sync = new NonfairSync(permits);
    }

    public Semaphore(int permits, boolean fair) {
        sync = fair ? new FairSync(permits) : new NonfairSync(permits);
    }

這兩個構造方法，都必須提供許可的數量，第二個構造方法可以指定是公平模式還是非公平模式，預設非公平模式。

由於篇幅問題，如果對 Semaphore 原始碼感興趣的朋友可以看下面這篇文章：

4 CountDownLatch （倒計時器）

CountDownLatch是一個同步工具類，用來協調多個執行緒之間的同步。這個工具通常用來控制執行緒等待，它可以讓某一個執行緒等待直到倒計時結束，再開始執行。

4.1 CountDownLatch 的兩種典型用法

①某一執行緒在開始執行前等待n個執行緒執行完畢。將 CountDownLatch 的計數器初始化為n ：new CountDownLatch(n)，每當一個任務執行緒執行完畢，就將計數器減1 countdownlatch.countDown()，當計數器的值變為0時，在CountDownLatch上 await() 的執行緒就會被喚醒。一個典型應用場景就是啟動一個服務時，主執行緒需要等待多個元件載入完畢，之後再繼續執行。

②實現多個執行緒開始執行任務的最大並行性。注意是並行性，不是併發，強調的是多個執行緒在某一時刻同時開始執行。類似於賽跑，將多個執行緒放到起點，等待發令槍響，然後同時開跑。做法是初始化一個共享的 CountDownLatch 物件，將其計數器初始化為 1 ：new CountDownLatch(1)，多個執行緒在開始執行任務前首先 coundownlatch.await()，當主執行緒呼叫 countDown() 時，計數器變為0，多個執行緒同時被喚醒。

4.2 CountDownLatch 的使用示例

/**
 * 
 * @author SnailClimb
 * @date 2018年10月1日
 * @Description: CountDownLatch 使用方法示例
 */
public class CountDownLatchExample1 {
	// 請求的數量
	private static final int threadCount = 550;

	public static void main(String[] args) throws InterruptedException {
		// 建立一個具有固定執行緒數量的執行緒池物件（如果這裡執行緒池的執行緒數量給太少的話你會發現執行的很慢）
		ExecutorService threadPool = Executors.newFixedThreadPool(300);
		final CountDownLatch countDownLatch = new CountDownLatch(threadCount);
		for (int i = 0; i < threadCount; i++) {
			final int threadnum = i;
			threadPool.execute(() -> {// Lambda 表示式的運用
				try {
					test(threadnum);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				} finally {
					countDownLatch.countDown();// 表示一個請求已經被完成
				}

			});
		}
		countDownLatch.await();
		threadPool.shutdown();
		System.out.println("finish");
	}

	public static void test(int threadnum) throws InterruptedException {
		Thread.sleep(1000);// 模擬請求的耗時操作
		System.out.println("threadnum:" + threadnum);
		Thread.sleep(1000);// 模擬請求的耗時操作
	}
}

上面的程式碼中，我們定義了請求的數量為550，當這550個請求被處理完成之後，才會執行System.out.println("finish");。

4.3 CountDownLatch 的不足

CountDownLatch是一次性的，計數器的值只能在構造方法中初始化一次，之後沒有任何機制再次對其設定值，當CountDownLatch使用完畢後，它不能再次被使用。

5 CyclicBarrier(迴圈柵欄)

CyclicBarrier 和 CountDownLatch 非常類似，它也可以實現執行緒間的技術等待，但是它的功能比 CountDownLatch 更加複雜和強大。主要應用場景和 CountDownLatch 類似。

CyclicBarrier 的字面意思是可迴圈使用（Cyclic）的屏障（Barrier）。它要做的事情是，讓一組執行緒到達一個屏障（也可以叫同步點）時被阻塞，直到最後一個執行緒到達屏障時，屏障才會開門，所有被屏障攔截的執行緒才會繼續幹活。CyclicBarrier預設的構造方法是 CyclicBarrier(int parties)，其引數表示屏障攔截的執行緒數量，每個執行緒呼叫await方法告訴 CyclicBarrier 我已經到達了屏障，然後當前執行緒被阻塞。

5.1 CyclicBarrier 的應用場景

CyclicBarrier 可以用於多執行緒計算資料，最後合併計算結果的應用場景。比如我們用一個Excel儲存了使用者所有銀行流水，每個Sheet儲存一個帳戶近一年的每筆銀行流水，現在需要統計使用者的日均銀行流水，先用多執行緒處理每個sheet裡的銀行流水，都執行完之後，得到每個sheet的日均銀行流水，最後，再用barrierAction用這些執行緒的計算結果，計算出整個Excel的日均銀行流水。

5.2 CyclicBarrier 的使用示例

示例1：

/**
 * 
 * @author Snailclimb
 * @date 2018年10月1日
 * @Description: 測試 CyclicBarrier 類中帶引數的 await() 方法
 */
public class CyclicBarrierExample2 {
	// 請求的數量
	private static final int threadCount = 550;
	// 需要同步的執行緒數量
	private static final CyclicBarrier cyclicBarrier = new CyclicBarrier(5);

	public static void main(String[] args) throws InterruptedException {
		// 建立執行緒池
		ExecutorService threadPool = Executors.newFixedThreadPool(10);

		for (int i = 0; i < threadCount; i++) {
			final int threadNum = i;
			Thread.sleep(1000);
			threadPool.execute(() -> {
				try {
					test(threadNum);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				} catch (BrokenBarrierException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			});
		}
		threadPool.shutdown();
	}

	public static void test(int threadnum) throws InterruptedException, BrokenBarrierException {
		System.out.println("threadnum:" + threadnum + "is ready");
		try {
			cyclicBarrier.await(2000, TimeUnit.MILLISECONDS);
		} catch (Exception e) {
			System.out.println("-----CyclicBarrierException------");
		}
		System.out.println("threadnum:" + threadnum + "is finish");
	}

}

執行結果，如下：

threadnum:0is ready
threadnum:1is ready
threadnum:2is ready
threadnum:3is ready
threadnum:4is ready
threadnum:4is finish
threadnum:0is finish
threadnum:1is finish
threadnum:2is finish
threadnum:3is finish
threadnum:5is ready
threadnum:6is ready
threadnum:7is ready
threadnum:8is ready
threadnum:9is ready
threadnum:9is finish
threadnum:5is finish
threadnum:8is finish
threadnum:7is finish
threadnum:6is finish
......

可以看到當執行緒數量也就是請求數量達到我們定義的 5 個的時候， await方法之後的方法才被執行。

另外，CyclicBarrier還提供一個更高階的建構函式CyclicBarrier(int parties, Runnable barrierAction)，用於線上程到達屏障時，優先執行barrierAction，方便處理更復雜的業務場景。示例程式碼如下：

/**
 * 
 * @author SnailClimb
 * @date 2018年10月1日
 * @Description: 新建 CyclicBarrier 的時候指定一個 Runnable
 */
public class CyclicBarrierExample3 {
	// 請求的數量
	private static final int threadCount = 550;
	// 需要同步的執行緒數量
	private static final CyclicBarrier cyclicBarrier = new CyclicBarrier(5, () -> {
		System.out.println("------當執行緒數達到之後，優先執行------");
	});

	public static void main(String[] args) throws InterruptedException {
		// 建立執行緒池
		ExecutorService threadPool = Executors.newFixedThreadPool(10);

		for (int i = 0; i < threadCount; i++) {
			final int threadNum = i;
			Thread.sleep(1000);
			threadPool.execute(() -> {
				try {
					test(threadNum);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				} catch (BrokenBarrierException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			});
		}
		threadPool.shutdown();
	}

	public static void test(int threadnum) throws InterruptedException, BrokenBarrierException {
		System.out.println("threadnum:" + threadnum + "is ready");
		cyclicBarrier.await();
		System.out.println("threadnum:" + threadnum + "is finish");
	}

}

執行結果，如下：

threadnum:0is ready
threadnum:1is ready
threadnum:2is ready
threadnum:3is ready
threadnum:4is ready
------當執行緒數達到之後，優先執行------
threadnum:4is finish
threadnum:0is finish
threadnum:2is finish
threadnum:1is finish
threadnum:3is finish
threadnum:5is ready
threadnum:6is ready
threadnum:7is ready
threadnum:8is ready
threadnum:9is ready
------當執行緒數達到之後，優先執行------
threadnum:9is finish
threadnum:5is finish
threadnum:6is finish
threadnum:8is finish
threadnum:7is finish
......

5.3 CyclicBarrier和CountDownLatch的區別

CountDownLatch是計數器，只能使用一次，而CyclicBarrier的計數器提供reset功能，可以多次使用。但是我不那麼認為它們之間的區別僅僅就是這麼簡單的一點。我們來從jdk作者設計的目的來看，javadoc是這麼描述它們的：

CountDownLatch: A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.(CountDownLatch: 一個或者多個執行緒，等待其他多個執行緒完成某件事情之後才能執行；)
CyclicBarrier : A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.(CyclicBarrier : 多個執行緒互相等待，直到到達同一個同步點，再繼續一起執行。)

對於CountDownLatch來說，重點是“一個執行緒（多個執行緒）等待”，而其他的N個執行緒在完成“某件事情”之後，可以終止，也可以等待。而對於CyclicBarrier，重點是多個執行緒，在任意一個執行緒沒有完成，所有的執行緒都必須等待。

CountDownLatch是計數器，執行緒完成一個記錄一個，只不過計數不是遞增而是遞減，而CyclicBarrier更像是一個閥門，需要所有執行緒都到達，閥門才能開啟，然後繼續執行。

CyclicBarrier和CountDownLatch的區別

CyclicBarrier和CountDownLatch的區別這部分內容參考瞭如下兩篇文章：

6 ReentrantLock 和 ReentrantReadWriteLock

ReentrantLock 和 synchronized 的區別在上面已經講過了這裡就不多做講解。另外，需要注意的是：讀寫鎖 ReentrantReadWriteLock 可以保證多個執行緒可以同時讀，所以在讀操作遠大於寫操作的時候，讀寫鎖就非常有用了。

由於篇幅問題，關於 ReentrantLock 和 ReentrantReadWriteLock 詳細內容可以檢視我的這篇原創文章。

相關推薦

Java多執行緒學習（十）：AQS 原理以及 AQS 同步元件總結

常見問題：AQS 原理？;CountDownLatch和CyclicBarrier瞭解嗎,兩者的區別是什麼？用過Semaphore嗎？ 本節思維導圖： 阿里雲產品 1888 代金券領取:https://promotion.aliyun.com/ntms

Java多執行緒學習（九）JUC 中的 Atomic 原子類總結

阿里雲產品 1888 代金券領取:https://promotion.aliyun.com/ntms/yunparter/invite.html?userCode=hf47liqn 本節思維導圖: 1 Atomic 原子類介紹 Atomic 翻譯成中文是原

多執行緒學習（4）：三種實現Java多執行緒的方法：Thread、Callable和Runable 的比較與區別

2018年10月03日 目錄 前言 前言 JVM允許應用程式併發執行多執行緒：最常用的是兩個方法：（1）基礎Thread類，重寫run（）方法；（2）或實現Runnable 介面，實現介面的run（）方法；（3）另外一種方法是：實現callable 介面

Java多執行緒學習（一）Java多執行緒入門

Java 併發的基礎知識，可能會在筆試中遇到，技術面試中也可能以併發知識環節提問的第一個問題出現。比如面試官可能會問你：“談談自己對於程序和執行緒的理解，兩者的區別是什麼？” 一 程序和多執行緒簡介 1.1 程序和執行緒 程序和執行緒的對比這一知識點

Java多執行緒學習（1）——停止執行緒

目錄： 1.interrupt方法學習（基礎知識） 2.異常法 3.sleep法 4.return法 5.stop法（不推薦） 1.interrupt方法學習（基礎知識） 呼叫interrupt方法只是對執行緒做了一個標記（停止標記），並沒有停止執行緒的效果，需要結合以下

Java 多執行緒基礎（十）interrupt()和執行緒終止方式

Java 多執行緒基礎（十）interrupt()和執行緒終止方式 一、interrupt() 介紹 interrupt() 定義在 Thread 類中，作用是中斷本執行緒。 本執行緒中斷自己是被允許的；其它執行緒呼叫本執行緒的 interrupt() 方法時，會通過 checkAccess() 檢查許可權。

java多執行緒系列（一）：Thread、Runnable、Callable實現多執行緒的區別

實現多執行緒 java實現多執行緒的方法有三種，分別是繼承thread類，實現runnable介面，實現callable介面（call方法有返回值） /** * 繼承Thread */ public class MyThread extends Thread{ int a = 0;

多執行緒學習（5）：synchronized 的基礎使用

2018年10月03日 目錄 前言 前言 java中已經有了內建鎖：synchronized，synchronized的特點是使用簡單，一切交給JVM去處理，不需要顯示釋放； j

多執行緒學習（四）：停止執行緒

停止執行緒 停止一個執行緒可以使用Thread.stop()方法，但最好不用它，因為這個方法是不安全的，而且已被棄用。 大多數停止一個執行緒的操作使用Thread.interrupt()方法，但是這個方法不會終止一個正在執行的執行緒，還需要加入一個判斷才可以完成執行緒的停止。 Jav

多執行緒學習（三）：isAlive()和sleep()和getId()

isAlive() isAlive()判斷執行緒是否處於活動狀態，即執行緒已經啟動但尚未終止。 例一 public class MyThread extends Thread{ @Override public void run() { System.out.prin

多執行緒學習（二）：執行緒間的資料共享

資料不共享的情況 public class MyThread04 extends Thread{ private int count=5; public MyThread04(String threadName) { this.setName(threadName); }

多執行緒學習（一）：多執行緒的兩種實現方式

程序和執行緒 程序是受作業系統管理的基本執行單元。 執行緒是在程序中獨立執行的子任務。 多執行緒的優點 使用多執行緒技術後，可以在同一時間內執行更多不同種類的任務。 單執行緒是同步執行任務，多執行緒是非同步執行任務。 多執行緒的使用方式 1：繼承Thread 2：實現

JAVA多執行緒入門（二）：JAVA中如何寫多執行緒

第一種方式：繼承Thread 步驟： 1.建立執行緒類，繼承自Thread + 重寫run，run中寫執行緒體，執行緒體就是mian()函式裡面的寫法 2.使用執行緒： 2.1 建立執行緒物件 2.2 執行緒物件.start() 步驟展示： 1. public

java 多執行緒學習（Java中Thread 和 Runnable的區別）

今天剛學習java多執行緒 在網上查了幾篇博文學習，個人覺得寫的不錯，但是有的地方有個疑問：Java中Thread 和 Runnable的區別。 然後，在網上查詢相關資料，發現幾乎都是一樣的。 下面貼出相關的程式碼： 如果一個類繼承Thread，則不適合資源共享。但是如果實現了

Java多執行緒學習（基礎篇）

1. java對執行緒的支援 java對執行緒的支援主要體現在Thread類以及Runable介面上，他們都位於java.lang包下，無論是Thread類還是Runable介面，它們都有public void run()方法，這個run方法為我們提供了執行緒實際工作時的程式碼，換句

Java多執行緒學習（吐血超詳細總結）

        寫在前面的話：此文只能說是java多執行緒的一個入門，其實Java裡頭執行緒完全可以寫一本書了，但是如果最基本的你都學掌握好，又怎麼能更上一個臺階呢？如果你覺得此文很簡單，那推薦你看看Java併發包的的執行緒池（Java併發程式設計與技術內幕:執行緒池深入理解

多執行緒的使用，Java多執行緒學習（吐血超詳細總結）

多執行緒的使用 首先講一下程序和執行緒的區別： 　　　　程序：每個程序都有獨立的程式碼和資料空間（程序上下文），程序間的切換會有較大的開銷，一個程序包含1--n個執行緒。 　　　　執行緒：同一類執行緒共享程式碼和資料空間，每個執行緒有獨立的執行棧和程式計數器(PC)，執行緒切換開銷小。

Java多執行緒學習（超詳細總結）

目錄(?)[-]      本文主要講了java中多執行緒的使用方法、執行緒同步、執行緒資料傳遞、執行緒狀態及相應的一些執行緒函式用法、概述等。 首先講一下程序和執行緒的區別： 　　程序：每個程序都有獨立的程式碼和資料空間（程序上下文），程序間的切換會有較大的

Java 多執行緒基礎（十一）執行緒優先順序和守護執行緒

 Java 多執行緒基礎（十一）執行緒優先順序和守護執行緒 一、執行緒優先順序 Java 提供了一個執行緒排程器來監控程式啟動後進去就緒狀態的所有執行緒。執行緒排程器通過執行緒的優先順序來決定排程哪些執行緒執行。一般來說，Java的執行緒排程器採用時間片輪轉演算法使多個執行緒輪轉獲得CPU的時間片。

多執行緒學習（1）

優點：多程序，多執行緒可以讓程式不被阻塞.可以充分利用多核cpu的優勢，提高執行效率 建立方式：   （1）通過繼承Thread類，並重寫其中的run方法來出建立 Thread t = new Thread() { public void run() { // 執行 //