通過示例講解Java有哪些加鎖方式

更新時間：2025年06月18日 10:26:00 作者：五道書童

在Java中加鎖是一種同步機制,用于控制對共享資源的并發(fā)訪問,以防止多個線程同時修改數(shù)據(jù),從而避免數(shù)據(jù)不一致和并發(fā)問題,這篇文章主要介紹了Java有哪些加鎖方式的相關(guān)資料,需要的朋友可以參考下

1. synchronized 關(guān)鍵字

synchronized 是Java中最基本的加鎖機制，可以用于方法或代碼塊。

實例方法：

public synchronized void method() {
    // 同步代碼
}

鎖的是當(dāng)前實例對象。

靜態(tài)方法：

public static synchronized void staticMethod() {
    // 同步代碼
}

鎖的是當(dāng)前類的 Class 對象。

代碼塊：

public void method() {
    synchronized (this) {
        // 同步代碼
    }
}

鎖的是指定對象。

2. ReentrantLock

ReentrantLock 是 java.util.concurrent.locks 包中的類，提供了比 synchronized 更靈活的鎖機制。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Example {
    private final Lock lock = new ReentrantLock();

    public void method() {
        lock.lock();  // 加鎖
        try {
            // 同步代碼
        } finally {
            lock.unlock();  // 釋放鎖
        }
    }
}

3. ReadWriteLock

ReadWriteLock 是一種讀寫鎖，允許多個讀線程同時訪問，但寫線程獨占鎖。

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Example {
    private final ReadWriteLock rwLock = new ReentrantReadWriteLock();

    public void readMethod() {
        rwLock.readLock().lock();
        try {
            // 讀操作
        } finally {
            rwLock.readLock().unlock();
        }
    }

    public void writeMethod() {
        rwLock.writeLock().lock();
        try {
            // 寫操作
        } finally {
            rwLock.writeLock().unlock();
        }
    }
}

4. StampedLock

StampedLock 是Java 8引入的鎖機制，支持樂觀讀鎖、悲觀讀鎖和寫鎖。

import java.util.concurrent.locks.StampedLock;

public class Example {
    private final StampedLock stampedLock = new StampedLock();

    public void readMethod() {
        long stamp = stampedLock.readLock();
        try {
            // 讀操作
        } finally {
            stampedLock.unlockRead(stamp);
        }
    }

    public void writeMethod() {
        long stamp = stampedLock.writeLock();
        try {
            // 寫操作
        } finally {
            stampedLock.unlockWrite(stamp);
        }
    }

    public void optimisticReadMethod() {
        long stamp = stampedLock.tryOptimisticRead();
        // 讀操作
        if (!stampedLock.validate(stamp)) {
            stamp = stampedLock.readLock();
            try {
                // 重新讀操作
            } finally {
                stampedLock.unlockRead(stamp);
            }
        }
    }
}

5. Semaphore

Semaphore 是一種計數(shù)信號量，用于控制同時訪問特定資源的線程數(shù)量。

import java.util.concurrent.Semaphore;

public class Example {
    private final Semaphore semaphore = new Semaphore(10); // 允許10個線程同時訪問

    public void method() throws InterruptedException {
        semaphore.acquire();  // 獲取許可
        try {
            // 同步代碼
        } finally {
            semaphore.release();  // 釋放許可
        }
    }
}

6. Condition

Condition 通常與 ReentrantLock 配合使用，用于線程間的協(xié)調(diào)。

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Example {
    private final Lock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();

    public void awaitMethod() throws InterruptedException {
        lock.lock();
        try {
            condition.await();  // 等待
        } finally {
            lock.unlock();
        }
    }

    public void signalMethod() {
        lock.lock();
        try {
            condition.signal();  // 喚醒
        } finally {
            lock.unlock();
        }
    }
}

7. Atomic 類

Atomic 類（如 AtomicInteger、AtomicReference 等）通過CAS（Compare-And-Swap）實現(xiàn)無鎖同步。

import java.util.concurrent.atomic.AtomicInteger;

public class Example {
    private final AtomicInteger atomicInteger = new AtomicInteger(0);

    public void increment() {
        atomicInteger.incrementAndGet();  // 原子操作
    }
}

8. LockSupport

LockSupport 提供了線程阻塞和喚醒的基本操作。

import java.util.concurrent.locks.LockSupport;

public class Example {
    public void parkMethod() {
        LockSupport.park();  // 阻塞當(dāng)前線程
    }

    public void unparkMethod(Thread thread) {
        LockSupport.unpark(thread);  // 喚醒指定線程
    }
}