单例模式实例（全）

什么是单例模式？

定义：确保一个类只有一个实例，而且自行实例化并向整个系统提供这个实例场景，也就是说：确保某个类有且只有一个对象的场景，避免产生多个对象消耗过多的资源，或者某种类型的对象应该有且只有一个。

构建单例模式的关键：

1.构造函数不对外开放，一般为Private

2.通过一个静态方法或者枚举返回单例类对象

3.确保单例类的对象有且只有一个，尤其是多线程的环境下

4.确保单例类对象在反序列化时不会重新构建对象

单例模式构建方式：

1.饿汉模式

2.懒汉模式（Double Check）

3.静态内部类的单例模式

4.容器实现单例模式

5.序列化反序列化单例模式（readResolve）

6.枚举单例模式

代码示例：

1.饿汉模式

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

2. 懒汉模式（Double Check）

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

需要volatile关键字修饰Intance，volatile的语义是“禁止CPU对字节码指令重排序”，因为现在电脑是多核，所以JVM在运行的时候会将字节码指令进行重排序优化来更好的执行，所以这就可能会出现线程A的字节码指令执行到一半，线程B的字节码指令就去执行而首先对Intance进行修改，而导致线程A字节码执行到new的时候Intance已经被初始化。这时候就会有问题，所以需要禁止字节码重排序。

3.静态内部类单例模式

public class Singleton {
	private Singleton(){}
	private static Singleton getInstance(){
		return SingletonHolder.Instance;
	}
	/**
	 * 静态内部类
	 */
	private static class SingletonHolder{
		private static final Singleton Instance = new Singleton();
	}
}

当第一次加载Singleton类时，并不会初始化Instance，只有在第一次调用Singleton的getInstance方法时，才会导致 Instance 被初始化。第一次调用 getInstance 方法会导致虚拟机加载SingletonHolder类，这种方式不仅能够确保线程安全，也能够保证单例对象的唯一性，同时也延迟了单例对象的实例化，所以推荐使用这种方法。

4.使用容器实现单例模式

public class SingletonManager {
    private static Map<String, Object> objMap = new HashMap<String, Object>();
    private SingletonManager(){ }
    //将多种单例类型注入到一个统一的管理类，在使用时根据key获取对象对应类型的对象
    public static void registerService(String key, Object instance)
    {
        if(!objMap.containsKey(key)){
            objMap.put(key, instance);
        }
    }
    public static Object getService(String key){
        return objMap.get(key);
    }
}

5.使用序列化现单例模式

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
 
public class SerSingleton implements Serializable {
 
    private static final long serialVersionUID = 1L;
    String name;
 
    private SerSingleton() {
        System.out.println("Singleton is create");
        name = "SerSingleton";
    }
 
    private static SerSingleton instance = new SerSingleton();
 
    public static SerSingleton getInstance() {
        return instance;
    }
 
    public static void createString() {
        System.out.println("createString in Singleton");
    }

    private Object readResolve(){
        return instance;
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        SerSingleton s1 = null;
        SerSingleton s = SerSingleton.getInstance();
 
        FileOutputStream fos = null;
        ObjectOutputStream oos = null;
 
        FileInputStream fis = null;
        ObjectInputStream ois = null;
        try {
            fos = new FileOutputStream("SerSingleton.obj");
            oos = new ObjectOutputStream(fos);
            oos.writeObject(s);
        } finally {
            oos.flush();
            oos.close();
            fos.close();
        }
 
        try{
            fis = new FileInputStream("SerSingleton.obj");
            ois = new ObjectInputStream(fis);
            s1 = (SerSingleton) ois.readObject();
        }finally{
            ois.close();
            fis.close();
        }
        System.out.println(s == s1);
    }
}

序列化单例模式需要实现readResolve方法。

6.使用enum现单例模式

public enum SingletonClass implements Serializable {
 
    INSTANCE;
    private static final long serialVersionUID = 1L;
 
    private String name;
 
    public void test() {
        System.out.println("The Test!");
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public String getName() {
        return name;
    }
 
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        SingletonClass s1 = null;
        SingletonClass s = SingletonClass.INSTANCE;
 
        FileOutputStream fos = null;
        ObjectOutputStream oos = null;
 
        FileInputStream fis = null;
        ObjectInputStream ois = null;
        try {
            fos = new FileOutputStream("SingletonClass.obj");
            oos = new ObjectOutputStream(fos);
            oos.writeObject(s);
        } finally {
            oos.flush();
            oos.close();
            fos.close();
        }    
        try {
            fis = new FileInputStream("SingletonClass.obj");
            ois = new ObjectInputStream(fis);
            s1 = (SingletonClass) ois.readObject();
        } finally {
            ois.close();
            fis.close();
        }
        System.out.println(s == s1);
    }
}

这种容器单例模式的实现，在Android中，我们使用的Context的getSystemService(key)的方式，就是利用的容器单例模式。eg：WIndowsManagerService、ActivityManagerService等等。在虚拟机第一次加载该类时，会注册各种Service，这些服务以键值对的形式存储在一个HashMap中，用户使用时只需要根据key来获取到对应的具体服务对象了。

单例模式实例（全）

猜你喜欢