单例模式的6种实现方式

一.单例模式

在标准的23种设计模式种，如果希望系统中只有一个类的实例，那么单例模式是最好的解决方案。
常见的单例模式写法有：饿汉式、懒汉式
接下来分别说明这两种模式及其优缺点，存在的问题

二、饿汉模式

饿汉模式，有立即加载的特性，所谓立即加载，就是使用类的时候已经将对象创建完毕，常见的办法就是直接new实例化

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

三、懒汉模式

懒汉模式具有延迟加载的特点，所谓延迟加载就是在调用getInstance()方法的时候实例才被创建。常见的办法是在get()方法中进行new实例化。

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

懒汉模式在多线程环境中会出现线程不安全问题，会导致取出多个不同实例的情况。

3.双重锁解决懒汉模式问题

同步方法解决：

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

缺点：效率非常低，下一个要取得对象，必须等上一个线程释放锁之后才能继续运行。

同步代码块解决：

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

缺点：与同步方法一样

双重锁结合同步代码块解决：

public class Singleton{
    private volatile static Singleton singleton = null;//这里不用volatile可以吗？
    private Singleton(){
    }
    public  static Singleton getInstance(){
    	if(singleton == null) {
    		synchronized(Singleton.class){
    	       if(singleton == null){
    	           singleton = new Singleton();
    	       }
    	    }
    	}
         
       
        return singleton;
    }
}

注意：上面声明一个Singleton类型引用时，用了关键字volatile,不用可以吗？

singleton = new Singleton();

这行代码可以分成三步：
memory = allocate();//1.分配对象的存储空间
ctorInstance(memory)//2.初始化对象
instance = memory;//3.instace指向刚分配的存储空间
上述第二步第三步在某些编译器与操作系统上可能会发生指令重排
memory = allocate();//1.分配对象的存储空间
instance = memory;//3.instace指向刚分配的存储空间（此时对象还未被初始化）
ctorInstance(memory)//2.初始化对象

因此需要volatile关键字禁止指令重排，保持可见性

4.使用静态内置类实现单例模式

DCL双重锁可以解决多线程单例模式的非线程安全问题。当然，使用其他的办法也能达到同样的效果。

public class Singleton{
   private static class MyObjectHandler{
      private static Singleton singleton = new Singleton();
   }
  private Singleton(){
  
  }
  public static Singleton getInstance(){
  return MyObjectHandler.singleton;
  }
}

静态内置类可以达到线程安全，但是如果遇到序列化对象时，使用默认的方法运行得到的结果还是多例的。

package cn.yu.thread;

import java.io.Serializable;

public class Singleton implements Serializable{//单例类
     private static final long seriaVersionUID = 888L;
     private static class MyObject{
       private static final Singleton singleton = new Singleton();
     }
    private Singleton(){
    }
    public static Singleton getInstance() {
    	return MyObject.singleton;
    }
    
}

public class Test {//测试类
public static void main(String[] args) throws InterruptedException {
	try {
		Singleton singleton = Singleton.getInstance();
		FileOutputStream fout = new FileOutputStream("test.txt");
		ObjectOutputStream out = new ObjectOutputStream(fout);
		out.writeObject(singleton);
		out.close();
		fout.close();
		System.out.println("写之前的hash值："+singleton.hashCode());
		
	} catch (FileNotFoundException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	
   try {
	FileInputStream fin = new FileInputStream("test.txt");
	ObjectInputStream in = new ObjectInputStream(fin);
	Singleton singleton = (Singleton)in.readObject();
	in.close();
	fin.close();
	System.out.println("读之后的hash值:"+singleton.hashCode());
} catch (FileNotFoundException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
} catch (IOException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
} catch (ClassNotFoundException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
}
	
	
}
}

运行结果：

写之前的hash值：1834188994
读之后的hash值:764308918
//不是同一个对象

**解决方法：**使用readResolve()方法

public class Singleton implements Serializable{
     private static final long seriaVersionUID = 888L;
     private static class MyObject{
       private static final Singleton singleton = new Singleton();
     }
    private Singleton(){
    }
    public static Singleton getInstance() {
    	return MyObject.singleton;
    }
    protected  Object readResolve() throws ObjectStreamException{
    	return MyObject.singleton;
    }
    
}

运行结果：

写之前的hash值：1834188994
读之后的hash值：1834188994

通过序列化工具，可以将一个类的单例的实例对象写到磁盘再读回来，从而有效获得一个实例。如果想要单例实现Serializable，任何readObject方法，不管显示还是默认的，它会返回一个新建的实例，这个新建实例不同于该类初始化时创建的实例。从而导致单例获取失败。但序列化工具可以让开发人员通过readResolve来替换readObject中创建的实例，即使构造方法是私有的。在反序列化时，新建对象上的readResolve方法会被调用，返回的对象将会取代readObject中新建的对象。

5.使用static代码块实现单例模式

静态代码块中的代码在使用类的时候就已经执行了，所以可以应用静态代码块的这个特性来实现单例设计模式。

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

6.使用enum枚举数据类型实现单例模式

枚举enum和静态代码块的特性相似，在使用枚举类时，构造方法会被自动调用，也可以应用其这个特性实现单例设计模式。

package cn.yu.test;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class MyObject {
   public enum MyEnumSingleton{//枚举内部类
	   connectionFactory;
	   private Connection connection;
	   private MyEnumSingleton() {
		   
		   try {
			   String url="jdbc:sqlserver://localhost:1079;databaseName=y2";
			   String username = "yu";
			   String password = "123456";
			   String driverName = "com.microsoft.sqlserver.jdbc.SQLServerDriver";
			   Class.forName(driverName);
			   connection = DriverManager.getConnection(url,username,password);
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		   
	   }
	   public Connection getConnection() {
		   return connection;
	   }
   }
   
   public static Connection getConnection() {
	   return MyEnumSingleton.connectionFactory.getConnection();
   }
   
}

单例模式以前就知道个饿汉模式与懒汉模式，没复习之前也没想到还有别的构建方式，继续学习中！