synchronized就是一种最简单的控制方法，它决定了一个线程释放可以访问临界区资源。
同时，Object.wait()方法和Object.notify()方法起到了线程等待和通知的作用。

ReenterLock重入锁可以完全替代关键字Synchoronized.重入锁是Synchoronized、Object.wait()方法和Object.notify()方法的替代品(或者说是增强版)。

在 Java 中，ReentrantLock（可重入锁）是一种支持重进入的锁，允许同一个线程多次获得同一把锁。这种锁的主要特点是，当线程尝试获取一个已经由它自己持有的锁时，会成功获取，并且计数器会递增。每次释放锁时，计数器会递减，只有当计数器变为零时，锁才会完全释放。

以下是一个简单的示例，演示了如何使用 ReentrantLock

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

public class ReentrantLockExample {
    private final Lock lock = new ReentrantLock();
    private int counter = 0;

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

    public void runExample() {
        Runnable incrementTask = () -> {
            for (int i = 0; i < 5; i++) {
                incrementCounter();
                System.out.println(Thread.currentThread().getName() + " - Counter: " + counter);
            }
        };

        // 创建两个线程并启动
        Thread thread1 = new Thread(incrementTask, "Thread 1");
        Thread thread2 = new Thread(incrementTask, "Thread 2");

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

    private void incrementCounter() {
        lock.lock();
        lock.lock(); // 获取锁
        try {
            counter++;
        } finally {
            lock.unlock(); // 释放锁
            lock.unlock();
        }
    }
}

一个线程连续两次获得同一把锁是允许的。如果不允许这么操作，那么同一个线程在第2次获得锁时，
将会和自己产生死锁。程序就会卡死在第2次申请锁的过程中。如果同一个线程多次获得锁，
那么在释放锁的时候，也必须释放相同次数，如果释放锁的次数多了，那么会得到一个
java.lang.IllegalMonitorStateException异常，反之，如果释放的次数少了，那么相当于线程还持有这个锁，
因此，其他线程也无非进入临界区。