在Java中，tryLock(long time, TimeUnit unit)方法是用来在指定的时间内尝试获取锁的-CSDN博客

本文链接：https://blog.csdn.net/blog_programb/article/details/138057464

在Java中，tryLock(long time, TimeUnit unit)方法是用来在指定的时间内尝试获取锁的。如果在指定时间内获取到锁，则返回true；否则返回false。

以下是一个示例代码，演示了tryLock(long time, TimeUnit unit)方法的使用：

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

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

    public static void main(String[] args) {
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    if (lock.tryLock(5, TimeUnit.SECONDS)) {
                        System.out.println("Thread 1 acquired the lock");
                        // 在这里执行需要加锁的代码
                    } else {
                        System.out.println("Thread 1 failed to acquire the lock");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    if (lock.isHeldByCurrentThread()) {
                        lock.unlock();
                    }
                }
            }
        });

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    if (lock.tryLock(5, TimeUnit.SECONDS)) {
                        System.out.println("Thread 2 acquired the lock");
                        // 在这里执行需要加锁的代码
                    } else {
                        System.out.println("Thread 2 failed to acquire the lock");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    if (lock.isHeldByCurrentThread()) {
                        lock.unlock();
                    }
                }
            }
        });

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

在上面的示例中，我们创建了一个ReentrantLock对象，并使用tryLock(long time, TimeUnit unit)方法尝试获取锁。如果在5秒内获取到锁，则输出相应的信息；否则输出获取锁失败的信息。在代码的最后，我们使用unlock()方法释放锁。
ReentrantLock是Java中的一种锁实现，它与synchronized关键字具有相似的语义。ReentrantLock通过调用lock()方法来获取锁，相比synchronized更加灵活。此外，ReentrantLock还提供了一些实用的方法，可以实现一些synchronized无法做到的细节控制，比如控制公平性和定义条件等。但需要注意的是，在使用ReentrantLock时，必须明确调用unlock()方法来释放锁，否则会一直持有该锁。

以下是一个使用ReentrantLock的示例代码：

import java.util.concurrent.locks.ReentrantLock;

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

    public void performTask() {
        lock.lock(); // 获取锁
        try {
            // 执行需要同步的代码块
            // ...
        } finally {
            lock.unlock(); // 释放锁
        }
    }
}

Java中的synchronized和ReentrantLock是两种可重入锁，它们有以下区别：

用法不同：
- synchronized是Java中的关键字，可以用于修饰方法或代码块，使用简单方便。
- ReentrantLock是一个类，需要手动创建实例，并通过lock()和unlock()方法来获取和释放锁。
锁的获取方式不同：
- synchronized是隐式获取锁，当线程进入synchronized修饰的方法或代码块时，会自动获取锁，执行完毕后自动释放锁。
- ReentrantLock是显式获取锁，需要手动调用lock()方法获取锁，并在finally块中调用unlock()方法释放锁。
锁的可中断性不同：
- synchronized在获取锁时，如果其他线程已经持有锁，当前线程会进入阻塞状态，直到获取到锁或被中断。
- ReentrantLock可以设置锁的可中断性，通过lockInterruptibly()方法可以在等待锁的过程中响应中断。
锁的公平性不同：
- synchronized是非公平锁，无法保证等待时间最长的线程优先获取锁。
- ReentrantLock可以设置为公平锁，保证等待时间最长的线程优先获取锁。
功能扩展性不同：
- ReentrantLock提供了更多的功能，如可定时的、可轮询的、可中断的锁获取方式，以及条件变量等高级特性。
  在Java中，synchronized和ReentrantLock都是常见的加锁方法，用于实现线程同步。它们的使用场景和常用程度有所不同。

synchronized是Java中的关键字，用于实现线程同步。它是一种隐式锁，可以用于修饰方法或代码块。synchronized关键字的使用相对简单，不需要显式地创建锁对象，而是使用对象的内置锁（也称为监视器锁）来实现线程同步。synchronized关键字的使用非常广泛，特别是在单线程环境下或者对于简单的线程同步需求，synchronized是首选的选择。

ReentrantLock是Java中的一个类，也用于实现线程同步。它是一种显式锁，需要显式地创建锁对象，并在需要同步的代码块中使用lock()和unlock()方法来获取和释放锁。相比于synchronized关键字，ReentrantLock提供了更多的灵活性和功能，例如可重入性、公平性、条件变量等。ReentrantLock在动态高并发的场景下更加推荐使用，因为它提供了更多的控制和扩展性。

综上所述，synchronized关键字更常用于简单的线程同步需求，而ReentrantLock更常用于复杂的线程同步需求或者对锁的控制更加精细的场景。
ReentrantLock是Java中的一个锁实现，相于传统的synchronized关键字，它具有以下优势：

可重入性：ReentrantLock允许同一个线程多次获取锁，而不会发生死锁。这对于一些复杂的线程交互场景非常有用。
公平性：ReentrantLock可以选择公平锁或非公平锁。公平锁会按照线程请求锁的顺序来获取锁，而非公平锁则允许插队。这样可以避免某些线程长时间等待锁的情况，提高了整体的吞吐量。
条件变量：ReentrantLock提供了Condition接口，可以通过它实现线程间的协调和通信。通过Condition，我们可以实现更加灵活的线程等待和唤醒机制。
可中断性：ReentrantLock提供了可中断的获取锁的方式。当一个线程在等待锁的过程中，可以通过中断来取消等待，避免线程长时间阻塞。
锁的细粒度控制：ReentrantLock允许我们通过lock()和unlock()方法手动控制锁的获取和释放，这样可以更加灵活地控制锁的粒度，提高代码的性能。

下面是一个使用ReentrantLock的示例代码：

import java.util.concurrent.locks.ReentrantLock;

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

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            lock.lock();
            try {
                // 执行线程1的任务
            } finally {
                lock.unlock();
            }
        });

        Thread thread2 = new Thread(() -> {
            lock.lock();
            try {
                // 执行线程2的任务
            } finally {
                lock.unlock();
            }
        });

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