Java提供了synchronized為什么還要提供Lock

Java提供了synchronized為什么還要提供Lock

引言

在Java多線程編程中，線程安全是一個非常重要的話題。為了保證多個線程能夠正確地訪問共享資源，Java提供了多種同步機制，其中最常見的就是synchronized關鍵字和java.util.concurrent.locks.Lock接口。盡管synchronized關鍵字已經能夠滿足大部分的同步需求，但Java仍然提供了Lock接口及其實現類（如ReentrantLock）。那么，為什么Java在已經有了synchronized的情況下，還要提供Lock呢？本文將從多個角度探討這個問題。

1. synchronized的局限性

1.1 無法中斷等待的線程

synchronized關鍵字的一個主要局限性是，當一個線程因為獲取不到鎖而進入阻塞狀態時，它無法被中斷。也就是說，如果一個線程在等待獲取鎖的過程中，其他線程無法通過調用interrupt()方法來中斷它。這可能會導致一些線程長時間處于阻塞狀態，影響系統的響應性。

public class SynchronizedExample {
    private final Object lock = new Object();

    public void doSomething() {
        synchronized (lock) {
            // 長時間操作
        }
    }
}

在上面的例子中，如果一個線程在synchronized塊中執行了一個長時間的操作，其他線程將無法中斷它，只能一直等待。

1.2 無法嘗試獲取鎖

synchronized關鍵字要求線程在獲取鎖時，必須一直等待，直到成功獲取鎖為止。這種機制在某些場景下可能不夠靈活。例如，在某些情況下，我們可能希望線程在嘗試獲取鎖失敗后，立即返回或執行其他操作，而不是一直等待。

public class SynchronizedExample {
    private final Object lock = new Object();

    public void doSomething() {
        synchronized (lock) {
            // 操作
        }
    }
}

在上面的例子中，如果一個線程無法獲取鎖，它將一直阻塞，直到鎖可用為止。

1.3 無法實現公平鎖

synchronized關鍵字無法實現公平鎖。公平鎖是指多個線程在競爭鎖時，按照請求鎖的順序來獲取鎖。而synchronized關鍵字采用的是非公平鎖機制，即線程獲取鎖的順序是不確定的，可能會導致某些線程長時間無法獲取鎖。

public class SynchronizedExample {
    private final Object lock = new Object();

    public void doSomething() {
        synchronized (lock) {
            // 操作
        }
    }
}

在上面的例子中，多個線程在競爭鎖時，獲取鎖的順序是不確定的，可能會導致某些線程長時間無法獲取鎖。

1.4 無法實現讀寫鎖

synchronized關鍵字無法區分讀操作和寫操作。在某些場景下，讀操作是可以并發執行的，而寫操作則需要互斥執行。synchronized關鍵字無法實現這種讀寫分離的鎖機制。

public class SynchronizedExample {
    private final Object lock = new Object();

    public void read() {
        synchronized (lock) {
            // 讀操作
        }
    }

    public void write() {
        synchronized (lock) {
            // 寫操作
        }
    }
}

在上面的例子中，讀操作和寫操作都需要互斥執行，無法實現讀操作的并發執行。

2. Lock接口的優勢

2.1 可中斷的鎖獲取

Lock接口提供了lockInterruptibly()方法，允許線程在等待鎖的過程中響應中斷。這意味著，如果一個線程在等待鎖的過程中被中斷，它可以立即拋出InterruptedException并退出等待狀態。

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

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

    public void doSomething() throws InterruptedException {
        lock.lockInterruptibly();
        try {
            // 長時間操作
        } finally {
            lock.unlock();
        }
    }
}

在上面的例子中，如果一個線程在等待鎖的過程中被中斷，它將立即拋出InterruptedException并退出等待狀態。

2.2 嘗試獲取鎖

Lock接口提供了tryLock()方法，允許線程嘗試獲取鎖。如果鎖可用，則立即獲取鎖并返回true；如果鎖不可用，則立即返回false，而不是一直等待。

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

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

    public void doSomething() {
        if (lock.tryLock()) {
            try {
                // 操作
            } finally {
                lock.unlock();
            }
        } else {
            // 執行其他操作
        }
    }
}

在上面的例子中，如果一個線程無法獲取鎖，它將立即返回并執行其他操作，而不是一直等待。

2.3 公平鎖

Lock接口的實現類ReentrantLock提供了公平鎖的選項。通過將ReentrantLock的構造函數參數設置為true，可以實現公平鎖機制，即多個線程在競爭鎖時，按照請求鎖的順序來獲取鎖。

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

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

    public void doSomething() {
        lock.lock();
        try {
            // 操作
        } finally {
            lock.unlock();
        }
    }
}

在上面的例子中，多個線程在競爭鎖時，將按照請求鎖的順序來獲取鎖，避免了某些線程長時間無法獲取鎖的情況。

2.4 讀寫鎖

Lock接口的實現類ReentrantReadWriteLock提供了讀寫鎖機制。讀寫鎖允許多個線程同時進行讀操作，但在寫操作時需要互斥執行。這種機制可以顯著提高讀操作的并發性能。

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

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

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

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

在上面的例子中，讀操作可以并發執行，而寫操作則需要互斥執行，從而提高了讀操作的并發性能。

3. Lock接口的其他優勢

3.1 條件變量

Lock接口提供了newCondition()方法，可以創建Condition對象。Condition對象類似于Object的wait()和notify()方法，但提供了更靈活的線程等待和喚醒機制。通過Condition對象，可以實現更復雜的線程同步邏輯。

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

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

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

    public void signal() {
        lock.lock();
        try {
            condition.signal();
        } finally {
            lock.unlock();
        }
    }
}

在上面的例子中，await()方法使當前線程等待，signal()方法喚醒等待的線程。通過Condition對象，可以實現更復雜的線程同步邏輯。

3.2 鎖的可重入性

Lock接口的實現類ReentrantLock是可重入鎖?？芍厝腈i允許同一個線程多次獲取同一個鎖，而不會導致死鎖。這種機制在某些復雜的同步場景下非常有用。

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

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

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

    public void inner() {
        lock.lock();
        try {
            // 操作
        } finally {
            lock.unlock();
        }
    }
}

在上面的例子中，outer()方法和inner()方法都可以獲取同一個鎖，而不會導致死鎖。

3.3 鎖的監控

Lock接口的實現類ReentrantLock提供了getHoldCount()、isHeldByCurrentThread()等方法，可以監控鎖的狀態。這些方法在某些調試和分析場景下非常有用。

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

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

    public void doSomething() {
        lock.lock();
        try {
            System.out.println("Hold count: " + ((ReentrantLock) lock).getHoldCount());
            System.out.println("Is held by current thread: " + ((ReentrantLock) lock).isHeldByCurrentThread());
            // 操作
        } finally {
            lock.unlock();
        }
    }
}

在上面的例子中，getHoldCount()方法返回當前線程持有鎖的次數，isHeldByCurrentThread()方法返回當前線程是否持有鎖。

4. synchronized與Lock的選擇

盡管Lock接口提供了更多的功能和靈活性，但在某些場景下，synchronized關鍵字仍然是更好的選擇。synchronized關鍵字的優點是簡單易用，不需要顯式地釋放鎖，且在某些情況下性能更好。因此，在選擇使用synchronized還是Lock時，需要根據具體的需求和場景進行權衡。

4.1 簡單場景

在簡單的同步場景下，synchronized關鍵字通常是更好的選擇。例如，當只需要保護一個簡單的臨界區時，synchronized關鍵字的簡潔性和易用性使其成為首選。

public class SynchronizedExample {
    private final Object lock = new Object();

    public void doSomething() {
        synchronized (lock) {
            // 操作
        }
    }
}

在上面的例子中，doSomething()方法只需要保護一個簡單的臨界區，使用synchronized關鍵字更加簡潔。

4.2 復雜場景

在復雜的同步場景下，Lock接口通常是更好的選擇。例如，當需要實現可中斷的鎖獲取、嘗試獲取鎖、公平鎖、讀寫鎖等功能時，Lock接口提供了更多的靈活性和功能。

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

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

    public void doSomething() throws InterruptedException {
        lock.lockInterruptibly();
        try {
            // 操作
        } finally {
            lock.unlock();
        }
    }
}

在上面的例子中，doSomething()方法需要實現可中斷的鎖獲取，使用Lock接口更加合適。

5. 總結

Java提供了synchronized關鍵字和Lock接口兩種同步機制，它們各有優缺點。synchronized關鍵字簡單易用，但在某些復雜的同步場景下存在局限性。Lock接口提供了更多的功能和靈活性，能夠滿足更復雜的同步需求。因此，在選擇使用synchronized還是Lock時，需要根據具體的需求和場景進行權衡。

在實際開發中，建議在簡單的同步場景下使用synchronized關鍵字，而在復雜的同步場景下使用Lock接口。通過合理選擇和使用同步機制，可以有效地提高多線程程序的性能和可靠性。