单例模式
1.饿汉模式
类加载的时候，就进行对象的创建，系统开销较大，但是不存在线程安全
* 饿汉模式-单例对象构建方法
* (类加载的时候，就进行对象的创建，系统开销较大，影响性能，所以多数采用饿汉模式，在使用时才真正的创建单例对象)
方式一：饿汉模式：性能最差
class Singleton1 {
private static Singleton1 singleton = new Singleton1(); // 建立对象
问题：每次类加载的时候，就进行对象的创建，性能开销大，是一种空间换时间的方式
2.懒汉模式
多数采用饿汉模式，在使用时才真正的创建单例对象，但是存在线程安全
懒汉模式
线程不安全
方式二：懒汉模式-性能不安全
class Singleton2 {
private static Singleton2 singleton = null; // 不建立对象
/*synchronized 可以解决线程安全问题,但是存在性能问题,即使singleton!=null也需要先获得锁*/
public synchronized static Singleton2 getInstance() {
if (singleton == null) { // 先判断是否为空
try {
Thread.sleep(1000);
System.out.println("构建这个对象可能耗时很长...");
} catch (InterruptedException e) {
e.printStackTrace();
}
singleton = new Singleton2(); // 懒汉式做法
}
return singleton;
}
是一种时间换空间的方式
问题：每次线程都要走同步代码块性能 不高
线程安全doublecheck
方式三：懒汉模式-性能安全
class Singleton3 {
private static Singleton3 singleton = null; // 不建立对象
private Singleton3() {
}
/*synchronized 代码块进行双重检查,可以提高性能*/
public static Singleton3 getInstance() {
if (singleton == null) { // 先判断是否为空
synchronized (Singleton3.class) {
//此处必须进行双重判断,否则依然存在线程安全问题
if(singleton == null){
try {
Thread.sleep(1000);
System.out.println("构建这个对象可能耗时很长...");
} catch (InterruptedException e) {
e.printStackTrace();
}
singleton = new Singleton3(); // 懒汉式做法
}
}
}
return singleton;
}
这里的synchronize只有开头几个线程会进来，此时singleton为null。
为什么要进行双重判断？
因为同步代码块的存在，多个线程程序刚启动的时候会一起进来，1个线程进入代码块执行方法，结束后，其他线程执行方法前要判断这个对象是否为null，这里的判断是判断是否一初始化实例。
第一次是判断单例是否存在，准备使用
第二次是判断单例是否存在，准备创建
3.静态内部类单例
兼具懒汉模式和饿汉模式的优点
序列化方式和反射方式都可以破坏单例
定义饿汉类
public class HungrySingleton implements Serializable,Cloneable{
private final static HungrySingleton hungrySingleton;
static{
hungrySingleton = new HungrySingleton();
}
private HungrySingleton(){
if(hungrySingleton != null){
throw new RuntimeException("单例构造器禁止反射调用");
}
}
public static HungrySingleton getInstance(){
return hungrySingleton;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return getInstance();
}
}
1.序列化破坏单例
序列化的时候对于普通对象会new Instance
HungrySingleton instance = HungrySingleton.getInstance();
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("singleton_file"));
oos.writeObject(instance);
File file = new File("singleton_file");
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
HungrySingleton newInstance = (HungrySingleton) ois.readObject();
System.out.println(instance);
System.out.println(newInstance);
System.out.println(instance == newInstance);
控制台输出：
发现输出的是不同的地址，观察ois.readObject();的源码发现
因为对象是object的，所以走到
case TC_OBJECT:
if (type == String.class) {
throw new ClassCastException("Cannot cast an object to java.lang.String");
}
return checkResolve(readOrdinaryObject(unshared));
在这个readOrdinaryObject中发现代码片
try {
obj = desc.isInstantiable() ? desc.newInstance() : null;
} catch (Exception ex) {
观察isInstantiable()方法,说明返回的一定是true
/**
* 如果表示的类是可序列化的，并且可以由序列化运行时实例化，则返回 true
* Returns true if represented class is serializable/externalizable and can
* be instantiated by the serialization runtime--i.e., if it is
* externalizable and defines a public no-arg constructor, or if it is
* non-externalizable and its first non-serializable superclass defines an
* accessible no-arg constructor. Otherwise, returns false.
*/
boolean isInstantiable() {
requireInitialized();
return (cons != null);
}
所以调用desc.newInstance()，这里就新建了一个实例，所以和原来的实例对象是不同的
拓展：序列化下实现单例
但观察源码，可以发现，如果object拥有readResolve（）方法，则最后会返回这个方法的返回对象覆盖原来new Instance()对象，所以加上这个方法试试
修改HungrySingleton，在readResolve()方法中返回单例对象
public class HungrySingleton implements Serializable,Cloneable{
private final static HungrySingleton hungrySingleton;
static{
hungrySingleton = new HungrySingleton();
}
private HungrySingleton(){
if(hungrySingleton != null){
throw new RuntimeException("单例构造器禁止反射调用");
}
}
public static HungrySingleton getInstance(){
return hungrySingleton;
}
private Object readResolve(){
return hungrySingleton;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return getInstance();
}
}
调试可得，发现输出的的确是单例
2.反射方式破坏单例
懒汉可以采用防御机制，在无参构造方法中防御，但是懒汉模式无法防御
Class objectClass = LazySingleton.class;
Constructor constructor = objectClass.getDeclaredConstructor();
constructor.setAccessible(true);
LazySingleton newInstance = (LazySingleton) constructor.newInstance();
LazySingleton instance = LazySingleton.getInstance();
System.out.println(instance);
System.out.println(newInstance);
输出
但是饿汉模式可以在无参构造器中加上防御机制
private HungrySingleton(){
if(hungrySingleton != null){
throw new RuntimeException("单例构造器禁止反射调用");
}
}
Class objectClass = HungrySingleton.class;
Constructor constructor = objectClass.getDeclaredConstructor();
constructor.setAccessible(true);
HungrySingleton newInstance = (HungrySingleton) constructor.newInstance();
HungrySingleton instance = HungrySingleton.getInstance();
System.out.println(instance);
System.out.println(newInstance);
3.使用枚举方式
针对序列化：
序列化的对象是确定的枚举值，所以一定是相同的
针对反射：
enum没有无参构造器
反射无法使用枚举！
通过反编译查看enum源码发现：
4.匹配源码
饿汉模式：
容器单例思想
