相似点：

两者都是可重入锁
“可重入锁”概念是：自己可以再次获取自己的内部锁。比如，一个线程获得了某个对象的锁，此时这个对象锁还没有释放，当其再次想要获取这个对象的锁时，还可以再获取的；如果不可锁重入的话，就会造成死锁；同一个线程每次获取锁，锁的计数器都自增1，所以要等到锁的计数器下降为0时，才能最终释放锁。

功能区别

这两种方式最大的区别就是对于synchronized来说，它是Java语音关键字，是原生语法层面的互斥，需要JVM实现。而ReentrantLock它是JDK1.5之后提供的API层面的互斥锁，需要lock()和unlock()方法配合try/finally语句来完成。

便利性：

Synchronized的使用方便简洁，并且由编译器去保证锁的加锁和释放锁，而ReentrantLock则需要手动声明加锁和释放锁的方法，为了避免忘记手动释放锁，最好是在finally中声明释放锁。

Synchronized

每个java对象都可以用做一个实现同步的锁，这些锁被称为内置锁(Intrinsic Lock)或者监视器锁(Monitor Lock)

要实现这个目标，则每个java对象都应该与某种类型的锁数据关联。

这意味着，我们需要一个存储锁数据的地方，并且每一个对象都应该有这么个地方。
在java中，这个地方就是对象头。
其实Java对象头和对象的关系很像Http请求的http header 和http body的关系。

实现synchronized的基础：Java对象头+Monitor
对象头的结构如下：

image.png
Synchronized经过编译后，会在同步块前后分别形成monitorenter和monitorexit两个字节码指令，在执行monitorenter指令时，首先要尝试获取对象锁，如果对象没有被锁定，或者当前已经拥有这个对象锁，把锁的计数器加1，相应的在执行monitorexit指令时，会将计数器减1，当计数器为0时，锁就被释放了。如果获取锁失败，那当前线程就要阻塞，直到对象锁被另一个线程释放为止。

在synchronized锁中，这个存储在对象头的 Mark Word中的锁信息是一个指针，它指向一个monitor对象(也称为管程或监视器锁)的起始地址。这样，我们就通过对象头，将每一个对象与monitor关联起来。

image.png

图片的最左边是线程的调用栈，它引用了堆中的一个对象，该对象的对象头部分记录了该对象所使用的监视器锁，该监视器锁指向了一个monitor对象。

那么这个monitor对象是什么呢？在Java虚拟机中，monitor是由ObjectMonitor实现的，其主要数据结果如下:

ObjectMonitor() {
    _header       = NULL;
    _count        = 0;
    _waiters      = 0,
    _recursions   = 0;
    _object       = NULL;
    _owner        = NULL;
    _WaitSet      = NULL;
    _WaitSetLock  = 0 ;
    _Responsible  = NULL ;
    _succ         = NULL ;
    _cxq          = NULL ;
    FreeNext      = NULL ;
    _EntryList    = NULL ;
    _SpinFreq     = 0 ;
    _SpinClock    = 0 ;
    OwnerIsThread = 0 ;
    _previous_owner_tid = 0;
 }

上面这些字段中，我们只需要重点关注三个字段:

• _owner : 当前拥有该 ObjectMonitor 的线程
• _EntryList: 当前等待锁的集合
• _WaitSet: 调用了Object.wait()方法而进入等待状态的线程的集合，

在java中，每一个等待锁的线程都会被封装成ObjectWaiter对象，当多个线程同时访问一段同步代码时，首先会被扔进 _EntryList 集合中，如果其中的某个线程获得了monitor对象，他将成为 _owner，如果在它成为 _owner之后又调用了wait方法，则他将释放获得的monitor对象，进入 _WaitSet集合中等待被唤醒。

image.png

另外，因为每一个对象都可以作为synchronized的锁，所以每一个对象都必须支持wait()，notify，notifyAll方法，使得线程能够在一个monitor对象上wait, 直到它被notify。这也就解释了这三个方法为什么定义在了Object类中——这样，所有的类都将持有这三个方法。

2.RreentrantLock

由于ReentrantLock是java.util.concurrent包下面提供的一套互斥锁，相比Synchronized类提供了一些高级的功能，主要有一下三项：

2.1 等待可中断，持有锁的线程长期不释放的时候，正在等待的线程可以选择放弃等待，这相当于Synchronized来说可以避免出现死锁的情况。通过lock.lockInterruptibly()来实现这个机制。

2.2 公平锁，多个线程等待同一个锁时，必须按照申请锁的时间顺序获得锁，Synchronized锁非公平锁，ReentrantLock默认的构造函数是创建的非公平锁，可以通过参数true设为公平锁，但公平锁表现的性能不是很好。

2.3 锁绑定多个条件，一个ReentrantLock对象可以同时绑定对个对象。ReentrantLock提供了一个Condition（条件）类，用来实现分组唤醒需要唤醒的线程们，而不是像synchronized要么随机唤醒一个线程要么唤醒全部线程

3.ReentrankLock实现原理

简单来说，ReentrankLock的实现时一种自旋锁(是指当一个线程在获取锁的时候，如果锁已经被其它线程获取，那么该线程将循环等待，然后不断的判断锁是否能够被成功获取，直到获取到锁才会退出循环。)，基于AQS实现,通过循环调用CAS操作来实现加锁。具体可以看下这个地址介绍https://segmentfault.com/a/1190000017372067 写的非常好。

4.Java中锁的分类

1、 分类一：乐观锁与悲观锁
a)悲观锁：认为其他线程会干扰本身线程操作，所以加锁
具体表现形式：synchronized关键字和lock实现类

b)乐观锁：认为没有其他线程会影响本身线程操作，所以不加锁
具体表现形式：java的原子类的递增操作
原理：采用cas算法

c)Cas算法：交换与比较
涉及三个数：需要读写的内存值V，进行比较的值A，要写入的新值B
具体操作：若A=V,就用B更新V,否则不进行任何操作
会用ABA问题：cas算法需要判断内存值V是否发生变化，如果a值变成b值然后又变回a值，cas算法就会无法判断，产生错误。解决上问题：在变量前添加版本号，将aba变成1a2b3c
循环时间长开销大，因为自旋需要消耗cpu 只能保证一个共享变量的原子操作

2、 分类二
a) 重入锁：支持重进入的锁，排它锁

3、 分类三
a)读写锁：一对锁，读锁，写锁，在同一时刻允许多线程访问