目錄
Lock和synchronized
為啥需要Lock
主要方法
Lock();
tryLock(long time,TimeUnit unit)；超時就放棄
lockInterruptibly(); 中斷
Java鎖分類：
樂觀鎖和悲觀鎖：
樂觀鎖：
劣勢：
使用場景：
劣勢：
使用場景：
可重入鎖：
ReentrantLock的其它方法
公平鎖和非公平鎖
共享鎖和排它鎖：
讀寫鎖的作用：
讀寫鎖的規則：
讀鎖和寫鎖的互動方式：
自旋鎖和阻塞鎖
自旋缺點：
原理：
使用場景：
Lock和synchronized
- 鎖是一種工具，用于控制對共享資源的訪問
- Lock和synchronized，這兩個是最創建的鎖，他們都可以達到執行緒安全的目的，但是使用和功能上有較大不同
- Lock不是完全替代synchronized的，而是當使用synchronized不合適或不足以滿足要求的時候，提供高級功能
- Lock 最常見的是ReentrantLock實作
為啥需要Lock
- syn效率低：鎖的釋放情況少，試圖獲得鎖時不能設定超時，不能中斷一個正在試圖獲得鎖的執行緒
- 不夠靈活，加鎖和釋放的時機單一，每個鎖僅有一個單一的條件(某個物件),可能是不夠的
- 無法知道是否成功獲取到鎖
主要方法
Lock();
最普通的獲取鎖，最佳實踐是finally中釋放鎖，保證發生例外的時候鎖一定被釋放 /**
* 描述：Lock不會像syn一樣，例外的時候自動釋放鎖
* 所以最佳實踐是finally中釋放鎖，保證發生例外的時候鎖一定被釋放
*/
private static Lock lock = new ReentrantLock();
public static void main(String[] args) {
lock.lock();
try {
//獲取本鎖保護的資源
System.out.println(Thread.currentThread().getName() + "開始執行任務");
} finally {
lock.unlock();
}
}tryLock(long time,TimeUnit unit)；超時就放棄
用來獲取鎖，如果當前鎖沒有被其它執行緒占用，則獲取成功，則回傳true，否則回傳false，代表獲取鎖失敗/**
* 描述：用TryLock避免死鎖
*/
static class TryLockDeadlock implements Runnable {
int flag = 1;
static Lock lock1 = new ReentrantLock();
static Lock lock2 = new ReentrantLock();
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (flag == 1) {
try {
if (lock1.tryLock(800, TimeUnit.MILLISECONDS)) {
try {
System.out.println("執行緒1獲取到了鎖1");
Thread.sleep(new Random().nextInt(1000));
if (lock2.tryLock(800,TimeUnit.MILLISECONDS)){
try {
System.out.println("執行緒1獲取到了鎖2");
System.out.println("執行緒1成功獲取到了2把鎖");
break;
}finally {
lock2.unlock();
}
}else{
System.out.println("執行緒1獲取鎖2失敗，已重試");
}
} finally {
lock1.unlock();
Thread.sleep(new Random().nextInt(1000));
}
} else {
System.out.println("執行緒1獲取鎖1失敗，已重試");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if (flag == 0) {
try {
if (lock2.tryLock(3000, TimeUnit.MILLISECONDS)) {
try {
System.out.println("執行緒2獲取到了鎖2");
Thread.sleep(new Random().nextInt(1000));
if (lock1.tryLock(800,TimeUnit.MILLISECONDS)){
try {
System.out.println("執行緒2獲取到了鎖1");
System.out.println("執行緒2成功獲取到了2把鎖");
break;
}finally {
lock1.unlock();
}
}else{
System.out.println("執行緒2獲取鎖1失敗，已重試");
}
} finally {
lock2.unlock();
Thread.sleep(new Random().nextInt(1000));
}
} else {
System.out.println("執行緒2獲取鎖2失敗，已經重試");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public static void main(String[] args) {
TryLockDeadlock r1 = new TryLockDeadlock();
TryLockDeadlock r2 = new TryLockDeadlock();
r1.flag = 1;
r2.flag = 0;
new Thread(r1).start();
new Thread(r2).start();
}
}
執行結果：
執行緒1獲取到了鎖1
執行緒2獲取到了鎖2
執行緒1獲取鎖2失敗，已重試
執行緒2獲取到了鎖1
執行緒2成功獲取到了2把鎖
執行緒1獲取到了鎖1
執行緒1獲取到了鎖2
執行緒1成功獲取到了2把鎖lockInterruptibly(); 中斷
相當于tryLock(long time,TimeUnit unit) 把超時時間設定為無限，在等待鎖的程序中，執行緒可以被中斷/**
* 描述：獲取鎖的程序中，中斷了
*/
static class LockInterruptibly implements Runnable {
private Lock lock = new ReentrantLock();
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "嘗試獲取鎖");
try {
lock.lockInterruptibly();
try {
System.out.println(Thread.currentThread().getName() + "獲取到了鎖");
Thread.sleep(5000);
} catch (InterruptedException e) {
System.out.println(Thread.currentThread().getName() + "睡眠中被中斷了");
} finally {
lock.unlock();
System.out.println(Thread.currentThread().getName() + "釋放了鎖");
}
} catch (InterruptedException e) {
System.out.println(Thread.currentThread().getName() + "等鎖期間被中斷了");
}
}
public static void main(String[] args) {
LockInterruptibly lockInterruptibly = new LockInterruptibly();
Thread thread0 = new Thread(lockInterruptibly);
Thread thread1 = new Thread(lockInterruptibly);
thread0.start();
thread1.start();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
thread0.interrupt();
}
}
執行結果：
Thread-0嘗試獲取鎖
Thread-1嘗試獲取鎖
Thread-0獲取到了鎖
Thread-0睡眠中被中斷了
Thread-0釋放了鎖
Thread-1獲取到了鎖
Thread-1釋放了鎖Java鎖分類：
樂觀鎖和悲觀鎖：
樂觀鎖：
- 比較樂觀，認為自己在處理操作的時候，不會有其它執行緒來干擾，所以并不會鎖住操作物件
- 在更新的時候，去對比我修改期間的資料有沒有被改變過，如沒有，就正常的修改資料
- 如果資料和我一開始拿到的不一樣了，說明其他人在這段時間內改過，會選擇放棄，報錯，重試等策略
- 樂觀鎖的實作一般都是利用CAS演算法來實作的
劣勢：
可能造成ABA問題，就是不知道是不是修改過
使用場景：
適合并發寫入少的情況，大部分是讀取的場景，不加鎖的能讓讀取的性能大幅提高
悲觀鎖：
比較悲觀，認為如果我不鎖住這個資源，別人就會來爭搶，就會造成資料結果錯誤，所以它會鎖住操作物件，Java中悲觀鎖的實作就是syn和Lock相關類
劣勢：
- 阻塞和喚醒帶來的性能劣勢
- 如果持有鎖的執行緒被永久阻塞，比如遇到了無限回圈，死鎖等活躍性問題，那么等待該執行緒釋放鎖的那幾個執行緒，永遠也得不到執行
- 優先級反轉，優先級低的執行緒拿到鎖不釋放或釋放的比較慢，就會造成這個問題
使用場景：
適合并發寫入多的情況，適用于臨界區持鎖時間比較長的情況：
- 臨界區有IO操作
- 臨界區代碼復雜或者回圈量大
- 臨界區競爭非常激烈
可重入鎖：
- 可重入就是說某個執行緒已經獲得某個鎖，可以再次獲取鎖而不會出現死鎖
- ReentrantLock 和 synchronized 都是可重入鎖
// 遞回呼叫演示可重入鎖
static class RecursionDemo{
public static ReentrantLock lock = new ReentrantLock();
private static void accessResource(){
lock.lock();
try {
System.out.println("已經對資源處理了");
if (lock.getHoldCount() < 5){
System.out.println("已經處理了"+lock.getHoldCount()+"次");
accessResource();
}
}finally {
lock.unlock();
}
}
public static void main(String[] args) {
new RecursionDemo().accessResource();
}
}
執行結果：
已經對資源處理了
已經處理了1次
已經對資源處理了
已經處理了2次
已經對資源處理了
已經處理了3次
已經對資源處理了
已經處理了4次
已經對資源處理了ReentrantLock的其它方法
- isHeldByCurrentThread 可以看出鎖是否被當前執行緒持有
- getQueueLength()可以回傳當前正在等待這把鎖的佇列有多長，一般這兩個方法是開發和除錯時候使用，上線后用到的不多
公平鎖和非公平鎖
- 公平指的是按照執行緒請求的順序，來分配鎖；
- 非公平指的是，不完全按照請求的順序，在一定情況下，可以插隊
- 非公平鎖可以避免喚醒帶來的空檔期
/**
* 描述：演示公平鎖和非公平鎖
*/
class FairLock{
public static void main(String[] args) {
PrintQueue printQueue = new PrintQueue();
Thread[] thread = new Thread[10];
for (int i = 0; i < 10; i++) {
thread[i] = new Thread(new Job(printQueue));
}
for (int i = 0; i < 5; i++) {
thread[i].start();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class Job implements Runnable{
PrintQueue printQueue;
public Job(PrintQueue printQueue) {
this.printQueue = printQueue;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"開始列印");
printQueue.printJob(new Object());
System.out.println(Thread.currentThread().getName()+"列印完成");
}
}
class PrintQueue{
// true 公平，false是非公平
private Lock queueLock = new ReentrantLock(true);
public void printJob(Object document){
queueLock.lock();
try {
int duration = new Random().nextInt(10)+1;
System.out.println(Thread.currentThread().getName()+"正在列印，需要"+duration+"秒");
Thread.sleep(duration * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
queueLock.unlock();
}
queueLock.lock();
try {
int duration = new Random().nextInt(10)+1;
System.out.println(Thread.currentThread().getName()+"正在列印，需要"+duration+"秒");
Thread.sleep(duration * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
queueLock.unlock();
}
}
}
執行結果：
Thread-0開始列印
Thread-0正在列印，需要10秒
Thread-1開始列印
Thread-2開始列印
Thread-3開始列印
Thread-4開始列印
Thread-1正在列印，需要2秒
Thread-2正在列印，需要2秒
Thread-3正在列印，需要2秒
Thread-4正在列印，需要4秒
Thread-0正在列印，需要2秒
Thread-0列印完成
Thread-1正在列印，需要7秒
Thread-1列印完成
Thread-2正在列印，需要8秒
Thread-2列印完成
Thread-3正在列印，需要3秒
Thread-3列印完成
Thread-4正在列印，需要8秒
Thread-4列印完成
true改為false演示非公平鎖：
Lock queueLock = new ReentrantLock(false);
執行結果：
Thread-0正在列印，需要7秒
Thread-1開始列印
Thread-2開始列印
Thread-3開始列印
Thread-4開始列印
Thread-0正在列印，需要9秒
Thread-0列印完成
Thread-1正在列印，需要3秒
Thread-1正在列印，需要2秒
Thread-1列印完成
Thread-2正在列印，需要4秒
Thread-2正在列印，需要7秒
Thread-2列印完成
Thread-3正在列印，需要10秒
Thread-3正在列印，需要2秒
Thread-3列印完成
Thread-4正在列印，需要7秒
Thread-4正在列印，需要8秒
Thread-4列印完成共享鎖和排它鎖：
- 排它鎖，又稱為獨占鎖，獨享鎖
- 共享鎖，又稱為讀鎖，獲得共享鎖之后，可以查看但無法修改和洗掉資料，其他執行緒此時也可以獲取到共享鎖，也可以查看但無法修改和洗掉資料
- 共享鎖和排它鎖的典型是讀寫鎖 ReentrantReadWriteLock,其中讀鎖是共享鎖，寫鎖是獨享鎖
讀寫鎖的作用：
- 在沒有讀寫鎖之前，我們假設使用ReentrantLock，那么雖然我們保證了執行緒安全，但是也浪費了一定的資源：多個讀操作同時進行，并沒有執行緒安全問題
- 在讀的地方使用讀鎖，在寫的地方使用寫鎖，靈活控制，如果沒有寫鎖的情況下，讀是無阻塞的，提高了程式的執行效率
讀寫鎖的規則：
- 多個執行緒值申請讀鎖，都可以申請到
- 要么一個或多個一起讀，要么一個寫，兩者不會同時申請到，只能存在一個寫鎖
/**
* 描述：演示可以多個一起讀，只能一個寫
*/
class CinemaReadWrite{
private static ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
private static ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();
private static ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock();
private static void read(){
readLock.lock();
try {
System.out.println(Thread.currentThread().getName() + "得到了讀鎖，正在讀取");
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
System.out.println(Thread.currentThread().getName() + "釋放了讀鎖");
readLock.unlock();
}
}
private static void write(){
writeLock.lock();
try {
System.out.println(Thread.currentThread().getName() + "得到了寫鎖，正在寫入");
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
System.out.println(Thread.currentThread().getName() + "釋放了寫鎖");
writeLock.unlock();
}
}
public static void main(String[] args) {
new Thread(()-> read(),"Thrad1").start();
new Thread(()-> read(),"Thrad2").start();
new Thread(()-> write(),"Thrad3").start();
new Thread(()-> write(),"Thrad4").start();
}
}
執行結果：
Thrad1得到了讀鎖，正在讀取
Thrad2得到了讀鎖，正在讀取
Thrad2釋放了讀鎖
Thrad1釋放了讀鎖
Thrad3得到了寫鎖，正在寫入
Thrad3釋放了寫鎖
Thrad4得到了寫鎖，正在寫入
Thrad4釋放了寫鎖讀鎖和寫鎖的互動方式：
讀鎖插隊策略：
- 公平鎖：不允許插隊
- 非公平鎖：寫鎖可以隨時插隊，讀鎖僅在等待佇列頭節點不是想獲取寫鎖執行緒的時候可以插隊
自旋鎖和阻塞鎖
- 讓當前執行緒進行自旋，如果自旋完成后前面鎖定同步資源的執行緒已經釋放了鎖，那么當前執行緒就可以不必阻塞而是直接獲取同步資源，從而避免切換執行緒的開銷，這就是自旋鎖，
- 阻塞鎖和自旋鎖相反，阻塞鎖如果遇到沒拿到鎖的情況，會直接把執行緒阻塞，知道被喚醒
自旋缺點：
- 如果鎖被占用的時間很長，那么自旋的執行緒只會白浪費處理器資源
- 在自旋的程序中，一直消耗cpu，所以雖然自旋鎖的起始開銷低于悲觀鎖，但是隨著自旋的時間增長，開銷也是線性增長的
原理：
- 在Java1.5版本及以上的并發框架java.util.concurrent 的atmoic包下的類基本都是自旋鎖的實作
- AtomicInteger的實作：自旋鎖的實作原理是CAS,AtomicInteger中呼叫unsafe 進行自增操作的原始碼中的do-while回圈就是一個自旋操作，如果修改程序中遇到其他執行緒競爭導致沒修改成功，就在while里死回圈直至修改成功
/**
* 描述：自旋鎖演示
*/
class SpinLock{
private AtomicReference<Thread> sign = new AtomicReference<>();
public void lock(){
Thread currentThread = Thread.currentThread();
while (!sign.compareAndSet(null,currentThread)){
System.out.println("自旋獲取失敗，再次嘗試");
}
}
public void unLock(){
Thread currentThread = Thread.currentThread();
sign.compareAndSet(currentThread,null);
}
public static void main(String[] args) {
SpinLock spinLock = new SpinLock();
Runnable runnable = new Runnable(){
@Override
public void run(){
System.out.println(Thread.currentThread().getName()+"開始嘗試自旋鎖");
spinLock.lock();
System.out.println(Thread.currentThread().getName()+"獲取到了自旋鎖");
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
spinLock.unLock();
System.out.println(Thread.currentThread().getName()+"釋放了自旋鎖");
}
}
};
Thread thread1 = new Thread(runnable);
Thread thread2 = new Thread(runnable);
thread1.start();
thread2.start();
}
}
執行結果：
Thread-0開始嘗試自旋鎖
Thread-0獲取到了自旋鎖
Thread-1開始嘗試自旋鎖
自旋獲取失敗，再次嘗試
自旋獲取失敗，再次嘗試
自旋獲取失敗，再次嘗試
自旋獲取失敗，再次嘗試
自旋獲取失敗，再次嘗試
自旋獲取失敗，再次嘗試
自旋獲取失敗，再次嘗試
自旋獲取失敗，再次嘗試
自旋獲取失敗，再次嘗試
自旋獲取失敗，再次嘗試
自旋獲取失敗，再次嘗試
Thread-0釋放了自旋鎖
Thread-1獲取到了自旋鎖
Thread-1釋放了自旋鎖使用場景：
- 自旋鎖一般用于多核服務器，在并發度不是特別高的情況下，比阻塞鎖的效率要高
- 另外，自旋鎖適用于臨界區比較短小的情況，否則如果臨界區很大(執行緒一旦拿到鎖，很久之后才會釋放)，那也是不合適的
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/275115.html
標籤：其他
上一篇：C#寫log，自家用
下一篇：走向編程之路