关于java:Java锁一volatilesynchronized详解

一、锁的基础知识

锁的类型

锁从主观上分为乐观锁和乐观锁。

乐观锁：乐观锁是一种乐观思维，认为写少读多，遇到并发写的可能性比拟低，读数据的时候认为他人不会批改，所以读的时候不会上锁，然而在写的时候会判断一下在此期间有没有他人去更新这个数据，采取的是先读取以后版本号，而后加锁操作，写完的时候读取最新版本号做记录的版本号做比拟一样则胜利，如果失败则反复读-比拟-写的操作。Java中的乐观锁根本都是通过CAS操作实现的，java.util.concurrent.atomic包下的原子变量。CAS(compare and swap)比拟替换是一种更新的原子操作，比拟以后值和传入值是否一样，一样则更新，否则则失败。
乐观锁：乐观锁就是乐观思维，认为写多且遇到并发性的可能性高，每次拿数据的时候都认为他人为批改，所以每次读写的时候都会上锁，这样他人想读写数据的时候都会block(阻塞)晓得拿到锁。Java中乐观锁就是syschronized，AQS框架下的锁则是先尝试CAS乐观锁获取锁，如果获取不到，才会转为乐观锁，如ReentrantLock。

Java中的锁

在Java中次要有两种锁加锁机制：

syschronized关键字润饰
java.util.concurrent.Lock，Lock是一个接口，有很多实现类比方ReentrantLock。

二、volatile

可见性

public class VolatileTest {
    public static void main(String[] args) {
        final  VT vt = new VT();
        Thread thread01 = new Thread(vt);
        Thread thread02 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException ignore) { }
                vt.sign = true;
                System.out.println("vt.sign = true 告诉 while (!sign) 完结！");
            }
        });
        thread01.start();
        thread02.start();
    }
}

class VT implements Runnable {
    public boolean sign = false;
    @Override
    public void run() {
        while (!sign) {

        }
        System.out.println("你坏");
    }
}

下面的代码是两个线程同时操作一个变量，程序心愿当sign在线程Thread01被操作vt.sign = true时，线程Thread02输入你坏。

实际上这段代码永远不会输入你坏，而是始终处于死循环。这是为什么呢？接下来咱们一步步解说验证。

咱们把sign关键字加上volatile关键字。

public volatile boolean sign = false;

这个时候会输入你坏。

volatile关键字是Java虚拟机提供的最轻量级锁的同步机制，作为一个修饰符呈现，同来润饰变量，不含括局部变量，用来保障对所有线程可见性。

无volatile关键字润饰时内存变动

当没有volatile关键字润饰的时候，Thread01对变量进行操作，Thead02并不会拿到最新值。

有volatile关键字时内存变动

当有volatile关键字润饰的时候，Thread01对变量进行操作时，会把变量的变动强制刷新到主内存，Thread02获取值时，会把本人内存的sign值过期掉，从主内存读取最新的。

有序性

volatile关键字底层是通过lock指令实现可见性的，lock指令相当于一个内存屏障，保障以下三点：

将本处理器的缓存写入主内存。
重排序时不会把前面的指令从新排序到内存屏障之前。
如果是写入操作会导致其余内存器中对应的内存有效。

总结

volatile关键字会管制被润饰的变量在内存操作的时候会被动把值刷新到主内存，JMM会先将线程对应的CPU内存设置过期，从内存读取最新值。
volatile关键字是通过内存屏障避免指令重排，volatile的内存屏障在读写的时候在前后各增加一个Store屏障来保障从新排序时不会把内存屏障前面的时候指令排序到内存屏障之前。
volatile不能解决原子性，如果须要解决原子性须要synchronized或者lock。

三、synchronized

常识纲要

应用办法

synchronized关键字次要有以下三种应用形式：

润饰实例办法，作用于以后实例加锁，进入同步代码前要获取以后实例的锁。

public class SynchronizedTest implements Runnable{
    private static int i = 0;

    public synchronized void getI(){
        if (i % 1000000 == 0) {
            System.out.println(i);
        }
    }

    public synchronized void increase() {
        i++;
        getI();
    }

    @Override
    public void run() {
        for (int j = 0; j < 1000000; j++) {
            increase();
        }
        System.out.println(i);
    }

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        SynchronizedTest synchronizedTest = new SynchronizedTest();
        executorService.execute(synchronizedTest);
        executorService.execute(synchronizedTest);
        executorService.shutdown();
    }
}

最初后果输入：

上述代码中，创立两个线程同时操作同一个共享资源i，且increase()、get()办法加了synchronized关键字，示意以后线程的锁是实例对象，因为传入线程都是synchronizedTest对象实例是同一个，所以最终后果必定能输入2000000，如果咱们换种形式，传入不同对象，代码如下：

public static void main(String[] args) {
    ExecutorService executorService = Executors.newCachedThreadPool();
    SynchronizedTest synchronizedTest01 = new SynchronizedTest();
    SynchronizedTest synchronizedTest02 = new SynchronizedTest();
    executorService.execute(synchronizedTest01);
    executorService.execute(synchronizedTest02);
    executorService.shutdown();
}

输入如下：

1002588
1641267
1848269

最终必定不是冀望的200000，因为synchronized润饰办法锁的是以后实例，传入不同对象实例线程是无奈保障平安的。

润饰静态方法，作用于以后类对象加锁，进入同步办法前要获取以后类对象的锁。

public class SynchronizedTest implements Runnable{
    private static int i = 0;

    public synchronized static void getI(){
        if (i % 1000000 == 0) {
            System.out.println(i);
        }
    }

    public synchronized static void increase() {
        i++;
        getI();
    }

    @Override
    public void run() {
        for (int j = 0; j < 1000000; j++) {
            increase();
        }
        System.out.println(i);
    }

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        SynchronizedTest synchronizedTest01 = new SynchronizedTest();
        SynchronizedTest synchronizedTest02 = new SynchronizedTest();
        executorService.execute(synchronizedTest01);
        executorService.execute(synchronizedTest02);
        executorService.shutdown();
    }
}

输入如下：

上述代码和第一段代码差不多，只不过increase()、get()办法是静态方法，且也加上了synchronized示意锁的是以后类对象，尽管咱们传入不同的对象，然而最终后果是会输入200000的。

润饰语代码块，指定加锁对象，给对象加锁，进入同步办法前要获取给定对象的锁。

public class SynchronizedTest02 implements Runnable{
    private static SynchronizedTest02 synchronizedTest02 = new SynchronizedTest02();
    private static int i = 0;

    @Override
    public void run() {
        // 传入对象锁以后实例对象
        // 如果是 synchronized (SynchronizedTest02.class) 锁以后类对象
        synchronized (synchronizedTest02){
            for(int j=0;j<1000000;j++){
                i++;
            }
        }
    }

    public static void main(String[] args) throws Exception {
        Thread thread01 = new Thread(synchronizedTest02);
        Thread thread02 = new Thread(synchronizedTest02);
        thread01.start();
        thread02.start();
        Thread.sleep(3000);
        System.out.println(i);
    }
}

上述代码用锁润饰代码块，传入的是对象示意锁的是以后实例对象，如果传入是类示意锁的是类对象。

个性

原子性

原子性示意一个操作不可中断，要么胜利要么失败。

synchroniezd能实现办法同步，同一时间段内只有一个线程能拿到锁，进入到代码执行，从而达到原子性。

底层通过执行mointorenter指令，判断是否有ACC_SYNCHRONIZED同步标识，有示意获取monitor锁，此时计数器+1，办法执行结束，执行mointorexit指定，此时计数器-1，归0开释锁。

可见性

可见性示意一个线程批改了一个共享变量的值，其它线程都可能晓得这个批改。CPU缓存优化、指令重排等都可能导致共享变量修不能立即被其余线程觉察。

synchroniezd通过操作系统内核互斥锁实现可见性，线程开释锁前必须把共享变量的最新值刷新到主内存中，线程获取锁之前会将工作内存中共享值清空，从主内存中获取最新的值。

有序性

程序在执行时，有可能会进行指令重排，CPU执行指令程序不肯定和程序的程序统一。指定重排保障串行语义统一（即重排后CPU执行的执行和程序真正执行程序统一）。synchronized能保障CPU执行指令程序和程序的程序统一。

public class LazySingleton {

    /**
     * 单例对象
     * volatile + 双重检测机制 -> 禁止重排序
     */
    private volatile static LazySingleton instance = null;

    /**
     *   instance = new LazySingleton();
     *   1. 调配对象内存空间
     *   2. 初始化对象
     *   3. 设置instance指向刚调配的内存
     *
     *   JVM和CPU优化, 产生了指令重排, 1-3-2, 线程A执行完3, 线程B执行第一个判断, 间接返回, 这个时候是     *     有问题的。
     *   通过volatile关键字禁止重排序
     * @return
     */
    public static LazySingleton getInstance(){
        if (null == instance) {
            synchronized (LazySingleton.class){
                if (null == instance) {
                    instance = new LazySingleton();
                }
            }
        }
        return instance;
    }
}

synchronized的有序性是保障线程有序的执行，不是避免指令重排序。下面代码如果不加volatile关键字可能导致的后果，就是第一个线程在初始化的时候，设置instance执行调配的内存时，这个时候第二个线程进来了，有指令重排，在第一个判断的时候间接返回，就出错了这个时候instance可能还没初始化胜利。

重入性

synchronized是可重入锁，容许一个线程二次申请本人持有对象锁的临界资源。

public class SynchronizedTest03 extends A {

    public static void main(String[] args) {
        SynchronizedTest03 synchronizedTest03 = new SynchronizedTest03();
        synchronizedTest03.doA();
    }

    public synchronized void doA() {
        System.out.println("子类办法：SynchronizedTest03.doA() ThreadId:" + Thread.currentThread().getId());
        doB();
    }

    public synchronized void doB() {
        System.out.println("子类办法：SynchronizedTest03.doB() ThreadId:" + Thread.currentThread().getId());
        super.doA();
    }
}

class A {
    public synchronized  void doA() {
        System.out.println("父类办法：A.doA() ThreadId:" + Thread.currentThread().getId());
    }
}

下面代码失常输出如下：

子类办法：SynchronizedTest03.doA() ThreadId:1
子类办法：SynchronizedTest03.doB() ThreadId:1
父类办法：A.doA() ThreadId:1

最初失常的输入了后果，并没有产生死锁，阐明synchronized是可重入锁。

synchronized锁对象的时候有个计数器，记录线程获取锁的次数，在执行完对应的代码后计数器就会-1，晓得计数器清0开释锁。

类型和降级

在介绍锁的类型之前先说一下什么是markword，markword是java对象数据结构中的一部分，markword数据在长度为32位和64位虚拟机（未开启压缩指针）中别离是32bit和64bit，它的最初两位bit是锁状态标记位，用来标记以后对象的状态，如下示意：

状态	标记位	贮存内容
无锁（未开启偏差锁）	01	对象哈希码、对象分代年龄
偏差锁（开启偏差锁）	01	偏差线程id、偏差工夫戳、对象分代年龄
轻量级锁	00	指向轻量级锁指针
重量级锁	10	指向重量级锁指针
GC标记	11	空

偏差锁

偏差锁会偏差于第一个拜访锁的线程，如果在运行过程中只有一个线程拜访不存在多个线程争用的状况下，则线程是不须要触发同步的，这个时候就会给线程加一个偏差锁。如果在运行过程中，遇到了其余线程抢占锁，则持有偏差锁的线程会被挂起，JVM会打消它身上的偏差锁，将锁降级至轻量级锁。

UseBiasedLocking 是一个偏差锁查看， 1.6 之后是默认开启的， 1.5 中是敞开的，须要手动开启参数是 XX: UseBiasedLocking=false。

偏差锁获取过程：

拜访markword中偏差锁示意是否为1，锁标记位01，确认为偏差锁状态。
判断markword中线程id是否指向以后线程id，如果是则执行步骤5，如果不是则执行步骤3
如果markword中线程id未指向以后线程id，则通过CAS操作竞争锁。如果竞争胜利，则指向以后线程id，执行步骤5，如果竞争失败，则执行步骤4。
如果CAS竞争锁失败示意有竞争，当达到全局平安点（safepoint）时取得偏差锁的线程会被挂起，偏差锁降级为轻量级锁并撤销偏差锁（撤销偏差锁是会导致stop the word，除GC所需的线程外，所有的线程都进入期待状态，直到GC工作实现），而后被阻塞在平安点的线程会继续执行同步代码。
执行同步代码。

轻量级锁

当锁是偏差锁的时候，在运行过程中发现有其余线程抢占锁，偏差锁就会升级成轻量级锁，其余线程会通过自旋的模式获取锁，不会阻塞，进步性能，毛病是循环会耗费CPU。

轻量级锁加锁过程：

在代码进入同步块的时候，如果同步对象锁状态为无锁状态（锁状态标记位为01状态，是否为偏差锁为0），虚拟机首先将在以后线程的帧栈中建设一个名为索记录（Lock Record）的空间，用于贮存锁对象目前的markword的拷贝，官网称之为 Displaced Mark Word。
拷贝对象的markword到锁记录中。
拷贝胜利后，虚拟机将应用CAS操作尝试将对象的markword更新指向锁记录的指针，并将锁记录里的owner指向对象的markword，如果更新胜利则执行步骤4，否则执行步骤5。
更新胜利示意这个线程就获取到了锁的对象，并且对象的markword锁标记位设置成00，示意此对象处于轻量级锁状态。
如果更新失败了，阐明虚拟机首先会查看对象的markword是否指向以后线程的栈帧，如果是阐明以后线程曾经获取到了这个对象的锁。如果不是则阐明多个线程竞争锁，轻量级锁就会升级成重量级锁，锁标记的状态值变为10，markword中贮存的就是指向重量级锁的指针，前面期待锁的线程会进入阻塞状态。

重量级锁

当偏差锁升级成轻量级锁时，其余线程会通过自旋的形式获取锁，不会阻塞，如果自旋n次都失败了，这个时候轻量级锁就会升级成重量级锁。

总结

synchronized的执行过程：

查看markword外面存储的是不是以后线程的id，如果是则示意以后线程处于偏差锁。
如果不是，则尝试应用CAS将以后线程的id替换markword，如果胜利则示意以后线程获取锁，偏差标记地位为1。
如果CAS失败则阐明产生竞争，撤销偏差锁，进而升级成轻量级锁，锁标记置为00。
以后线程应用CAS将对象的markword替换成锁记录指针，如果胜利，则以后线程获取锁。
如果替换失败，示意其余线程竞争锁，以后线程遍尝试应用自选锁的形式来获取锁。
如果自旋胜利获取锁则依处于轻量级锁。
如果自旋失败，则升级成重量级锁，锁标记置为10。

关于java:Java锁一volatilesynchronized详解

一、锁的基础知识

锁的类型

Java中的锁

二、volatile

可见性

有序性

总结

三、synchronized

常识纲要

应用办法

个性

原子性

可见性

有序性

重入性

类型和降级

偏差锁

轻量级锁

重量级锁

总结

评论

发表回复取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

关于java:Java锁一volatilesynchronized详解

一、锁的基础知识

锁的类型

Java中的锁

二、volatile

可见性

有序性

总结

三、synchronized

常识纲要

应用办法

个性

原子性

可见性

有序性

重入性

类型和降级

偏差锁

轻量级锁

重量级锁

总结

评论

发表回复 取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

发表回复取消回复