通过单例模式理解synchronized,volatile

本是古典何须时尚 2022-01-31 00:51 196阅读 0赞

### 转载：[https://www.jianshu.com/p/5b2f063d9f68][https_www.jianshu.com_p_5b2f063d9f68] ###

### synchronized 关键字 ###

synchronized关键字是用来控制线程同步的，就是在多线程的环境下，控制synchronized代码段不被多个线程同时执行。是一种阻塞性的锁,synchronized既可以加在一段代码上，也可以加在方法上。  
synchronized(this)及非static的synchronized方法，只能防止多个线程同时执行`同一个对象`的同步代码段。当synchronized锁住一个对象后，别的线程如果也想拿到这个对象的锁，就必须等待这个线程执行完成释放锁，才能再次给对象加锁，这样才达到线程同步的目的。即使两个不同的代码段，都要锁同一个对象，那么这两个代码段也不能在多线程环境下同时运行。  
所以我们在用synchronized关键字的时候，能缩小代码段的范围就尽量缩小，能在代码段上加同步就不要再整个方法上加同步。这叫减小锁的粒度，使代码更大程度的并发。原因是基于以上的思想，锁的代码段太长了，别的线程是不是要等很久。  
如果用synchronized加在`静态方法`上，就相当于用`××××.class`锁住整个方法内的代码块,此时是锁住该类的Class对象,相当于一个全局,锁。使用synchronized修饰的方法或者代码块可以看成是一个原子操作。  
一个线程执行互斥代码过程如下：  
1. 获得同步锁；  
2. 清空工作内存；  
3. 从主内存拷贝对象副本到工作内存；  
4. 执行代码(计算或者输出等)；  
5. 刷新主内存数据；  
6. 释放同步锁。  
所以，synchronized既保证了多线程的并发有序性，又保证了多线程的内存可见性。

### volatile（非阻塞性的） ###

volatile的特性当我们声明共享变量为volatile后，对这个变量的读/写将会很特别。理解volatile特性的一个好方法是：把对volatile变量的单个读/写，看成是使用同一个监视器锁对这些单个读/写操作做了同步。

它的工作原理是，它对写和读都是直接操作工作主存的。下面我们通过具体的示例来说明，请看下面的示例代码：

class VolatileFeaturesExample {  
        volatile long vl = 0L;  //使用volatile声明64位的long型变量        
        public void set(long l) {            
            vl = l;   //单个volatile变量的写        
        }            
        public void getAndIncrement () { 
            vl++;   //复合（多个）volatile变量的读/写            
        }          
        public long get()  {            
            return vl;   //单个volatile变量的读        
        }    
    }
    class VolatileFeaturesExample {      
        volatile long vl = 0L;  //使用volatile声明64位的long型变量        
        public void set(long l) {           
            vl = l;   //单个volatile变量的写        
        }            
        public void getAndIncrement () {                         
            vl++;    //复合（多个）volatile变量的读/写        
        }                
        public long get() {            
            return vl;   //单个volatile变量的读     
        }  
    }

假设有多个线程分别调用上面程序的三个方法，这个程序在语意上和下面程序等价：

class VolatileFeaturesExample {       
           long vl = 0L;               // 64位的long型普通变量        
           //对单个的普通 变量的写用同一个监视器同步          
           public synchronized void set(long l) {             
              vl = l;       
           }           
           public void getAndIncrement () { 
            //普通方法调用            
            long temp = get();           //调用已同步的读方法           
            temp += 1L;                  //普通写操作                  
            set(temp);                   //调用已同步的写方法        
          }        
          public synchronized long get() {        
          //对单个的普通变量的读用同一个监视器同步                
              return vl;      
          }    
    }

临界区代码的执行具有原子性。这意味着即使是64位的long型和double型变量，只要它是volatile变量，对该变量的读写就将具有原子性。  
如果是多个volatile操作或类似于volatile++这种复合操作，这些操作整体上不具有原子性。简而言之，volatile变量自身具有下列特性：

*  可见性: 对一个volatile变量的读，总是能看到（任意线程）对这个volatile变量最后的写入。
 *  对 volatile 变量的写操作，不允许和它之前的读写操作打乱顺序；对 volatile 变量的读操作，不允许和它之后的读写乱序。

`volatile不能保证原子性`,原子性不是volatile来保证的,如果操作本来就具有原子性,volatile就会保证这个原子性不会被打破,理解为加上同步。比如上面例子中的get和set函数。  
以及下面这段线程不安全的singleton（单例模式）实现，尽管使用了volatile：

public class UnSafeSingleton {        
        private static volatile UnSafeSingleton       
        sInstance = null;              
        private UnSafeSingleton() {}             
        public static UnSafeSingleton getInstance(){
            if (sInstance == null) {                     
                sInstance = new UnSafeSingleton();                
            }            
            return sInstance;       
         }    
    }

关于原子性的理解:只对`单个操作`就有原子性,比如i++这种就不是单个操作。

> 但是,轻易不要用volatile来替代synchronized来避免并发问题,因为很多原子操作自己可能并没那么了解,除非你是并发专家。《java编程思想》的作者是这样建议的。

### 单例模式的应用 ###

**先看一个"饿汉式"的模式**

public class Singleton {      
        private static Singleton instance = new Singleton();     
        private Singleton (){}      
        public static Singleton getInstance() {            
             return instance;     
        }  
    }

这种方式比较常用，但容易产生垃圾对象。  
优点：没有加锁，执行效率会提高。  
缺点：类加载时就初始化，浪费内存。  
它基于 Classloader 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法， 但是也不能确定有其他的方式（或者其他的静态方法,比如反射）导致类装载，这时候初始化 instance显然没有达到 lazy loading 的效果。  
**一个双重锁定式的单例模式**

public class Singleton {      
        private volatile static Singleton sSingleton;              
        private Singleton (){}      
        public static Singleton getSingleton() {      
            if (sSingleton == null) {                   
                synchronized (Singleton.class) {                    
                    if (sSingleton == null) {                                       
                        sSingleton = new Singleton();                  
                    }          
                }     
             }      
             return sSingleton;      
        }  
    }

讨论下volatile关键字的必要性,如果没有volatile关键字,问题可能会出在singleton = new Singleton();这句,用伪代码表示

inst = allocat()； // 分配内存  
    sSingleton = inst;      // 赋值
    constructor(inst); // 真正执行构造函数

可能会由于虚拟机的优化等导致赋值操作先执行,而构造函数还没完成,导致其他线程访问得到singleton变量不为null,但初始化还未完成,导致程序崩溃。  
下篇[你见过这样的单例模式吗][Link 1]将见识到一种新的单例模式。

参考：[Java 单例真的写对了么?][Java]

作者：SilenceDut  
链接：https://www.jianshu.com/p/5b2f063d9f68  
来源：简书  
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。

[https_www.jianshu.com_p_5b2f063d9f68]: https://www.jianshu.com/p/5b2f063d9f68
[Link 1]: https://www.jianshu.com/p/d9c9c947678a
[Java]: https://link.jianshu.com?t=http://www.race604.com/java-double-checked-singleton/