单例模式（懒汉式）
懒汉式是符合懒加载的模式，但是会存在线程并发的问题发生，所以还需要一种解决线程并发的机制，比如：加锁等
单例模式懒汉式主要的构成是如下
- 单例类
- 私有化构造函数（防止实例化）
- 私有化变量
- 公共静态获得实例的方法(在调用这个方法的时候才进行实例化)
- 解决线程并发的机制
代码
懒汉式（线程不安全）
package singleton.type3;
/**
*
*
* @author: Hui
**/
public class SingletonTest3 {
public static void main(String[] args) {
Singleton singleton = Singleton.getInstance();
Singleton singleton1 = Singleton.getInstance();
System.out.println(singleton == singleton1);
System.out.println(singleton.hashCode());
System.out.println(singleton1.hashCode());
}
}
class Singleton{
//1.构造器私有化
private Singleton(){}
//2.静态实例私有化
private static Singleton singleton;
//3.提供实例的静态方法
public static Singleton getInstance(){
if (singleton == null){
singleton = new Singleton();
}
return singleton;
}
}
以上方法虽然实现了懒加载，但是线程不安全，在实际开发情况下不能使用。
因为以上代码会出现线程不安全的情况，那么我们如何保证线程安全呢？最简单的就是加锁，在提供实例的静态方法中加锁，就可以保证线程安全了。
懒汉式（线程安全，加锁）
package singleton.type4;
/**
* @author: Hui
**/
public class SingletonTest4 {
public static void main(String[] args) {
System.out.println("线程安全，加锁");
Singleton singleton = Singleton.getInstance();
Singleton singleton1 = Singleton.getInstance();
System.out.println(singleton == singleton1);
System.out.println(singleton.hashCode());
System.out.println(singleton1.hashCode());
}
}
class Singleton {
//1.构造器私有化
private Singleton() {
}
//2.静态实例私有化
private static Singleton singleton;
//3.提供实例的静态方法
public static synchronized Singleton getInstance() {
if (singleton == null) {
singleton = new Singleton();
}
return singleton;
}
}
虽然解决了线程安全问题，但是性能太差了，每一次调用实例都需要进入同步方法，其实我们创建实例的时候保持同步就可以了。这个方法因为性能比较差，开发过程中不建议使用。
那上述锁的是一个方法，我们可不可以将锁的颗度降低，锁住一个代码块呢？
代码如下
//3.提供实例的静态方法
public static synchronized Singleton getInstance() {
if (singleton == null) {
synchronized(Singleton){
singleton = new Singleton();
}
}
return singleton;
}
像以上方法是不是就实现了提高性能呢？是的，但是也出现了线程不安全的问题，比如有多个线程进入 if (singleton == null) 那么是不是会有多个线程进行创建对象。所以为了减少颗粒度又要保证线程安全，我们可以使用双层检查锁来完成！！！
//3.提供实例的静态方法
public static synchronized Singleton getInstance() {
if (singleton == null) {
synchronized(Singleton.class){
if (singleton == null){
singleton = new Singleton();
}
}
}
return singleton;
}
我们只需要在加锁的代码块中再进行一次空判断，就可以很好的解决并发问题了，当一个线程进入的时候，先判断是否为空，为空才创建对象，不为空直接返回。
双重检查锁很好的解决线程不安全问题，并且达到性能的提升。
在实际开发中推荐使用
双重检查锁（线程安全，推荐）
package singleton.type5;
/**
* @author: Hui
**/
public class SingletonTest5 {
public static void main(String[] args) {
System.out.println("双重检查锁，推荐使用");
Singleton singleton = Singleton.getInstance();
Singleton singleton1 = Singleton.getInstance();
System.out.println(singleton == singleton1);
System.out.println(singleton.hashCode());
System.out.println(singleton1.hashCode());
}
}
class Singleton {
//1.私有化构造器
private Singleton() {
}
//2.声明静态变量，volatile 保证内存的可见性
private static volatile Singleton instance;
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
//双重检查锁
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
注意变量一定要使用 volatile 修饰，保证变量内存修改时的可见性。
