synchronized同步以及双重检索

一、synchronized同步参考

两个线程同时执行会出错，那么最简单的方法是让CPU执行完一个线程，再执行另一个线程，那么Java中给出了一个非常简单的解决办法，【synchronized】：是一种同步锁。简单解释一下：就是synchronized修饰的代码，同时只能有一个线程执行，即执行完一个线程，再执行另一个，其它需要执行的线程都要排队 。 

synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：

        1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； 
　　2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 
　　3. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象； 
　　4. 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。 

注意：在定义接口方法时不能使用synchronized关键字；构造方法不能使用synchronized关键字，但可以使用synchronized代码块来进行同步。

1、一个线程访问一个对象中的synchronized(this)同步代码块时，其他试图访问该对象的线程将被阻塞。

public  void test() {
       synchronized (this){
            ......
        }
    }

2、当一个线程访问对象的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该对象中的非synchronized(this)同步代码块。

TestThread testThread = new TestThread();
Thread thread1 = new Thread(testThread, "testThread1");
Thread thread2 = new Thread(testThread, "testThread2");
thread1.start();
thread2.start();

//synchronized代码块
public void test1() {
    synchronized(this) {
        ......
    }
}

//非synchronized代码块
public void test2() {
    ......
}

//执行方法
public void run() {
        String threadName = Thread.currentThread().getName();
        if (threadName.equals("testThread1")) {
            test1();
        } else if (threadName.equals("testThread2")) {
            test2();
        }
}

3、修饰一个方法

synchronized修饰一个方法很简单，就是在方法的前面加synchronized，public synchronized void method(){}; synchronized修饰方法和修饰一个代码块类似，只是作用范围不一样，修饰代码块是大括号括起来的范围，而修饰方法范围是整个函数。

public synchronized void run() {
       ......
}

4、修饰一个静态的方法

public synchronized static void method() {
   ......
}

5、修饰一个类

class ClassName {
    public void method() {
        synchronized(ClassName.class) {
            ......
        }
    }
}

二、双重检索参考

1、单例模式

public class Singleton {
     private static Singleton singleton;
 
     private Singleton() {
     }
 
     public Singleton getInstance() {
         if (null == singleton) {
             singleton= new Singleton();
         }
         return singleton;
     }
 }

 这样写在多线程的情况下，会导致singleton有多个实例，完全违背了单例的初衷。

2、出现这种情况，第一反应就是加锁

public class Singleton {
     private static Singleton singleton;
 
     private Singleton() {
     }
 
     public synchronized Singleton getInstance() {
         if (null == singleton) {
             singleton= new Singleton();
         }
         return singleton;
     }
 }

这样虽然解决了问题，但是因为用到了synchronized，会导致很大的性能开销，并且加锁其实只需要在第一次初始化的时候用到，之后的调用都没必要再进行加锁。

3、之后会想到双重加锁：双重检查锁是对上述问题的一种优化。先判断对象是否已经被初始化，再决定要不要加锁。

public class Singleton {
    private static Singleton singleton;

    private Singleton() {
    }

    public Singleton getInstance() {
        if (null == singleton) {
            synchronized (Singleton.class) {
                if (null == singleton) {
                    singleton= new Singleton();//error
                }
            }
        }
        return singleton;
    }
}

如果这样写，运行顺序就成了：

1. 检查变量是否被初始化(不去获得锁)，如果已被初始化则立即返回。
2. 获取锁。
3. 再次检查变量是否已经被初始化，如果还没被初始化就初始化一个对象。

执行双重检查是因为，如果多个线程同时了通过了第一次检查，并且其中一个线程首先通过了第二次检查并实例化了对象，那么剩余通过了第一次检查的线程就不会再去实例化对象。

这样，除了初始化的时候会出现加锁的情况，后续的所有调用都会避免加锁而直接返回，解决了性能消耗的问题。

隐患

上述写法看似解决了问题，但是有个很大的隐患。实例化对象的那行代码（标记为error的那行），实际上可以分解成以下三个步骤：

1. 分配内存空间
2. 初始化对象
3. 将对象指向刚分配的内存空间

但是有些编译器为了性能的原因，可能会将第二步和第三步进行重排序，顺序就成了：

1. 分配内存空间
2. 将对象指向刚分配的内存空间
3. 初始化对象

为了解决上述问题，需要在singleton前加入关键字volatile。使用了volatile关键字后，重排序被禁止，所有的写（write）操作都将发生在读（read）操作之前。 

public class Singleton {
    private volatile static Singleton singleton;

    private Singleton() {
    }

    public Singleton getInstance() {
        if (null == singleton) {
            synchronized (Singleton.class) {
                if (null == singleton) {
                    singleton= new Singleton();
                }
            }
        }
        return singleton;
    }
}

这样双重检查锁就可以完美工作了。