synchronized 与 volatitle

作者: ZalleDay | 来源:发表于2019-03-16 21:08 被阅读0次

synchronized关键字最主要的三种使用方式：

修饰实例方法，作用于当前对象实例加锁，进入同步代码前要获得当前对象实例的锁 * 修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁。这里知识带类的静态成员加了锁，而对于实例化对象的非静态方法没有锁的限制。
修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。和 synchronized 方法一样，synchronized(this)代码块也是锁定当前对象的。synchronized 关键字加到 static 静态方法和 synchronized(class)代码块上都是是给 Class 类上锁。

synchronized的使用


//双重校验锁实现对象单例（线程安全）

public class Singleton {
    private volatile static Singleton uniqueInstance;

    private Singleton(){

    }

    public static Singleton getUniqueInstance(){
        if (uniqueInstance == null){
            synchronized (Singleton.class){
                if (uniqueInstance == null){
                    uniqueInstance = new Singleton();
                }
            }
        }
        return uniqueInstance;
    }

 
}

Synchronized内部实现

public class SynchronizedDemo {

    public void method() {
        synchronized (this) {
            System.out.println("synchronized code data");
        }
    }
}

image.png

可以看到jvm底层的 monitorenter 和 monitorexit 指令实现，这两个指令把synchronized修饰代码修饰起来。

当执行 monitorenter 指令时，线程试图获取锁也就是获取 monitor(monitor对象存在于每个Java对象的对象头中，synchronized 锁便是通过这种方式获取锁的，也是为什么Java中任意对象可以作为锁的原因) 的持有权.当计数器为0则可以成功获取，获取后将锁计数器设为1也就是加1。相应的在执行 monitorexit 指令后，将锁计数器设为0，表明锁被释放。如果获取对象锁失败，那当前线程就要阻塞等待，直到锁被另外一个线程释放为止。

对于Synchronized修饰的方法

synchronized 修饰的方法并没有 monitorenter 指令和 monitorexit 指令，取得代之的确实是 ACC_SYNCHRONIZED 标识，该标识指明了该方法是一个同步方法，JVM 通过该 ACC_SYNCHRONIZED 访问标志来辨别一个方法是否声明为同步方法，从而执行相应的同步调用。

volatitle

一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：

保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
禁止进行指令重排序。

volatitle的作用是可以禁止 JVM 的指令重排，保证在多线程环境下也能正常运行。

上文在初始化Singleton的时候分为三个步骤，内存分配空间，初始化，把uniqueSingleton指向相应的的空间。但是JVM可能会重排，比如线程一做了第一第三步，还没有初始化我们的对象，线程而就可以通过get方法拿到这个实例对象，这样就会使用到没有初始化的数据。因此上文的的volatitle是非常必要的。

然而volatitle不保证操作的原子性

Java内存模型

Java内存模型规定所有的变量都是存在主存当中（类似于前面说的物理内存），每个线程都有自己的工作内存（类似于前面的高速缓存）。线程对变量的所有操作都必须在工作内存中进行，而不能直接对主存进行操作。并且每个线程不能访问其他线程的工作内存。

举个简单的例子：在java中，执行下面这个语句：

i  = 10;

执行线程必须先在自己的工作线程中对变量i所在的缓存行进行赋值操作，然后再写入主存当中。而不是直接将数值10写入主存当中。（如果算上没有读取的内存，我们需要执行的read i 、 i + 1 、 write i）

对于这三步操作，就可能出现问题，因为在对多线程中，我们线程一正在执行i+1，线程二执行read的话，写操作还没有执行，就读取了脏数据。这就不能保证并发编程的原子性。因此这就是我们说的volatitle不满足原子操作。

样例代码

public class VolatileDemo {

    public static volatile int race = 0;
    public static void increase() {
        race++;

    }
    public static int THREADS_COUNT = 3;
    
    public static void main(String[] args) throws InterruptedException {
        Thread[] threads = new Thread[THREADS_COUNT];
        for (int i = 0; i < THREADS_COUNT; i++) {
            threads[i] = new Thread(new Runnable() {
                public void run() {
                    for (int i = 0; i < 100000; i++) {
                        increase();

                    }
                }
            });

            threads[i].start();
        }

        while (Thread.activeCount() > 1) {
            //Thread.yield();
            Thread.sleep(150);
            System.out.println(race);
        }
    }
}
//结果和预想的不太一样    对吧~

说说 synchronized 关键字和 volatile 关键字的区别

从性能上来说，synchronized关键字和volatile关键字比较 volatile关键字是线程同步的轻量级实现，所以volatile性能肯定比synchronized关键字要好。
从修饰范围上，但是volatile关键字只能用于变量而synchronized关键字可以修饰方法以及代码块。
从使用方面上，synchronized关键字在JavaSE1.6之后进行了主要包括为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁以及其它各种优化之后执行效率有了显著提升，实际开发中使用 synchronized 关键字的场景还是更多一些。
从多线程堵塞方面，多线程访问volatile关键字不会发生阻塞，而synchronized关键字可能会发生阻塞
从原子性、可见性上看，volatile关键字能保证数据的可见性，但不能保证数据的原子性。synchronized关键字两者都能保证。
用途上，volatile关键字主要用于解决变量在多个线程之间的可见性，而 synchronized关键字解决的是多个线程之间访问资源的同步性。

简单介绍一下原子性、可见性、有序性

可见性
在Java中，对基本数据类型的变量的读取和赋值操作是原子性操作，即这些操作是不可被中断的，要么执行，要么不执行。

x = 10;         //语句1
y = x;         //语句2
x++;           //语句3
x = x + 1;     //语句4

语句1是直接将数值10赋值给x，也就是说线程执行这个语句的会直接将数值10写入到工作内存中。

语句2实际上包含2个操作，它先要去读取x的值，再将x的值写入工作内存，虽然读取x的值以及将x的值写入工作内存这2个操作都是原子性操作，但是合起来就不是原子性操作了。

同样的，x++和 x = x+1包括3个操作：读取x的值，进行加1操作，写入新的值。

所以上面4个语句只有语句1的操作具备原子性。

也就是说，只有简单的读取、赋值（而且必须是将数字赋值给某个变量，变量之间的相互赋值不是原子操作）才是原子操作。

从上面可以看出，Java内存模型只保证了基本读取和赋值是原子性操作，如果要实现更大范围操作的原子性，可以通过synchronized和Lock来实现。由于synchronized和Lock能够保证任一时刻只有一个线程执行该代码块，那么自然就不存在原子性问题了，从而保证了原子性。

可见性
　对于可见性，Java提供了volatile关键字来保证可见性。

当一个共享变量被volatile修饰时，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，它会去内存中读取新值。

而普通的共享变量不能保证可见性，因为普通共享变量被修改之后，什么时候被写入主存是不确定的，当其他线程去读取时，此时内存中可能还是原来的旧值，因此无法保证可见性。

另外，通过synchronized和Lock也能够保证可见性，synchronized和Lock能保证同一时刻只有一个线程获取锁然后执行同步代码，并且在释放锁之前会将对变量的修改刷新到主存当中。因此可以保证可见性。

顺序性
在Java内存模型中，允许编译器和处理器对指令进行重排序，但是重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性。

下面就来具体介绍下happens-before原则（先行发生原则）：

1 程序次序规则：一个线程内，按照代码顺序，书写在前面的操作先行发生于书写在后面的操作
2 锁定规则：一个unLock操作先行发生于后面对同一个锁额lock操作
3 volatile变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作
4 传递规则：如果操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于操作C

参考 javaguide
http://www.cnblogs.com/dolphin0520/p/3920373.html

网友评论

本文标题：synchronized 与 volatitle

本文链接：https://www.haomeiwen.com/subject/vttemqtx.html

延伸阅读

深度阅读

您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！