synchronized 和 ReentrantLock 之间的区别

  在Java编程中，synchronized和ReentrantLock是两种常用的线程同步机制。虽然它们的目的都是为了保证多个线程之间的数据同步和互斥访问，但在实际应用中，它们之间还是存在一些区别。

  synchronized是Java语言提供的一种内置的同步机制，而ReentrantLock是一个基于JUC（Java Util Concurrent）框架的锁。

  在使用上:

     synchronized是通过关键字来实现的，而ReentrantLock则是通过类来实现的。

     synchronized是隐式的，即编译器会自动添加锁的获取和释放操作，

     ReentrantLock是显式的，需要程序员手动调用lock()和unlock()方法来获取和释放锁。

代码如下:

import java.util.concurrent.locks.ReentrantLock;

public class emo9 {
    public static void main(String[] args) {
        ReentrantLock reentrantLock = new ReentrantLock();
        try{
            //开锁
            reentrantLock.lock();
        }finally {
            //解锁
            reentrantLock.unlock();
        }
    }
}

  另外，ReentrantLock相比synchronized提供了更灵活的锁操作。例如，ReentrantLock可以实现公平锁和非公平锁。

ReentrantLock reentrantLock = new ReentrantLock(true);
//一般默认非公平锁,true为公平锁,false为非公平锁

   synchronized只能实现非公平锁。

  此外，ReentrantLock还提供了tryLock()方法，可以尝试获取锁而不会一直阻塞等待。ReentrantLock类提供了tryLock()方法。这个方法尝试获取锁，如果锁可用，则获取锁并立即返回true；如果锁不可用，则立即返回false，而不会阻塞线程。tryLock()方法可以用于实现非阻塞的锁获取逻辑。

  示例代码，演示了ReentrantLock的tryLock()方法的用法：

import java.util.concurrent.locks.ReentrantLock;

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

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            if (lock.tryLock()) {
                try {
                    System.out.println("Thread 1 acquired the lock");
                    Thread.sleep(1000); // 模拟线程执行一段时间
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                    System.out.println("Thread 1 released the lock");
                }
            } else {
                System.out.println("Thread 1 failed to acquire the lock");
            }
        });

        Thread t2 = new Thread(() -> {
            if (lock.tryLock()) {
                try {
                    System.out.println("Thread 2 acquired the lock");
                    //无论是否发生异常，都会执行的代码块，通常用于资源释放或清理操作。
                } finally {
                    lock.unlock();
                    System.out.println("Thread 2 released the lock");
                }
            } else {
                System.out.println("Thread 2 failed to acquire the lock");
            }
        });
        
        t1.start();
        t2.start();
    }
}

  在这个示例中，我们创建了一个ReentrantLock对象，并在两个线程中使用tryLock()方法尝试获取锁。第一个线程（t1）成功获取锁并执行一段时间后释放，而第二个线程（t2）在第一个线程释放锁后成功获取锁。

  在性能上:

  一般情况下，synchronized 关键字和 ReentrantLock 的性能表现是非常接近的。在 JDK 1.6 之后，synchronized 关键字在实现上进行了很多优化，性能已经得到了很大的改善，因此在低并发情况下，synchronized 的性能可能会比 ReentrantLock 稍微好一些。

   然而，在高并发情况下，ReentrantLock 的性能通常会比 synchronized 更好。这是因为 ReentrantLock 提供了更多的灵活性和控制，例如提供了可中断的锁获取、超时的锁获取、公平性选择等功能，使得在高并发环境下能够更好地控制线程的调度和性能。

  另外，ReentrantLock 也可以通过使用 Condition 来实现更灵活的线程通信机制，这在某些复杂的多线程场景下会更加方便。

  总的来说，synchronized是一种简单易用的同步机制，适用于大多数情况下。而ReentrantLock则提供了更多的灵活性和性能优势，适用于一些特殊的场景。在实际开发中，我们可以根据具体情况选择合适的同步机制来保证程序的正确性和性能。

  感谢大家观看!!!希望大家多多指出不足之处!!!