ReentrantLock 锁代码示例

以下是 ReentrantLock 锁的代码示例：

import java.util.concurrent.locks.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() {
        return count;
    }
}

在上面的示例中，我们使用 ReentrantLock 类来保护 Counter 类中的 count 变量。在 increment() 方法中，我们首先调用 lock() 方法来获得锁，然后执行 count++ 操作，最后调用 unlock() 方法来释放锁。这样，我们就可以保证 count 变量的线程安全性。

相关问题

ReentrantLock尝试获取锁的代码

在使用ReentrantLock时，可以使用`tryLock()`方法来尝试获取锁。该方法会立即返回一个布尔值，表示是否成功获取锁。

代码示例：

import java.util.concurrent.locks.ReentrantLock;

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

    public void doSomething() {
        if (lock.tryLock()) {
            try {
                // 成功获取锁后执行的代码逻辑
                System.out.println(Thread.currentThread().getName() + " acquired the lock");
                // 执行其他业务逻辑
            } finally {
                lock.unlock();
            }
        } else {
            // 未成功获取锁时的处理逻辑
            System.out.println(Thread.currentThread().getName() + " failed to acquire the lock");
            // 可以选择等待一段时间后重新尝试获取锁，或者执行其他业务逻辑
        }
    }

    public static void main(String[] args) {
        ReentrantLockExample example = new ReentrantLockExample();
        // 创建多个线程尝试获取锁
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                example.doSomething();
            }).start();
        }
    }
}

在上述示例中，多个线程通过调用`doSomething()`方法来尝试获取锁。如果线程成功获取到锁，则输出当前线程名称并执行其他业务逻辑；如果未成功获取到锁，则输出当前线程名称并执行其他处理逻辑。

需要注意的是，`tryLock()`方法是非阻塞的，如果锁已经被其他线程占用，当前线程会立即返回false，而不是等待获取锁。这使得我们可以在获取锁失败时进行其他处理，而不是一直等待锁的释放。

另外，`tryLock()`方法还有一个重载版本，可以指定等待时间，在指定的时间内尝试获取锁，若超时仍未获取到锁，则返回false。例如：`tryLock(long timeout, TimeUnit unit)`。

总之，`tryLock()`方法提供了一种灵活的方式来尝试获取锁，并根据返回的结果来进行相应的处理。

ReentrantLock与ReentrantReadWriteLock代码例子

### 回答1：
以下是使用Java编写的ReentrantLock和ReentrantReadWriteLock的代码示例：

ReentrantLock示例：

import java.util.concurrent.locks.ReentrantLock;

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

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

    public void decrement() {
        lock.lock();
        try {
            count--;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        return count;
    }
}

ReentrantReadWriteLock示例：

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Cache {
    private Object data = null;
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public Object getData() {
        lock.readLock().lock();
        try {
            return data;
        } finally {
            lock.readLock().unlock();
        }
    }

    public void setData(Object data) {
        lock.writeLock().lock();
        try {
            this.data = data;
        } finally {
            lock.writeLock().unlock();
        }
    }
}

在这些示例中，ReentrantLock和ReentrantReadWriteLock都被用于控制共享资源的访问。使用lock()方法获取锁，使用unlock()方法释放锁。在ReentrantReadWriteLock示例中，readLock()和writeLock()方法被用于获取读锁和写锁，以控制对共享数据的读和写访问。

### 回答2：
ReentrantLock（可重入锁）和ReentrantReadWriteLock（可重入读写锁）是Java并发包中提供的两种锁机制。它们都是可重入锁，意味着同一个线程可以多次获取同一个锁。

首先，我们来看一下ReentrantLock的代码例子。在下面的示例中，有两个线程分别尝试获取同一把锁，并对共享资源进行操作。

import java.util.concurrent.locks.ReentrantLock;

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

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            lock.lock();
            try {
                // 对共享资源进行操作
                System.out.println("Thread 1 is accessing the shared resource.");
            } finally {
                lock.unlock();
            }
        });

        Thread thread2 = new Thread(() -> {
            lock.lock();
            try {
                // 对共享资源进行操作
                System.out.println("Thread 2 is accessing the shared resource.");
            } finally {
                lock.unlock();
            }
        });

        thread1.start();
        thread2.start();
    }
}

上述代码中，两个线程分别通过lock()方法获取锁，并在finally块中使用unlock()方法释放锁。这就确保了同一时间只能有一个线程访问共享资源。

接下来，我们来看一下ReentrantReadWriteLock的代码例子。与ReentrantLock不同，ReentrantReadWriteLock可以支持多个读线程同时访问共享资源，但只允许一个写线程进行写操作。

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReentrantReadWriteLockExample {
    private static final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private static final ReentrantReadWriteLock.ReadLock readLock = lock.readLock();
    private static final ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();
    private static int sharedResource = 0;

    public static void main(String[] args) {
        Thread reader1 = new Thread(() -> {
            readLock.lock();
            try {
                // 读取共享资源
                System.out.println("Reader 1 is reading the value: " + sharedResource);
            } finally {
                readLock.unlock();
            }
        });

        Thread reader2 = new Thread(() -> {
            readLock.lock();
            try {
                // 读取共享资源
                System.out.println("Reader 2 is reading the value: " + sharedResource);
            } finally {
                readLock.unlock();
            }
        });

        Thread writer = new Thread(() -> {
            writeLock.lock();
            try {
                // 修改共享资源
                sharedResource = 100;
                System.out.println("Writer is updating the value to: " + sharedResource);
            } finally {
                writeLock.unlock();
            }
        });

        reader1.start();
        reader2.start();
        writer.start();
    }
}

在上述代码中，我们使用了readLock()和writeLock()方法来获取读锁和写锁，然后通过lock()方法进行加锁，通过unlock()方法进行解锁。这样保证了在写操作时，不允许其他线程同时进行读或写操作。

以上是ReentrantLock和ReentrantReadWriteLock的简单代码例子，它们在多线程并发操作中提供了可靠的锁机制，确保数据的安全性和一致性。

### 回答3：
ReentrantLock和ReentrantReadWriteLock是Java.util.concurrent包中的两个线程同步工具。它们都实现了Lock接口，可以用于对共享资源进行线程安全的访问。

首先，我们来看一下ReentrantLock的代码示例：

import java.util.concurrent.locks.ReentrantLock;

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

    public void printMessage(String message) {
        lock.lock();
        try {
            // 访问共享资源
            System.out.println(message);
        } finally {
            lock.unlock(); // 释放锁
        }
    }
}

在上面的示例中，我们创建了一个ReentrantLock对象lock，并将它用于保护printMessage方法中的临界区。lock.lock()用于获取锁，如果锁已被其他线程占用，则当前线程等待。然后在try块中访问共享资源，最后在finally块中使用lock.unlock()来释放锁。

接下来，我们看一下ReentrantReadWriteLock的代码示例：

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReentrantReadWriteLockExample {
    private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    private String data = "Shared data";

    public String readData() {
        rwLock.readLock().lock();
        try {
            // 读取共享数据
            return data;
        } finally {
            rwLock.readLock().unlock(); // 释放读锁
        }
    }

    public void writeData(String input) {
        rwLock.writeLock().lock();
        try {
            // 更新共享数据
            data = input;
        } finally {
            rwLock.writeLock().unlock(); // 释放写锁
        }
    }
}

在上述示例中，我们创建了一个ReentrantReadWriteLock对象rwLock，并将它用于保护readData和writeData方法中的临界区。rwLock.readLock()用于获取读锁，rwLock.writeLock()用于获取写锁。多个线程可以同时获取读锁，但只有一个线程可以获取写锁。除非有线程持有写锁，否则其他线程可以同时获取读锁。在读操作中，我们使用读锁保护共享数据的只读访问，而在写操作中，我们使用写锁保护共享数据的更新。

以上是ReentrantLock和ReentrantReadWriteLock的简单代码示例，它们可以帮助我们在多线程环境中实现资源的安全访问。