Synchronized实现原理及和Lock的区别

Synchronized

偏向锁，轻量级锁，重量级锁

偏向锁：对象头存储线程ID，可重入（根据线程ID判断）

轻量级锁：复制对象头到Lock Record 记录锁信息，拥有锁复制的Lock Rrecord 指向对象头,自旋获取锁

重量级锁：moniter监控，阻塞

Synchronized不同使用方法区别：

可重入锁

可重入锁又名递归锁，是指在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。说的有点抽象，下面会有一个代码的示例。

对于Java ReentrantLock而言, 他的名字就可以看出是一个可重入锁，其名字是Re entrant Lock重新进入锁。
对于Synchronized而言，也是一个可重入锁。可重入锁的一个好处是可一定程度避免死锁。
```
synchronized void setA() throws Exception{

    Thread.sleep(1000);

    setB();

}

synchronized void setB() throws Exception{

    Thread.sleep(1000);

}
```
上面的代码就是一个可重入锁的一个特点，如果不是可重入锁的话，setB可能不会被当前线程执行，可能造成死锁。

Synchronized和ReentrantLock区别：

1.比Synchronized更灵活

2.lock()获取锁，unlock()释放锁,要手动在finally中调用unlock()释放锁。

3.Synchronized惊群效应

Synchronized中的wait和notify ，而Lock是借助于Condition类实现，更灵活，可以选择性的进行线程通知，在调度线程上更加灵活。

Synchronized惊群效应，当有一个线程获取锁时候，其他线程进入WaitSet队列，wait()之后的nofity()时线程在争夺同一把锁的时候是随机的，谁抢到就给谁。 notifyAll() 会有一种惊群效应，一旦锁被释放了，所有的wait线程被唤醒。被通知的线程是有JVM 随机选择的 ,Synchronized就相当于整个Lock对象中只有一个单一的Condition对象，所有的线程都注册在它一个对象的身上，线程开始notiifyAll()时，需要通知所有的WAITING线程，没有选择权，会出现相当大的效率问题。

4.Lock对象可以创建多个Condition（对象监视器）实例，线程对象可以注册在指定的Condition中，从而可以选择性的进行线程的通知，在调度线程上更加灵活。

 Lock lock=new ReentrantLock();

 Condition condition=lock.newCondition();

  condition.await();
  condition.signal();
  condition.signalAll();

Condition中的signalAll

　　　　 /** 从Condition中移动所有的等待线程到 拥有锁队列里

         * Moves all threads from the wait queue for this condition to

         * the wait queue for the owning lock.

         * 是 queue队列而不是waitSet 集合

         * @throws IllegalMonitorStateException if {@link #isHeldExclusively}

         *         returns {@code false}

         */

        public final void signalAll() {

            if (!isHeldExclusively())

                throw new IllegalMonitorStateException();

            Node first = firstWaiter;

            if (first != null)

                doSignalAll(first);

        }

/**

         * Removes and transfers all nodes.

         * @param first (non-null) the first node on condition queue

         */

        private void doSignalAll(Node first) {

            lastWaiter = firstWaiter = null;

            do {

                Node next = first.nextWaiter;

                first.nextWaiter = null;

                transferForSignal(first);

                first = next;

            } while (first != null);

        }

为什么会有偏向锁，轻量级锁，重量级锁：

1.为什么要引入偏向锁？

因为经过HotSpot的作者大量的研究发现，大多数时候是不存在锁竞争的，常常是一个线程多次获得同一个锁，因此如果每次都要竞争锁会增大很多没有必要付出的代价，为了降低获取锁的代价，才引入的偏向锁。

2.为什么要引入轻量级锁？

轻量级锁考虑的是竞争锁对象的线程不多，而且线程持有锁的时间也不长的情景。因为阻塞线程需要CPU从用户态转到内核态，代价较大，如果刚刚阻塞不久这个锁就被释放了，那这个代价就有点得不偿失了，因此这个时候就干脆不阻塞这个线程，让它自旋这等待锁释放。

3.轻量级锁什么时候升级为重量级锁？

自旋的时间太长也不行，因为自旋是要消耗CPU的，因此自旋的次数是有限制的，比如10次或者100次，如果自旋次数到了线程1还没有释放锁，或者线程1还在执行，
线程2还在自旋等待，这时又有一个线程3过来竞争这个锁对象，那么这个时候轻量级锁就会膨胀为重量级锁。重量级锁把除了拥有锁的线程都阻塞，防止CPU空转。
重量级锁线程会被挂起park，耗性能

Synchronized的锁升级过程