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的锁升级过程