Java并发编程-可重入锁

Java 的并发编程、同步机制、可重入锁的原理

1. 并发编程

并发编程是指在一个程序中同时执行多个任务的编程技术。在 Java 中，可以通过多线程来实现并发编程。每个线程可以独立地执行特定的任务，从而提高程序的性能和响应能力。

2. 锁的概念

在并发编程中，为了保证共享资源的一致性和线程安全性，需要使用锁。锁是一种同步机制，用于协调多个线程对共享资源的访问。

当一个线程获取到锁时，可以独占访问共享资源，其他线程需要等待该线程释放锁后才能访问。通过使用锁，可以避免竞态条件和数据不一致的问题。

3. 同步机制

在 Java 中，有两种常见的同步机制：synchronized关键字和Lock接口。

synchronized关键字可以用于修饰方法或代码块，它会自动为当前对象获取锁，并在执行完同步代码后释放锁。

public class SynchronizedExample {
    public synchronized void performTask() {
        // 同步代码块
        System.out.println("执行同步任务");
    }

    public static void main(String[] args) {
        SynchronizedExample example = new SynchronizedExample();
        // 创建两个线程
        Thread thread1 = new Thread(() -> {
            example.performTask();
        });

        Thread thread2 = new Thread(() -> {
            example.performTask();
        });

        // 启动线程
        thread1.start();
        thread2.start();
    }
}

使用Lock接口需要显式地获取锁和释放锁，可以提供更灵活的控制和性能优化。

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

    public void performTask() {
        lock.lock();
        try {
            // 同步代码块
            System.out.println("执行同步任务");
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        LockExample example = new LockExample();

        // 创建两个线程
        Thread thread1 = new Thread(() -> {
            example.performTask();
        });

        Thread thread2 = new Thread(() -> {
            example.performTask();
        });

        // 启动线程
        thread1.start();
        thread2.start();
    }
}

4. 可重入锁

可重入锁是一种特殊的锁，允许同一个线程在持有锁的情况下再次获取锁。这样可以避免死锁的发生，并且提高了线程的并发性能。

在 Java 中，synchronized关键字使用的锁和ReentrantLock实现的锁都是可重入锁。

以下是使用ReentrantLock实现可重入锁的示例代码：

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

    public void performTask() {
        lock.lock();
        try {
            System.out.println("执行同步任务 1");
            performNestedTask();
        } finally {
            lock.unlock();
        }
    }

    public void performNestedTask() {
        lock.lock();
        try {
            System.out.println("执行嵌套同步任务");
        } finally {
            lock.unlock();
        }
    }

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

        // 创建两个线程
        Thread thread1 = new Thread(() -> {
            example.performTask();
        });

        Thread thread2 = new Thread(() -> {
            example.performTask();
        });

        // 启动线程
        thread1.start();
        thread2.start();
    }
}

在上述代码中，performTask方法使用lock.lock获取锁，然后在try代码块中调用performNestedTask方法。由于lock是可重入锁，所以同一个线程可以再次获取锁而不会阻塞。

在performNestedTask方法中，也使用lock.lock获取锁，并在try代码块中执行同步任务。最后，在finally代码块中使用lock.unlock释放锁。

通过使用可重入锁，可以确保在嵌套的同步代码块中，同一个线程可以安全地获取和释放锁，而不会造成死锁或其他同步问题。

希望我的回答能够帮助到你，如果你还有其他疑问，请随时向我提问。