Lock & Synchronized

1. ConcurrentHashMap在Jdk1.7的实现是:Segment +单向链表+ReentrantLock   实现
2. ConcurrentHashNap在Jdk1.8的实现是:Node+单向链表+红黑树的结构+CAS+Synchronized+Volatile 实现.

这里所谓的安全只能针对同一时间,的put操作和get操作的安全cuiyaonan2000@163.com.这里整理一下Synchronized 和 ReentrantLock的相关信息

巨人肩膀:

1. Synchronized与ReentrantLock区别总结（简单粗暴，一目了然）_奋力奔跑的蜗牛的博客-CSDN博客_synchronized和reentrantlock
2. Java并发编程：Synchronized底层优化（偏向锁、轻量级锁） - liuxiaopeng - 博客园

synchronized是Java的关键字,而Lock是在java.util.concurrent下的一个类.由此可以明确synchronized是由Jvm底层来实现的锁,而Lock是由Api即代码层面实现的锁(JDK 1.5之后).

参照如下代码,可以看到Lock的实现有3步,而synchornized则省事一点(但是不够灵活)

1. 创建Lock的实现类(Lock是个接口,它的实现类其实有很多不止ReentrantLock )
2. 调用lock()方法加锁
3. 调用unlock()方法解锁

package nan.yao.cui.test;

import java.util.concurrent.ThreadPoolExecutor;


public class Test01 implements Runnable{

    public class MyThread implements Runnable{
        @Override
        public void run() {

        }
    }

    private static Integer theNum = 0;

    private static Integer theNum2 = 0 ;

    public static void main(String[] args) throws Exception {
        Test01 test01 = new Test01();
        for(int i = 1; i<=100 ;i++){
            Thread tempThread = new Thread(test01);
            tempThread.start();
        }

        theNum2 =1000;
        Thread.sleep(5000);

        System.out.println("最终结果是"+theNum2);

    }

    public void testSynchronizedStatement(){
//        System.out.println(Thread.currentThread().getName()+"正在处理theNum2开始");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        synchronized (theNum2){
            theNum2+=1;
            System.out.println(Thread.currentThread().getName()+"处理theNum2的结果是:"+theNum2+" 时间是:"+System.currentTimeMillis());
        }

    }

    public synchronized void testSynchronized(){
        ++theNum;
        System.out.println(Thread.currentThread().getName()+"开始睡眠");
        try {
            Thread.sleep(20000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(Thread.currentThread().getName()+"计算的结果是:"+theNum);

    }

    @Override
    public void run() {
        testSynchronizedStatement();
    }
}

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

监视器锁本质又是依赖于底层的操作系统的Mutex Lock来实现的。而操作系统实现线程之间的切换这就需要从用户态转换到核心态，这个成本非常高，状态之间的转换需要相对比较长的时间，这就是为什么Synchronized效率低的原因。因此，这种依赖于操作系统Mutex Lock所实现的锁我们称之为“重量级锁”。

JDK中对Synchronized做的种种优化，其核心都是为了减少这种重量级锁的使用。JDK1.6以后，为了减少获得锁和释放锁所带来的性能消耗，提高性能，引入了“轻量级锁”和“偏向锁”。

总的来说JDK1.6以后 synchronized不在只有1中实现方式了还是额外增加2中实现方式.所以锁的状态就分为了如下4中:

1. 无锁状态
2. 偏量锁
3. 轻量锁
4. 重量锁

当我们在代码中使用synchronized的时候JVM一开始模认使用的是偏量锁,随着并发量的升级,就会从偏量锁升级为轻量锁,最后直至重量锁. 这个过程是不可逆的.可以通过设置JVM的环境变量,来设置synchronized的默认等级,即-XX:-UseBiasedLocking

synchronized使用在方法上,表示拥有该方法的对象是被监控对象.当调用该对象的synchronized方法时,就会针对该对象的锁加1. 此时如果该方法有2个synchronized方法,则都会被限制.因为被监控对象是一样的.所以我们更多的时候我们写synchronized应该使用语句块.

同理一个方法内的synchronized语句块,当1个进程进入该语句块后,其它线程则要等待,但是等待线程可以把synchronized语句块意外的语句继续执行(确切的说是synchronized语句块之前的代码能背执行).所以合理的使用synchronized尤其重要cuiyaonan2000@163.com

自从1.6以后官方推荐使用synchronized.但是在一些复杂情况下Lock具有更好的适应性.也就是Lock提供了synchronized所没有的功能

1. Lock提供了公平锁,synchronized只有非公平锁
2. Lock支持等待中断,等待超时,尝试获取锁,synchronized不支持
3. Lock可以关联多个条件,synchronized只能关联一个条件

多个线程等待同一个锁时，必须按照申请锁的时间顺序获得锁.

Synchronized是非公平锁，ReentrantLock默认的构造函数是创建的非公平锁，可以通过参数true设为公平锁，但公平锁表现的性能不是很好。

持有锁的线程长期不释放的时候，正在等待的线程可以选择放弃等待，这相当于Synchronized来说可以避免出现死锁的情况

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