Java中怎么實現不可重入鎖和可重入鎖

Java中怎么實現不可重入鎖和可重入鎖

在Java中，鎖是控制多個線程對共享資源訪問的重要機制。鎖可以分為不可重入鎖和可重入鎖。本文將詳細介紹這兩種鎖的概念，并通過代碼示例展示如何在Java中實現它們。

1. 不可重入鎖

不可重入鎖（Non-Reentrant Lock）是指同一個線程在持有鎖的情況下，再次嘗試獲取該鎖時會被阻塞。這種鎖的實現相對簡單，但可能會導致死鎖問題。

1.1 實現不可重入鎖

我們可以通過一個簡單的布爾變量來實現不可重入鎖。以下是一個不可重入鎖的實現示例：

public class NonReentrantLock {
    private boolean isLocked = false;

    public synchronized void lock() throws InterruptedException {
        while (isLocked) {
            wait();
        }
        isLocked = true;
    }

    public synchronized void unlock() {
        isLocked = false;
        notify();
    }
}

1.2 使用不可重入鎖

以下是一個使用不可重入鎖的示例：

public class NonReentrantLockExample {
    private NonReentrantLock lock = new NonReentrantLock();

    public void outer() throws InterruptedException {
        lock.lock();
        try {
            inner();
        } finally {
            lock.unlock();
        }
    }

    public void inner() throws InterruptedException {
        lock.lock();
        try {
            // 臨界區代碼
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        NonReentrantLockExample example = new NonReentrantLockExample();
        try {
            example.outer();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在這個示例中，outer方法調用了inner方法，但由于使用的是不可重入鎖，inner方法在嘗試獲取鎖時會被阻塞，導致死鎖。

2. 可重入鎖

可重入鎖（Reentrant Lock）是指同一個線程在持有鎖的情況下，可以多次獲取該鎖而不會被阻塞。Java中的ReentrantLock類就是一個典型的可重入鎖實現。

2.1 實現可重入鎖

我們可以通過記錄持有鎖的線程和重入次數來實現可重入鎖。以下是一個簡單的可重入鎖實現示例：

public class ReentrantLock {
    private Thread lockedBy = null;
    private int lockCount = 0;

    public synchronized void lock() throws InterruptedException {
        Thread callingThread = Thread.currentThread();
        while (lockedBy != null && lockedBy != callingThread) {
            wait();
        }
        lockedBy = callingThread;
        lockCount++;
    }

    public synchronized void unlock() {
        if (Thread.currentThread() == lockedBy) {
            lockCount--;
            if (lockCount == 0) {
                lockedBy = null;
                notify();
            }
        }
    }
}

2.2 使用可重入鎖

以下是一個使用可重入鎖的示例：

public class ReentrantLockExample {
    private ReentrantLock lock = new ReentrantLock();

    public void outer() throws InterruptedException {
        lock.lock();
        try {
            inner();
        } finally {
            lock.unlock();
        }
    }

    public void inner() throws InterruptedException {
        lock.lock();
        try {
            // 臨界區代碼
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        ReentrantLockExample example = new ReentrantLockExample();
        try {
            example.outer();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在這個示例中，outer方法調用了inner方法，由于使用的是可重入鎖，inner方法可以成功獲取鎖，不會導致死鎖。

3. Java中的ReentrantLock類

Java標準庫中提供了ReentrantLock類，它是一個功能強大的可重入鎖實現。ReentrantLock類提供了比synchronized關鍵字更靈活的鎖操作，例如嘗試獲取鎖、超時獲取鎖、可中斷獲取鎖等。

3.1 使用ReentrantLock

以下是一個使用ReentrantLock的示例：

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

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

    public void outer() {
        lock.lock();
        try {
            inner();
        } finally {
            lock.unlock();
        }
    }

    public void inner() {
        lock.lock();
        try {
            // 臨界區代碼
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        ReentrantLockExample example = new ReentrantLockExample();
        example.outer();
    }
}

在這個示例中，ReentrantLock的使用方式與自定義的可重入鎖類似，但ReentrantLock提供了更多的功能和更好的性能。

4. 總結

不可重入鎖和可重入鎖是Java中兩種常見的鎖機制。不可重入鎖實現簡單，但可能會導致死鎖問題；可重入鎖則更加靈活和安全，適用于復雜的多線程場景。Java標準庫中的ReentrantLock類是一個功能強大的可重入鎖實現，推薦在實際開發中使用。

通過本文的介紹和示例代碼，相信讀者已經對Java中的不可重入鎖和可重入鎖有了更深入的理解。在實際開發中，選擇合適的鎖機制可以有效提高程序的并發性能和穩定性。