JUC学习笔记及拓展
Java JUC
1 Java JUC簡(jiǎn)介
在 Java 5.0 提供了 java.util.concurrent （簡(jiǎn)稱 JUC ）包，在此包中增加了在并發(fā)編程中很常用 的實(shí)用工具類，用于定義類似于線程的自定義子 系統(tǒng)，包括線程池、異步 IO 和輕量級(jí)任務(wù)框架。 提供可調(diào)的、靈活的線程池。還提供了設(shè)計(jì)用于多線程上下文中的 Collection 實(shí)現(xiàn)等。
2 volatile 關(guān)鍵字-內(nèi)存可見性
2.1 內(nèi)存可見性
Java 內(nèi)存模型規(guī)定，對(duì)于多個(gè)線程共享的變量，存儲(chǔ)在主內(nèi)存當(dāng)中，每個(gè)線程都有自己獨(dú)立的工作內(nèi)存，并且線程只能訪問(wèn)自己的工作內(nèi)存，不可以訪問(wèn)其它線程的工作內(nèi)存。工作內(nèi)存中保存了主內(nèi)存中共享變量的副本，線程要操作這些共享變量，只能通過(guò)操作工作內(nèi)存中的副本來(lái)實(shí)現(xiàn)，操作完畢之后再同步回到主內(nèi)存當(dāng)中，其 JVM 模型大致如下圖。
內(nèi)存可見性問(wèn)題是，當(dāng)多個(gè)線程操作共享數(shù)據(jù)時(shí)，彼此不可見。
JVM 模型規(guī)定：1) 線程對(duì)共享變量的所有操作必須在自己的內(nèi)存中進(jìn)行，不能直接從主內(nèi)存中讀寫; 2) 不同線程之間無(wú)法直接訪問(wèn)其它線程工作內(nèi)存中的變量，線程間變量值的傳遞需要通過(guò)主內(nèi)存來(lái)完成。這樣的規(guī)定可能導(dǎo)致得到后果是：線程對(duì)共享變量的修改沒(méi)有即時(shí)更新到主內(nèi)存，或者線程沒(méi)能夠即時(shí)將共享變量的最新值同步到工作內(nèi)存中，從而使得線程在使用共享變量的值時(shí)，該值并不是最新的。這就引出了內(nèi)存可見性。
內(nèi)存可見性（Memory Visibility）是指當(dāng)某個(gè)線程正在使用對(duì)象狀態(tài)，而另一個(gè)線程在同時(shí)修改該狀態(tài)，需要確保當(dāng)一個(gè)線程修改了對(duì)象狀態(tài)后，其他線程能夠看到發(fā)生的狀態(tài)變化。
可見性錯(cuò)誤是指當(dāng)讀操作與寫操作在不同的線程中執(zhí)行時(shí)，我們無(wú)法確保執(zhí)行讀操作的線程能適時(shí)地看到其他線程寫入的值，有時(shí)甚至是根本不可能的事情。
public class TestVolatile {public static void main(String[] args) {ThreadDemo td = new ThreadDemo();new Thread(td).start();while(true){if(td.isFlag()){System.out.println("------------------");break;}}} }class ThreadDemo implements Runnable {private boolean flag = false;@Overridepublic void run() {try {Thread.sleep(200);} catch (InterruptedException e) {}flag = true;System.out.println("flag=" + isFlag());}public boolean isFlag() {return flag;}public void setFlag(boolean flag) {this.flag = flag;} } //輸出： //flag=true2.2 volatile 關(guān)鍵字
Java 提供了一種稍弱的同步機(jī)制，即 volatile 變量，用來(lái)確保將變量的更新操作通知到其它線程。當(dāng)把共享變量聲明為 volatile 類型后，線程對(duì)該變量修改時(shí)會(huì)將該變量的值立即刷新回主內(nèi)存，同時(shí)會(huì)使其它線程中緩存的該變量無(wú)效，從而其它線程在讀取該值時(shí)會(huì)從主內(nèi)中重新讀取該值（參考緩存一致性）。因此在讀取 volatile 類型的變量時(shí)總是會(huì)返回最新寫入的值。
volatile屏蔽掉了JVM中必要的代碼優(yōu)化(指令重排序)，所以在效率上比較低
//如果設(shè)置為 private volatile boolean flag = false; //輸出結(jié)果： flag=true ------------------volatile關(guān)鍵字最主要的作用是：
可以將 volatile 看做一個(gè)輕量級(jí)的鎖，但是又與 鎖有些不同：
3 原子變量與CAS算法
3.1 原子變量
3.1.1 i++的原子性問(wèn)題
public class TestAtomicDemo {public static void main(String[] args) {AtomicDemo ad = new AtomicDemo();for (int i = 0; i < 10; i++) {new Thread(ad).start();}} } class AtomicDemo implements Runnable{ // private volatile int serialNumber = 0;private AtomicInteger serialNumber = new AtomicInteger(0);@Overridepublic void run() {try {Thread.sleep(200);} catch (InterruptedException e) {}System.out.print(getSerialNumber()+" ");}public int getSerialNumber(){return serialNumber.getAndIncrement();} } //運(yùn)行結(jié)果 //1 3 2 0 4 6 5 7 8 9 ——> 不會(huì)重復(fù) //如果改為： class AtomicDemo implements Runnable{private volatile int serialNumber = 0; // private AtomicInteger serialNumber = new AtomicInteger(0);@Overridepublic void run() {try {Thread.sleep(200);} catch (InterruptedException e) {}System.out.print(getSerialNumber()+" ");}public int getSerialNumber(){return serialNumber++; // return serialNumber.getAndIncrement();} } //運(yùn)行結(jié)果： //0 4 3 2 1 0 5 6 7 8 ——> 會(huì)產(chǎn)生重復(fù)3.1.2 原子變量
實(shí)現(xiàn)全局自增id最簡(jiǎn)單有效的方式是什么？java.util.concurrent.atomic包定義了一些常見類型的原子變量。這些原子變量為我們提供了一種操作單一變量無(wú)鎖(lock-free)的線程安全(thread-safe)方式。
實(shí)際上該包下面的類為我們提供了類似volatile變量的特性，同時(shí)還提供了諸如boolean compareAndSet(expectedValue, updateValue)的功能。
不使用鎖實(shí)現(xiàn)線程安全聽起來(lái)似乎很不可思議，這其實(shí)是通過(guò)CPU的compare and swap指令實(shí)現(xiàn)的，由于硬件指令支持當(dāng)然不需要加鎖了。
核心方法：boolean compareAndSet(expectedValue, updateValue)
-
原子變量類的命名類似于AtomicXxx，例如，AtomicInteger類用于表示一個(gè)int變量。
-
標(biāo)量原子變量類
AtomicInteger，AtomicLong和AtomicBoolean類分別支持對(duì)原始數(shù)據(jù)類型int，long和boolean的操作。
當(dāng)引用變量需要以原子方式更新時(shí)，AtomicReference類用于處理引用數(shù)據(jù)類型。
-
原子數(shù)組類
有三個(gè)類稱為AtomicIntegerArray，AtomicLongArray和AtomicReferenceArray，它們表示一個(gè)int，long和引用類型的數(shù)組，其元素可以進(jìn)行原子性更新。
3.2 CAS算法
-
Compare And Swap (Compare And Exchange) / 自旋 / 自旋鎖 / 無(wú)鎖
-
CAS 是一種硬件對(duì)并發(fā)的支持，針對(duì)多處理器操作而設(shè)計(jì)的處理器中的一種特殊指令，用于管理對(duì)共享數(shù)據(jù)的并發(fā)訪問(wèn)。
-
CAS 是一種無(wú)鎖的非阻塞算法的實(shí)現(xiàn)。
-
CAS 包含了 3 個(gè)操作數(shù)：
- 需要讀寫的內(nèi)存值 V
- 進(jìn)行比較的值 A
- 擬寫入的新值 B
當(dāng)且僅當(dāng) V 的值等于 A 時(shí)，CAS 通過(guò)原子方式用新值 B 來(lái)更新 V的值，否則不會(huì)執(zhí)行任何操作。
3.2.1 ABA問(wèn)題
CAS會(huì)導(dǎo)致ABA問(wèn)題，線程1準(zhǔn)備用CAS將變量的值由A替換為B，在此之前，線程2將變量的值由A替換為C，又由C替換為A，然后線程1執(zhí)行CAS時(shí)發(fā)現(xiàn)變量的值仍然為A，所以CAS成功。但實(shí)際上這時(shí)的現(xiàn)場(chǎng)已經(jīng)和最初不同了，盡管CAS成功，但可能存在潛藏的問(wèn)題。
解決辦法（版本號(hào) AtomicStampedReference），基礎(chǔ)類型簡(jiǎn)單值不需要版本號(hào)
3.2.2 CAS在JAVA中底層的實(shí)現(xiàn)
Unsafe
Unsafe類：Java 與 C/C++ 的一個(gè)非常明顯區(qū)別就是，Java 中不可以直接操作內(nèi)存。當(dāng)然這并不完全正確，因?yàn)?Unsafe 就可以做到。
Unsafe在AtomicInteger中的應(yīng)用:
class AtomicDemo implements Runnable{private AtomicInteger serialNumber = new AtomicInteger(0);@Overridepublic void run() {try {Thread.sleep(200);} catch (InterruptedException e) {}System.out.print(getSerialNumber()+" ");}public int getSerialNumber(){return serialNumber.incrementAndGet();} } public final int incrementAndGet() {for (;;) {int current = get();int next = current + 1;if (compareAndSet(current, next))return next;}}public final boolean compareAndSet(int expect, int update) {return unsafe.compareAndSwapInt(this, valueOffset, expect, update);}Unsafe:
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);運(yùn)用：
package com.mashibing.jol;import sun.misc.Unsafe;import java.lang.reflect.Field;public class T02_TestUnsafe {int i = 0;private static T02_TestUnsafe t = new T02_TestUnsafe();public static void main(String[] args) throws Exception {//Unsafe unsafe = Unsafe.getUnsafe();Field unsafeField = Unsafe.class.getDeclaredFields()[0];unsafeField.setAccessible(true);Unsafe unsafe = (Unsafe) unsafeField.get(null);Field f = T02_TestUnsafe.class.getDeclaredField("i");long offset = unsafe.objectFieldOffset(f);System.out.println(offset);boolean success = unsafe.compareAndSwapInt(t, offset, 0, 1);System.out.println(success);System.out.println(t.i);//unsafe.compareAndSwapInt()} }jdk8u: unsafe.cpp:
cmpxchg = compare and exchange
UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x))UnsafeWrapper("Unsafe_CompareAndSwapInt");oop p = JNIHandles::resolve(obj);jint* addr = (jint *) index_oop_from_field_offset_long(p, offset);return (jint)(Atomic::cmpxchg(x, addr, e)) == e; UNSAFE_ENDjdk8u: atomic_linux_x86.inline.hpp
is_MP = Multi Processor
inline jint Atomic::cmpxchg (jint exchange_value, volatile jint* dest, jint compare_value) {int mp = os::is_MP();__asm__ volatile (LOCK_IF_MP(%4) "cmpxchgl %1,(%3)": "=a" (exchange_value): "r" (exchange_value), "a" (compare_value), "r" (dest), "r" (mp): "cc", "memory");return exchange_value; }jdk8u: os.hpp is_MP()
static inline bool is_MP() {// During bootstrap if _processor_count is not yet initialized// we claim to be MP as that is safest. If any platform has a// stub generator that might be triggered in this phase and for// which being declared MP when in fact not, is a problem - then// the bootstrap routine for the stub generator needs to check// the processor count directly and leave the bootstrap routine// in place until called after initialization has ocurred.return (_processor_count != 1) || AssumeMP;}jdk8u: atomic_linux_x86.inline.hpp
#define LOCK_IF_MP(mp) "cmp $0, " #mp "; je 1f; lock; 1: "最終實(shí)現(xiàn)：
cmpxchg = cas修改變量值
lock cmpxchg 指令 //記住這條指令cmpxchg不能保證原子性，lock保證了原子性（當(dāng)執(zhí)行cmpxchg指令時(shí)，其他CPU不允許對(duì)里面的值進(jìn)行修改）。
硬件：
lock指令在執(zhí)行后面指令的時(shí)候鎖定一個(gè)北橋信號(hào)（電信號(hào)）
（不采用鎖總線的方式）
CAS在JAVA中底層的實(shí)現(xiàn)是通過(guò) lock cmpxchg來(lái)實(shí)現(xiàn)的
volatile和synchronized的實(shí)現(xiàn)也都跟這條指令有關(guān)
3.3 原子性與可見性區(qū)別
4 ConcurrentHashMap
ConcurrentHashMap 同步容器類是Java 5 增加的一個(gè)線程安全的哈希表。對(duì)于多線程的操作，介于 HashMap 與 Hashtable 之間。內(nèi)部采用“鎖分段” 機(jī)制替代 Hashtable 的獨(dú)占鎖，進(jìn)而提高性能。
4.1 鎖粒度
減小鎖粒度是指縮小鎖定對(duì)象的范圍，從而減小鎖沖突的可能性，從而提高系統(tǒng)的并發(fā)能力。減小鎖粒度是一種削弱多線程鎖競(jìng)爭(zhēng)的有效手段，這種技術(shù)典型的應(yīng)用是 ConcurrentHashMap(高性能的HashMap)類的實(shí)現(xiàn)。對(duì)于 HashMap 而言，最重要的兩個(gè)方法是 get 與 set 方法，如果我們對(duì)整個(gè) HashMap 加鎖，可以得到線程安全的對(duì)象，但是加鎖粒度太大。Segment 的大小也被稱為 ConcurrentHashMap 的并發(fā)度。
4.2 鎖分段
ConcurrentHashMap，它內(nèi)部細(xì)分了若干個(gè)小的 HashMap，稱之為段(Segment)。默認(rèn)情況下 一個(gè) ConcurrentHashMap 被進(jìn)一步細(xì)分為 16 個(gè)段，既就是鎖的并發(fā)度。
如果需要在 ConcurrentHashMap 中添加一個(gè)新的表項(xiàng)，并不是將整個(gè) HashMap 加鎖，而是首 先根據(jù) hashcode 得到該表項(xiàng)應(yīng)該存放在哪個(gè)段中，然后對(duì)該段加鎖，并完成 put 操作。在多線程 環(huán)境中，如果多個(gè)線程同時(shí)進(jìn)行put操作，只要被加入的表項(xiàng)不存放在同一個(gè)段中，則線程間可以做到真正的并行。
4.3 其它
此包還提供了設(shè)計(jì)用于多線程上下文中的 Collection 實(shí)現(xiàn)：
ConcurrentHashMap、ConcurrentSkipListMap、ConcurrentSkipListSet、 CopyOnWriteArrayList 和 CopyOnWriteArraySet。
-
當(dāng)期望許多線程訪問(wèn)一個(gè)給定 collection 時(shí)，ConcurrentHashMap 通常優(yōu)于同步的 HashMap， ConcurrentSkipListMap 通常優(yōu)于同步的 TreeMap。
-
當(dāng)期望的讀數(shù)和遍歷遠(yuǎn)遠(yuǎn) 大于列表的更新數(shù)時(shí)，CopyOnWriteArrayList 優(yōu)于同步的 ArrayList。
4.4 寫入并復(fù)制
注意：添加操作多時(shí)，效率低，因?yàn)槊看翁砑訒r(shí)都會(huì)進(jìn)行復(fù)制，開銷非常的大。并發(fā)迭代操作多時(shí)可以選擇。
public class TestCopyOnWriteArrayList {public static void main(String[] args) {HelloThread ht = new HelloThread();for (int i = 0; i < 10; i++) {new Thread(ht).start();}} }class HelloThread implements Runnable{private static List<String> list = Collections.synchronizedList(new ArrayList<String>()); // private static CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();static{list.add("AA");list.add("BB");list.add("CC");}@Overridepublic void run() {Iterator<String> it = list.iterator(); while(it.hasNext()){System.out.println(it.next());list.add("AA");}} }運(yùn)行會(huì)造成并發(fā)修改異常ConcurrentModificationException。遍歷的列表和添加的都是同一個(gè)。
// private static List<String> list = Collections.synchronizedList(new ArrayList<String>());private static CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();這樣不會(huì)報(bào)錯(cuò)，正常運(yùn)行。**因?yàn)樵诿看螌懭霑r(shí)，都會(huì)在底層完成一次復(fù)制，復(fù)制一份新的列表，然后再進(jìn)行添加。每次寫入都會(huì)復(fù)制。**不會(huì)造成并發(fā)修改異常，但是效率較低。
添加操作多時(shí)，效率低，因?yàn)槊看翁砑訒r(shí)都會(huì)進(jìn)行復(fù)制，開銷非常的大。并發(fā)迭代操作多時(shí)可以選擇。
5 CountDownLatch(閉鎖)
5.1 概念
CountDownLatch（閉鎖）——一個(gè)同步輔助類，在完成一組正在其他線程中執(zhí)行的操作之前，它允許一個(gè)或多個(gè)線程一直等待。CountDown（倒數(shù)）latch（鎖）
用給定的計(jì)數(shù) 初始化 CountDownLatch。由于調(diào)用了 countDown() 方法，所以在當(dāng)前計(jì)數(shù)到達(dá)零之前，await 方法會(huì)一直受阻塞。之后，會(huì)釋放所有等待的線程，await 的所有后續(xù)調(diào)用都將立即返回。這種現(xiàn)象只出現(xiàn)一次——計(jì)數(shù)無(wú)法被重置。 一個(gè)線程(或者多個(gè))， 等待另外N個(gè)線程完成某個(gè)事情之后才能執(zhí)行。
閉鎖可以延遲線程的進(jìn)度直到其到達(dá)終止?fàn)顟B(tài)，閉鎖可以用來(lái)確保某些活 動(dòng)直到其他活動(dòng)都完成才繼續(xù)執(zhí)行：
- 確保某個(gè)計(jì)算在其需要的所有資源都被初始化之后才繼續(xù)執(zhí)行;
- 確保某個(gè)服務(wù)在其依賴的所有其他服務(wù)都已經(jīng)啟動(dòng)之后才啟動(dòng);
- 等待直到某個(gè)操作所有參與者都準(zhǔn)備就緒再繼續(xù)執(zhí)行。
5.2 方法介紹
CountDownLatch最重要的方法是countDown()——倒數(shù) 和 await()，前者主要是倒數(shù)一次，后者是等待倒數(shù)到0，如果沒(méi)有到達(dá)0，就只有阻塞等待了。
public class TestCountDownLatch {public static void main(String[] args) {final CountDownLatch latch = new CountDownLatch(50); //每次有個(gè)線程執(zhí)行完-1，設(shè)置初始值50LatchDemo ld = new LatchDemo(latch);long start = System.currentTimeMillis();for (int i = 0; i < 50; i++) {new Thread(ld).start();}try {latch.await(); //50個(gè)線程執(zhí)行完，才繼續(xù)執(zhí)行main線程} catch (InterruptedException e) {}long end = System.currentTimeMillis();System.out.println("耗費(fèi)時(shí)間為：" + (end - start));} }class LatchDemo implements Runnable {private CountDownLatch latch;public LatchDemo(CountDownLatch latch) {this.latch = latch;}@Overridepublic void run() {try {for (int i = 0; i < 50000; i++) {if (i % 2 == 0) {System.out.println(i);}}} finally {latch.countDown(); //每次執(zhí)行完-1，放在finally里確保每次都執(zhí)行}} }6 實(shí)現(xiàn) Callable 接口
Java 5.0 在 java.util.concurrent 提供了一個(gè)新的創(chuàng)建執(zhí)行線程的方式：Callable 接口。
Callable 需要依賴FutureTask ，FutureTask 也可以用作閉 鎖。
6.1 創(chuàng)建線程的四種方式
無(wú)返回：
有返回：
6.2 Callable的使用
public class TestCallable {public static void main(String[] args) {ThreadDemo td = new ThreadDemo();//1.執(zhí)行 Callable 方式，需要 FutureTask 實(shí)現(xiàn)類的支持，用于接收運(yùn)算結(jié)果。FutureTask<Integer> result = new FutureTask<>(td);new Thread(result).start();//2.接收線程運(yùn)算后的結(jié)果try {Integer sum = result.get(); //FutureTask 可用于 閉鎖System.out.println(sum);System.out.println("------------------------------------");} catch (InterruptedException | ExecutionException e) {e.printStackTrace();}} }class ThreadDemo implements Callable<Integer>{@Overridepublic Integer call() throws Exception {int sum = 0;for (int i = 0; i <= 100000; i++) {sum += i;}return sum;} }7 -Lock 同步鎖
在 Java 5.0 之前，協(xié)調(diào)共享對(duì)象的訪問(wèn)時(shí)可以使用的機(jī)制只有 synchronized 和 volatile 。Java 5.0 后增加了一些新的機(jī)制，但并不是一種替代內(nèi)置鎖的方法，而是當(dāng)內(nèi) 置鎖不適用時(shí)，作為一種可選擇的高級(jí)功能。
ReentrantLock 實(shí)現(xiàn)了 Lock 接口，并提供了與 synchronized 相同的互斥性和內(nèi)存可見性。但相較于 synchronized 提供了更高的處理鎖的靈活性。
解決多線程安全問(wèn)題的三種方式
-
jdk 1.5 前：
-
synchronized：隱式鎖
1.同步代碼塊
2.同步方法
-
-
jdk 1.5 后：
-
3.同步鎖 Lock：顯式鎖
注意：是一個(gè)顯示鎖，需要通過(guò) lock() 方法上鎖，必須通過(guò) unlock() 方法進(jìn)行釋放鎖
-
8 Condition 控制線程通信
Condition 接口描述了可能會(huì)與鎖有關(guān)聯(lián)的條件變量。這些變量在用 法上與使用 Object.wait 訪問(wèn)的隱式監(jiān)視器類似，但提供了更強(qiáng)大的功能。需要特別指出的是，單個(gè) Lock 可能與多個(gè) Condition 對(duì)象關(guān)聯(lián)。為了避免兼容性問(wèn)題，Condition 方法的名稱與對(duì)應(yīng)的 Object 版本中的不同。
在 Condition 對(duì)象中，與 wait、notify 和 notifyAll 方法對(duì)應(yīng)的分別是 await、signal 和 signalAll。
Condition 實(shí)例實(shí)質(zhì)上被綁定到一個(gè)鎖上。要為特定 Lock 實(shí)例獲得 Condition 實(shí)例，請(qǐng)使用其 newCondition() 方法。
8.1 使用Condition
使用Condition控制線程通信：
8.2 生產(chǎn)者和消費(fèi)者案例
public class TestProductorAndConsumerForLock {public static void main(String[] args) {Clerk clerk = new Clerk();Productor pro = new Productor(clerk);Consumer con = new Consumer(clerk);new Thread(pro, "生產(chǎn)者 A").start();new Thread(con, "消費(fèi)者 B").start();// new Thread(pro, "生產(chǎn)者 C").start(); // new Thread(con, "消費(fèi)者 D").start();}}class Clerk {private int product = 0;private Lock lock = new ReentrantLock(); //創(chuàng)建lock對(duì)象private Condition condition = lock.newCondition(); //獲得Lock實(shí)例的Condition實(shí)例// 進(jìn)貨public void get() {lock.lock();try {if (product >= 1) { // 為了避免虛假喚醒，應(yīng)該總是使用在循環(huán)中。System.out.println("產(chǎn)品已滿！");try {condition.await();} catch (InterruptedException e) {}}System.out.println(Thread.currentThread().getName() + " : " + ++product);condition.signalAll();} finally {lock.unlock();}}//售貨public void sale() {lock.lock();try {if (product <= 0) {System.out.println("缺貨！");try {condition.await();} catch (InterruptedException e) {}}System.out.println(Thread.currentThread().getName() + " : " + --product);condition.signalAll();} finally {lock.unlock();}} }// 生產(chǎn)者 class Productor implements Runnable {private Clerk clerk;public Productor(Clerk clerk) {this.clerk = clerk;}@Overridepublic void run() {for (int i = 0; i < 20; i++) {try {Thread.sleep(200);} catch (InterruptedException e) {e.printStackTrace();}clerk.get(); //調(diào)用店員進(jìn)貨方法}} }// 消費(fèi)者 class Consumer implements Runnable {private Clerk clerk;public Consumer(Clerk clerk) {this.clerk = clerk;}@Overridepublic void run() {for (int i = 0; i < 20; i++) {clerk.sale(); //調(diào)用店員售貨方法}}}9 線程按序交替
要求：編寫一個(gè)程序，開啟 3 個(gè)線程，這三個(gè)線程的 ID 分別為 A、B、C，每個(gè)線程將自己的 ID 在屏幕上打印 10 遍，要 求輸出的結(jié)果必須按順序顯示。 如：ABCABCABC…… 依次遞歸
public class TestABCAlternate {public static void main(String[] args) {AlternateDemo ad = new AlternateDemo();new Thread(new Runnable() {@Overridepublic void run() {for (int i = 1; i <= 20; i++) {ad.loopA(i);}}}, "A").start();new Thread(new Runnable() {@Overridepublic void run() {for (int i = 1; i <= 20; i++) {ad.loopB(i);}}}, "B").start();new Thread(new Runnable() {@Overridepublic void run() {for (int i = 1; i <= 20; i++) {ad.loopC(i);System.out.println("-----------------------------------");}}}, "C").start();}}class AlternateDemo{private int number = 1; //當(dāng)前正在執(zhí)行線程的標(biāo)記private Lock lock = new ReentrantLock();private Condition condition1 = lock.newCondition();private Condition condition2 = lock.newCondition();private Condition condition3 = lock.newCondition();/*** @param totalLoop : 循環(huán)第幾輪*/public void loopA(int totalLoop){lock.lock();try {//1. 判斷if(number != 1){condition1.await(); //線程A等待}//2. 打印for (int i = 1; i <= 1; i++) {System.out.println(Thread.currentThread().getName() + "\t" + i + "\t" + totalLoop);}//3. 喚醒number = 2;condition2.signal(); //喚醒B線程} catch (Exception e) {e.printStackTrace();} finally {lock.unlock();}}public void loopB(int totalLoop){lock.lock();try {//1. 判斷if(number != 2){condition2.await(); //線程B等待}//2. 打印for (int i = 1; i <= 1; i++) {System.out.println(Thread.currentThread().getName() + "\t" + i + "\t" + totalLoop);}//3. 喚醒number = 3;condition3.signal(); //喚醒C線程} catch (Exception e) {e.printStackTrace();} finally {lock.unlock();}}public void loopC(int totalLoop){lock.lock();try {//1. 判斷if(number != 3){condition3.await(); //C線程等待}//2. 打印for (int i = 1; i <= 1; i++) {System.out.println(Thread.currentThread().getName() + "\t" + i + "\t" + totalLoop);}//3. 喚醒number = 1;condition1.signal(); //喚醒A線程} catch (Exception e) {e.printStackTrace();} finally {lock.unlock();}}}10 ReadWriteLock 讀寫鎖
ReadWriteLock 維護(hù)了一對(duì)相關(guān)的鎖，一個(gè)用于只讀操作， 另一個(gè)用于寫入操作。只要沒(méi)有 writer，讀取鎖可以由多個(gè) reader 線程同時(shí)保持。寫入鎖是獨(dú)占的。
ReadWriteLock 讀取操作通常不會(huì)改變共享資源，但執(zhí)行寫入操作時(shí)，必須獨(dú)占方式來(lái)獲取鎖。對(duì)于讀取操作占多數(shù)的數(shù)據(jù)結(jié)構(gòu)。 ReadWriteLock 能提供比獨(dú)占鎖更高的并發(fā)性。而對(duì)于只讀的數(shù)據(jù)結(jié)構(gòu)，其中包含的不變性 可以完全不需要考慮加鎖操作。
- 寫寫/讀寫 需要“互斥”
- 讀讀 不需要互斥
11 線程8鎖
判斷打印的 “one” or “two” ？
- 兩個(gè)普通同步方法，兩個(gè)線程，標(biāo)準(zhǔn)打印， 打印結(jié)果?
- 新增 Thread.sleep() 給 getOne()，打印結(jié)果?
- 新增普通方法 getThree() , 打印結(jié)果?
- 兩個(gè)普通同步方法，兩個(gè) Number 對(duì)象，打印結(jié)果?
- 修改 getOne() 為靜態(tài)同步方法，打印結(jié)果?
- 修改兩個(gè)方法均為靜態(tài)同步方法，一個(gè) Number 對(duì)象，打印結(jié)果?
- 一個(gè)靜態(tài)同步方法，一個(gè)非靜態(tài)同步方法，兩個(gè) Number 對(duì)象，打印結(jié)果?
- 兩個(gè)靜態(tài)同步方法，兩個(gè) Number 對(duì)象，打印結(jié)果?
要想知道上面線程8鎖的答案，需要知曉關(guān)鍵所在：
- ① 非靜態(tài)方法的鎖默認(rèn)為 this（實(shí)例對(duì)象）, 靜態(tài)方法的鎖為對(duì)應(yīng)的 Class 對(duì)象（類對(duì)象）。
- ② 某一個(gè)時(shí)刻，同一個(gè)對(duì)象，只能有一個(gè)線程持有鎖，無(wú)論幾個(gè)方法。
- ③ 鎖靜態(tài)方法，某一個(gè)時(shí)刻，不同實(shí)例對(duì)象也只能有一個(gè)對(duì)象持有鎖。
答案：
12 線程池
12.1 線程池介紹
第四種獲取線程的方法：線程池。線程池提供了一個(gè)線程隊(duì)列，隊(duì)列中保存著所有等待狀態(tài)的線程。避免了創(chuàng)建與銷毀額外開銷，提高了響應(yīng)的速度。通常使用 Executors 工廠方法配置。
線程池可以解決兩個(gè)不同問(wèn)題：由于減少了每個(gè)任務(wù)調(diào)用的開銷，它們通常可以在執(zhí)行大量異步任務(wù)時(shí)提供增強(qiáng)的性能，并且還可以提供綁定和管理資源（包括執(zhí)行任務(wù)集時(shí)使用的線程）的方法。
12.2 線程池的體系結(jié)構(gòu)
/** java.util.concurrent.Executor : 負(fù)責(zé)線程的使用與調(diào)度的根接口* |--ExecutorService 子接口: 線程池的主要接口* |--ThreadPoolExecutor 線程池的實(shí)現(xiàn)類* |--ScheduledExecutorService 子接口：負(fù)責(zé)線程的調(diào)度* |--ScheduledThreadPoolExecutor ：繼承 ThreadPoolExecutor， 實(shí)現(xiàn) ScheduledExecutorService*/12.3 工具類 : Executors
為了便于跨大量上下文使用，此類提供了很多可調(diào)整的參數(shù)和擴(kuò)展鉤子 (hook)。但是，強(qiáng)烈建議程序員使用較為方便的 Executors 工廠方法 ：
-
Executors newCachedThreadPool()（緩存線程池，線程池的數(shù)量不固定，可以根據(jù)需求自動(dòng)的更改數(shù)量，可以進(jìn)行自動(dòng)線程回收）
-
Executors newFixedThreadPool(int)（創(chuàng)建固定大小的線程池）
-
Executors newSingleThreadExecutor()（線程池中只有一個(gè)線程）
-
ScheduledExecutorService newScheduledThreadPool() : 創(chuàng)建固定大小的線程，可以延遲或定時(shí)的執(zhí)行任務(wù)。
12.4 線程調(diào)度
- ScheduledExecutorService newScheduledThreadPool() : 創(chuàng)建固定大小的線程，可以延遲或定時(shí)的執(zhí)行任務(wù)。
13 ForkJoinPool 分支/合并框架 工作竊取
13.1 Fork/Join 框架
Fork/Join 框架：就是在必要的情況下，將一個(gè)大任務(wù)，進(jìn)行拆分(fork)成 若干個(gè)小任務(wù)（拆到不可再拆時(shí)），再將一個(gè)個(gè)的小任務(wù)運(yùn)算的結(jié)果進(jìn) 行 join 匯總。
13.2 Fork/Join 框架與線程池的區(qū)別
采用 “工作竊取”模式（work-stealing）：
當(dāng)執(zhí)行新的任務(wù)時(shí)它可以將其拆分分成更小的任務(wù)執(zhí)行，并將小任務(wù)加到線程隊(duì)列中，然后再從一個(gè)隨機(jī)線程的隊(duì)列中偷一個(gè)并把它放在自己的隊(duì)列中。
相對(duì)于一般的線程池實(shí)現(xiàn)，fork/join框架的優(yōu)勢(shì)體現(xiàn)在對(duì)其中包含的任務(wù)的處理方式上。在一般的線程池中，如果一個(gè)線程正在執(zhí)行的任務(wù)由于某些原因無(wú)法繼續(xù)運(yùn)行，那么該線程會(huì)處于等待狀態(tài)。而在fork/join框架實(shí)現(xiàn)中， 如果某個(gè)子問(wèn)題由于等待另外一個(gè)子問(wèn)題的完成而無(wú)法繼續(xù)運(yùn)行。那么處理該子問(wèn)題的線程會(huì)主動(dòng)尋找其他尚未運(yùn)行的子問(wèn)題來(lái)執(zhí)行。這種方式減少了 線程的等待時(shí)間，提高了性能。
public class TestForkJoinPool {public static void main(String[] args) {Instant start = Instant.now();ForkJoinPool pool = new ForkJoinPool();ForkJoinTask<Long> task = new ForkJoinSumCalculate(0L, 5000000000L);Long sum = pool.invoke(task);System.out.println(sum);Instant end = Instant.now();System.out.println("耗費(fèi)時(shí)間為：" + Duration.between(start, end).toMillis());//2709 拆分也需要時(shí)間}@Testpublic void test1(){Instant start = Instant.now();long sum = 0L;for (long i = 0L; i <= 5000000000L; i++) {sum += i;}System.out.println(sum);Instant end = Instant.now();System.out.println("for耗費(fèi)時(shí)間為：" + Duration.between(start, end).toMillis());//2057}//java8 新特性@Testpublic void test2(){Instant start = Instant.now();Long sum = LongStream.rangeClosed(0L, 5000000000L).parallel().reduce(0L, Long::sum);System.out.println(sum);Instant end = Instant.now();System.out.println("java8 新特性耗費(fèi)時(shí)間為：" + Duration.between(start, end).toMillis());//1607} }class ForkJoinSumCalculate extends RecursiveTask<Long>{/*** */private static final long serialVersionUID = -259195479995561737L;private long start;private long end;private static final long THURSHOLD = 10000L; //臨界值public ForkJoinSumCalculate(long start, long end) {this.start = start;this.end = end;}@Overrideprotected Long compute() {long length = end - start;if(length <= THURSHOLD){long sum = 0L;for (long i = start; i <= end; i++) {sum += i;}return sum;}else{long middle = (start + end) / 2;ForkJoinSumCalculate left = new ForkJoinSumCalculate(start, middle); left.fork(); //進(jìn)行拆分，同時(shí)壓入線程隊(duì)列ForkJoinSumCalculate right = new ForkJoinSumCalculate(middle+1, end);right.fork(); //進(jìn)行拆分，同時(shí)壓入線程隊(duì)列return left.join() + right.join();}}}總結(jié)
以上是生活随笔為你收集整理的JUC学习笔记及拓展的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問(wèn)題。
