java加锁的几种方式与区别

原创admin 分类：热门问答 2024-04-26 16:12:07 0

java加锁的几种方式与区别
在多线程编程中，加锁是一种常见的同步机制，用于控制对共享资源的访问，以防止数据竞争和保证线程安全。我将从第一人称的角度，详细解释Java中加锁的几种方式及其区别，并提供代码案例。

1. 定义与目的

加锁的目的是在多个线程尝试访问同一资源时，确保一次只有一个线程可以执行相关的代码段。这可以通过多种方式实现，每种方式都有其特定的使用场景和性能考量。

2. 加锁方式与区别

在Java中，加锁可以通过以下几种方式实现：

2.1 同步代码块（synchronized Block）

synchronized (lockObject) {
    // 临界区代码
}

区别于其他锁机制，synchronized 是Java的内建关键字，它简单易用，但缺乏灵活性。例如，它不支持超时机制和公平性设置。

2.2 显式锁（ReentrantLock）

ReentrantLock lock = new ReentrantLock();
lock.lock();
try {
    // 临界区代码
} finally {
    lock.unlock();
}

与synchronized相比，ReentrantLock 提供了更多高级功能，如可中断的锁定、超时机制和公平性策略。

2.3 比较表格

以下是这两种加锁方式的对比表格：

特性	synchronized	ReentrantLock
可重入	是	是
等待可中断	否	是
超时机制	否	是
公平性	否	可配置
使用方式	代码块	API调用

3. 核心类与方法

synchronized：无需额外的类，直接使用关键字即可。
ReentrantLock：需要创建ReentrantLock对象，并调用其lock()和unlock()方法。

4. 使用场景

当需要一个简单的，不可中断的锁时，可以使用synchronized。
当需要更复杂的锁策略，如可中断的锁定或超时机制时，应使用ReentrantLock。

5. 代码案例

5.1 synchronized代码案例

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

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (lock) {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName() + " " + i);
                }
            }
        }).start();

        new Thread(() -> {
            synchronized (lock) {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName() + " " + i);
                }
            }
        }).start();
    }
}

5.2 ReentrantLock代码案例

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

    public static void main(String[] args) {
        lock.lock();
        try {
            new Thread(() -> {
                lock.lock();
                try {
                    for (int i = 0; i < 10; i++) {
                        System.out.println(Thread.currentThread().getName() + " " + i);
                    }
                } finally {
                    lock.unlock();
                }
            }).start();

            new Thread(() -> {
                lock.lock();
                try {
                    for (int i = 0; i < 10; i++) {
                        System.out.println(Thread.currentThread().getName() + " " + i);
                    }
                } finally {
                    lock.unlock();
                }
            }).start();
        } finally {
            lock.unlock();
        }
    }
}