![Java中有哪些無鎖技術來解決併發問題?如何使用?](http://p2.ttnews.xyz/loading.gif)
除了使用 synchronized、Lock 加鎖之外,Java 中還有很多不需要加鎖就可以解決併發問題的工具類
一、原子工具類
JDK 1.8 中,java.util.concurrent.atomic 包下類都是原子類,原子類都是基於 sun.misc.Unsafe 實現的。
- CPU 為了解決併發問題,提供了 CAS 指令,全稱 Compare And Swap,即比較並交互
- CAS 指令需要 3 個參數,變量、比較值、新值。當變量的當前值與比較值相等時,才把變量更新為新值
- CAS 是一條 CPU 指令,由 CPU 硬件級別上保證原子性
- java.util.concurrent.atomic 包中的原子分為:原子性基本數據類型、原子性對象引用類型、原子性數組、原子性對象屬性更新器和原子性累加器
原子性基本數據類型:AtomicBoolean、AtomicInteger、AtomicLong
原子性對象引用類型:AtomicReference、AtomicStampedReference、AtomicMarkableReference
原子性數組 :AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray
原子性對象屬性更新:AtomicIntegerFieldUpdater、AtomicLongFieldUpdater、AtomicReferenceFieldUpdater
原子性累加器:DoubleAccumulator、DoubleAdder、LongAccumulator、LongAdder
修改我們之前測試原子性問題的類,使用 AtomicInteger 的簡單例子
package constxiong.concurrency.a026;
import java.util.concurrent.atomic.AtomicInteger;
/**
* 測試 原子類 AtomicInteger
*
* @author ConstXiong
*/
public class TestAtomicInteger {
// 計數變量
static volatile AtomicInteger count = new AtomicInteger(0);
public static void main(String[] args) throws InterruptedException {
// 線程 1 給 count 加 10000
Thread t1 = new Thread(() -> {
for (int j = 0; j <10000; j++) {
count.incrementAndGet();
}
System.out.println("thread t1 count 加 10000 結束");
});
// 線程 2 給 count 加 10000
Thread t2 = new Thread(() -> {
for (int j = 0; j <10000; j++) {
count.incrementAndGet();
}
System.out.println("thread t2 count 加 10000 結束");
});
// 啟動線程 1
t1.start();
// 啟動線程 2
t2.start();
// 等待線程 1 執行完成
t1.join();
// 等待線程 2 執行完成
t2.join();
// 打印 count 變量
System.out.println(count.get());
}
}
打印結果如預期
thread t2 count 加 10000 結束
thread t1 count 加 10000 結束
20000
![Java中有哪些無鎖技術來解決併發問題?如何使用?](http://p2.ttnews.xyz/loading.gif)
二、線程本地存儲
- java.lang.ThreadLocal 類用於線程本地化存儲。
- 線程本地化存儲,就是為每一個線程創建一個變量,只有本線程可以在該變量中查看和修改值。
- 典型的使用例子就是,spring 在處理數據庫事務問題的時候,就用了 ThreadLocal 為每個線程存儲了各自的數據庫連接 Connection。
- 使用 ThreadLocal 要注意,在不使用該變量的時候,一定要調用 remove() 方法移除變量,否則可能造成內存洩漏的問題。
示例
package constxiong.concurrency.a026;
/**
* 測試 原子類 AtomicInteger
*
* @author ConstXiong
*/
public class TestThreadLocal {
// 線程本地存儲變量
private static final ThreadLocal<integer> THREAD_LOCAL_NUM = new ThreadLocal<integer>() {
@Override
protected Integer initialValue() {//初始值
return 0;
}
};
public static void main(String[] args) {
for (int i = 0; i <3; i++) {// 啟動三個線程
Thread t = new Thread() {
@Override
public void run() {
add10ByThreadLocal();
}
};
t.start();
}
}
/**
* 線程本地存儲變量加 5
*/
private static void add10ByThreadLocal() {
try {
for (int i = 0; i <5; i++) {
Integer n = THREAD_LOCAL_NUM.get();
n += 1;
THREAD_LOCAL_NUM.set(n);
System.out.println(Thread.currentThread().getName() + " : ThreadLocal num=" + n);
}
} finally {
THREAD_LOCAL_NUM.remove();// 將變量移除
}
}
}
/<integer>/<integer>
每個線程最後一個值都打印到了 5
Thread-0 : ThreadLocal num=1
Thread-2 : ThreadLocal num=1
Thread-1 : ThreadLocal num=1
Thread-2 : ThreadLocal num=2
Thread-0 : ThreadLocal num=2
Thread-2 : ThreadLocal num=3
Thread-0 : ThreadLocal num=3
Thread-1 : ThreadLocal num=2
Thread-0 : ThreadLocal num=4
Thread-2 : ThreadLocal num=4
Thread-0 : ThreadLocal num=5
Thread-1 : ThreadLocal num=3
Thread-2 : ThreadLocal num=5
Thread-1 : ThreadLocal num=4
Thread-1 : ThreadLocal num=5
三、copy-on-write
- 根據英文名稱可以看出,需要寫時複製,體現的是一種延時策略。
- Java 中的 copy-on-write 容器包括:CopyOnWriteArrayList、CopyOnWriteArraySet。
- 涉及到數組的全量複製,所以也比較耗內存,在寫少的情況下使用比較適合。
簡單的 CopyOnWriteArrayList 的示例,這裡只是說明 CopyOnWriteArrayList 怎麼用,並且是線程安全的。這個場景並不適合使用 CopyOnWriteArrayList,因為寫多讀少。
package constxiong.concurrency.a026;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.CopyOnWriteArrayList;
/**
* 測試 copy-on-write
* @author ConstXiong
*/
public class TestCopyOnWrite {
private static final Random R = new Random();
private static CopyOnWriteArrayList<integer> cowList = new CopyOnWriteArrayList<integer>();
// private static ArrayList<integer> cowList = new ArrayList<integer>();
public static void main(String[] args) throws InterruptedException {
List<thread> threadList = new ArrayList<thread>();
//啟動 1000 個線程,向 cowList 添加 5 個隨機整數
for (int i = 0; i <1000; i++) {
Thread t = new Thread(() -> {
for (int j = 0; j <5; j++) {
//休眠 10 毫秒,讓線程同時向 cowList 添加整數,引出併發問題
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
cowList.add(R.nextInt(100));
}
}) ;
t.start();
threadList.add(t);
}
for (Thread t : threadList) {
t.join();
}
System.out.println(cowList.size());
}
}
/<thread>/<thread>/<integer>/<integer>/<integer>/<integer>
打印結果
5000
如果把
private static CopyOnWriteArrayList<integer> cowList = new CopyOnWriteArrayList<integer>();
/<integer>/<integer>
改為
private static ArrayList<integer> cowList = new ArrayList<integer>();
/<integer>/<integer>
打印結果就是小於 5000 的整數了
閱讀更多 Java肖先生 的文章