2.设计模式–创建者模式–单例设计模式

一个程序整个运行过程中，该实例的对象只被创建一次。

2.1单例设计模式的分类：

饿汉式：类加载时创建单例类的对象
懒汉式：类加载时不创建单例类的对象，第一次访问时创建单例类的对象。

2.2单例设计模式

2.2.1饿汉式（静态变量）

/*** 饿汉式：静态变量创建类的对象*/
public class Singleton {//构造方法私有private Singleton(){}//静态变量创建类的对象private static Singleton instance = new Singleton();//对外提供静态方法public static Singleton getInstance(){return instance;}
}

如果对象不创建会导致内存浪费。

2.2.2 饿汉式（静态代码块）

/*** 饿汉：静态代码块*/
public class Singleton2 {//构造方法私有private Singleton2(){}private static Singleton2 instance;//静态代码块static{instance = new Singleton2();}//对外提供静态对象获取该对象public static Singleton2 getInstance(){return instance;}
}

如果对象不创建会导致内存浪费。

2.2.3 懒汉式（方式一）

/*** 懒汉式*/
public class Singleton3 {/*** 构造方法私有*/private Singleton3(){};//在成员位置创建该类的对象private static Singleton3 instance;/*** 静态获取方法* @return*/public static Singleton3 getInstance(){if(instance==null){instance = new Singleton3();}return instance;}
}

多线程环境，会出现线程安全问题。

2.2.4 懒汉式（方法上synchronized锁）

public class Singleton4 {//私有构造方法private Singleton4(){};//在成员位置创建该类的对象private static Singleton4 instance;/*** 提供静态方法获取变量*/public synchronized static Singleton4 getinstance(){if(instance==null){instance = new Singleton4();}return instance;}
}

在初始化instance的时候才会出现线程安全问题，一旦初始化完成就不存在了。

2.2.4 懒汉式（双重检查锁）

public class Singleton5 {private Singleton5(){};private static Singleton5 instance;public static Singleton5 getInstance(){if(instance==null){//第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实例synchronized (Singleton5.class){//抢到锁之后再次判断是否为nullif(instance==null){instance = new Singleton5();}}}return null;}
}

在多线程的情况下，可能会出现空指针问题，出现问题的原因是JVM在实例化对象的时候会进行优化和指令重排序操作

2.2.5懒汉式（volatile关键字）

public class Singleton6 {private Singleton6(){};//volatile参数存在，不会指令重排序private static volatile Singleton6 instance;public static Singleton6 getInstance(){if(instance==null){//第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实例synchronized (Singleton6.class){//抢到锁之后再次判断是否为nullif(instance==null){instance = new Singleton6();}}}return null;}
}

2.2.6懒汉式（静态内部类方式）

public class Singleton7 {//私有方法构造private Singleton7(){};private static class singletonHolder{private static final Singleton7 INSTANCE = new Singleton7();}public static Singleton7 getInstance(){return singletonHolder.INSTANCE;}
}

静态属性由于被 static修饰，保证只被实例化一次，并且严格保证实例化顺序

3.1破坏单例模式

1.序列化和反序列化

public class SingletonDemo {public static void main(String[] args) throws Exception {//往文件中写对象writeObject2File();//从文件中读取对象Singleton s1 = readObjectFromFile();Singleton s2 = readObjectFromFile();//判断两个反序列化后的对象是否是同一个对象System.out.println(s1 == s2);}private static Singleton readObjectFromFile() throws Exception {//创建对象输入流对象ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\a.txt"));//第一个读取Singleton对象Singleton instance = (Singleton) ois.readObject();return instance;}public static void writeObject2File() throws Exception {//获取Singleton类的对象Singleton instance = Singleton.getInstance();//创建对象输出流ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\a.txt"));//将instance对象写出到文件中oos.writeObject(instance);}
}

2.反射

public class Test {public static void main(String[] args) throws Exception {//获取Singleton类的字节码对象Class clazz = Singleton.class;//获取Singleton类的私有无参构造方法对象Constructor constructor = clazz.getDeclaredConstructor();//取消访问检查constructor.setAccessible(true);//创建Singleton类的对象s1Singleton s1 = (Singleton) constructor.newInstance();//创建Singleton类的对象s2Singleton s2 = (Singleton) constructor.newInstance();//判断通过反射创建的两个Singleton对象是否是同一个对象System.out.println(s1 == s2);}
}