详解Java多线程编程中互斥锁ReentrantLock类的用法

简介

Java多线程编程中，为了保证线程安全，需要保证同一时间只有一个线程访问共享资源。使用互斥锁可以实现这个目的。在Java中，ReentrantLock类提供了互斥锁的功能。

ReentrantLock是可重入的互斥锁，它允许线程重复地获取同一把锁，而不会造成死锁。与synchronized关键字相比，ReentrantLock提供了更灵活和精细的锁定机制。

使用方法

定义ReentrantLock对象

在使用ReentrantLock时，首先需要定义一个ReentrantLock对象。可以使用以下代码：

private ReentrantLock lock = new ReentrantLock();

获取锁

获取锁的方法是lock()，使用ReentrantLock进行线程同步时，需要在资源共享的代码前面加锁。如果锁已经被另一个线程获取，那么当前线程会被阻塞，直到锁被释放。获取锁的代码如下：

lock.lock();
try {
    // 资源共享的代码
} finally {
    // 释放锁
    lock.unlock();
}

释放锁

释放锁的方法是unlock()，必须在finally块中释放锁，如上面代码所示。

锁定等待时间

在获取锁时，还可以指定锁定的等待时间，如果等待超时则不再等待。代码如下：

if (lock.tryLock(timeout, TimeUnit.SECONDS)) {
    try {
        // 资源共享的代码
    } finally {
        // 释放锁
        lock.unlock();
    }
} else {
    // 获取锁失败
}

示例说明

示例一：线程安全的计数器

下面是一个使用ReentrantLock实现线程安全的计数器的例子：

public class Counter {
    private int count = 0;
    private ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

在这个计数器中，increment()方法加锁后增加计数器的值，getCount()方法加锁后获取计数器的值。

示例二：死锁的解决

下面是一个使用ReentrantLock解决死锁的例子：

public class DeadlockDemo {
    private ReentrantLock lock1 = new ReentrantLock();
    private ReentrantLock lock2 = new ReentrantLock();

    public void method1() {
        lock1.lock();
        try {
            Thread.sleep(1000);
            lock2.lock();
            try {
                // 互斥代码
            } finally {
                lock2.unlock();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock1.unlock();
        }
    }

    public void method2() {
        lock2.lock();
        try {
            Thread.sleep(1000);
            lock1.lock();
            try {
                // 互斥代码
            } finally {
                lock1.unlock();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock2.unlock();
        }
    }
}

在这个例子中，如果使用synchronized关键字进行同步，代码可能会发生死锁。而使用ReentrantLock可以解决这个问题。

总结

ReentrantLock类为Java多线程编程中提供了一种可重入的互斥锁机制。与synchronized关键字相比，ReentrantLock提供了更灵活和精细的锁定控制。但是，在使用ReentrantLock时需要注意代码的正确性和线程安全性。