快捷導(dǎo)航

Java多線程同步的幾種常見方法

更新時(shí)間：2025年05月13日 10:12:35 作者：java1234_小鋒

在 Java 中,多線程同步是確保多個(gè)線程在訪問共享資源時(shí)不會(huì)發(fā)生競(jìng)爭(zhēng)和沖突的機(jī)制,Java 提供了多種方式來實(shí)現(xiàn)線程同步,以下是 Java 中常見的幾種同步方法,需要的朋友可以參考下

Java多線程同步有哪些方法?

1. 使用 synchronized 關(guān)鍵字

synchronized 是 Java 提供的最基本的同步方式，它可以用來修飾方法或代碼塊，確保同一時(shí)刻只有一個(gè)線程能夠執(zhí)行被同步的代碼部分。

(1) 同步方法

將整個(gè)方法標(biāo)記為同步方法，確保同一時(shí)刻只有一個(gè)線程能夠執(zhí)行該方法。

public synchronized void method() {
    // 線程安全的操作
}

如果同步方法是實(shí)例方法，鎖是當(dāng)前實(shí)例對(duì)象（this）。
如果同步方法是靜態(tài)方法，鎖是類對(duì)象（Class）。

(2) 同步代碼塊

通過同步代碼塊，指定一個(gè)特定的鎖對(duì)象來控制同步的范圍，從而提高性能。

public void method() {
    synchronized (this) {
        // 線程安全的操作
    }
}

this 表示鎖住當(dāng)前實(shí)例對(duì)象，可以根據(jù)需要使用不同的鎖對(duì)象。

2. 使用 ReentrantLock

ReentrantLock 是 java.util.concurrent.locks 包中的一個(gè)鎖實(shí)現(xiàn)，提供比 synchronized 更加靈活和強(qiáng)大的功能，如可重入性、公平性、響應(yīng)中斷等。通過顯式調(diào)用 lock() 和 unlock() 來控制鎖的獲取和釋放。

import java.util.concurrent.locks.ReentrantLock;
 
public class LockExample {
    private final ReentrantLock lock = new ReentrantLock();
 
    public void method() {
        lock.lock();
        try {
            // 線程安全的操作
        } finally {
            lock.unlock();
        }
    }
}

特性：

可重入性：同一線程可以多次獲得鎖。
公平性：可以選擇公平鎖（按請(qǐng)求順序獲取鎖）。
中斷響應(yīng)：支持響應(yīng)線程中斷。

3. 使用 ReadWriteLock

ReadWriteLock 是 java.util.concurrent.locks 包中的一個(gè)接口，分為 ReentrantReadWriteLock 實(shí)現(xiàn)類。它提供了讀寫鎖機(jī)制，其中允許多個(gè)線程同時(shí)讀，但寫操作是互斥的，保證了高效的讀操作并避免寫操作沖突。

import java.util.concurrent.locks.ReentrantReadWriteLock;
 
public class ReadWriteLockExample {
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
 
    public void readMethod() {
        lock.readLock().lock();
        try {
            // 線程安全的讀操作
        } finally {
            lock.readLock().unlock();
        }
    }
 
    public void writeMethod() {
        lock.writeLock().lock();
        try {
            // 線程安全的寫操作
        } finally {
            lock.writeLock().unlock();
        }
    }
}

特性：

讀鎖：多個(gè)線程可以同時(shí)獲得讀鎖，只要沒有寫鎖被占用。
寫鎖：寫鎖是獨(dú)占的，當(dāng)一個(gè)線程獲取寫鎖時(shí)，其他線程不能同時(shí)獲得讀鎖或?qū)戞i。

4. 使用 volatile 關(guān)鍵字

volatile 關(guān)鍵字用于確保線程對(duì)某個(gè)變量的修改對(duì)其他線程立即可見。volatile 保證了變量的可見性，但并不能保證原子性。

private volatile boolean flag = false;

可見性：確保線程對(duì) volatile 變量的修改立即對(duì)其他線程可見。
不保證原子性：對(duì)于復(fù)合操作（如 i++），volatile 并不能保證原子性。

5. 使用 Atomic 類

java.util.concurrent.atomic 包提供了一些原子操作類，如 AtomicInteger、AtomicBoolean 等，適用于處理簡單的數(shù)值操作。它們通過 CAS（比較并交換）機(jī)制提供原子操作，避免了使用鎖。

import java.util.concurrent.atomic.AtomicInteger;
 
public class AtomicExample {
    private final AtomicInteger count = new AtomicInteger(0);
 
    public void increment() {
        count.incrementAndGet();
    }
 
    public int getCount() {
        return count.get();
    }
}

原子性：這些類通過底層的 CAS 操作保證線程安全。
無鎖機(jī)制：避免了傳統(tǒng)鎖的性能開銷。

6. 使用 Semaphore（信號(hào)量）

Semaphore 是一種用來控制同時(shí)訪問特定資源的線程數(shù)的同步工具。它可以設(shè)置一個(gè)信號(hào)量計(jì)數(shù)，控制可以訪問某些資源的線程數(shù)量。

import java.util.concurrent.Semaphore;
 
public class SemaphoreExample {
    private final Semaphore semaphore = new Semaphore(3); // 最大允許3個(gè)線程
 
    public void accessResource() {
        try {
            semaphore.acquire();
            // 執(zhí)行資源訪問操作
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release();
        }
    }
}

可控制并發(fā)數(shù)：通過信號(hào)量來控制并發(fā)線程數(shù)。
適用場(chǎng)景：用于限制某些共享資源的并發(fā)訪問，例如數(shù)據(jù)庫連接池等。

7. 使用 CountDownLatch

CountDownLatch 是一種同步工具，允許一個(gè)或多個(gè)線程等待，直到其他線程完成一組操作后再繼續(xù)執(zhí)行。通常用于在一組線程完成任務(wù)后再啟動(dòng)主線程或其他線程。

import java.util.concurrent.CountDownLatch;
 
public class CountDownLatchExample {
    private final CountDownLatch latch = new CountDownLatch(3); // 等待3個(gè)線程完成
 
    public void task() {
        try {
            // 執(zhí)行某些操作
        } finally {
            latch.countDown(); // 操作完成，計(jì)數(shù)減一
        }
    }
 
    public void mainTask() throws InterruptedException {
        latch.await(); // 等待所有線程完成
        System.out.println("All tasks are finished!");
    }
}

8. 使用 CyclicBarrier

CyclicBarrier 是一個(gè)允許一組線程互相等待，直到所有線程都到達(dá)某個(gè)公共屏障點(diǎn)后再繼續(xù)執(zhí)行的同步工具。它適用于需要多線程并行執(zhí)行的場(chǎng)景。

import java.util.concurrent.CyclicBarrier;
 
public class CyclicBarrierExample {
    private final CyclicBarrier barrier = new CyclicBarrier(3, new Runnable() {
        @Override
        public void run() {
            System.out.println("All threads reached the barrier, continue execution.");
        }
    });
 
    public void task() throws InterruptedException {
        barrier.await(); // 等待所有線程到達(dá)屏障
        // 執(zhí)行任務(wù)
    }
}