public class Singleton01 {private static Singleton01 singleton01 = null;/*** 私有构造函数*/private Singleton01() {}/*** 懒汉式 线程不安全** @return*/public static Singleton01 getInstance() {if (singleton01 == null) {singleton01 = new Singleton01();}return singleton01;}public static void main(String[] args) {Singleton01 instance1 = Singleton01.getInstance();Singleton01 instance2 = Singleton01.getInstance();System.out.println(instance1 == instance2);}}

public class Singleton02 {private static Singleton02 singleton02 = null;/*** 懒汉式线程安全 已经创建对象，获取该单例对象的时候还需要上锁效率比较低** @return*/public static synchronized Singleton02 getInstance() {if (singleton02 == null) {singleton02 = new Singleton02();}return singleton02;}public static void main(String[] args) {Singleton02 instance1 = Singleton02.getInstance();Singleton02 instance2 = Singleton02.getInstance();System.out.println(instance2 == instance1);}}

public class Singleton03 {private static volatile Singleton03 singleton03;public static Singleton03 getInstance() {// 第一次检查if (singleton03 == null) {//第二次检查synchronized (Singleton03.class) {if (singleton03 == null) {singleton03 = new Singleton03();}}}return singleton03;}public static void main(String[] args) {Singleton03 instance1 = Singleton03.getInstance();Singleton03 instance2 = Singleton03.getInstance();System.out.println(instance1==instance2);}}

public class Singleton04 {/*** 提前创建单例对象，优点先天性 保证线程安全，比较占用内存*/public static final Singleton04 singleton04 = new Singleton04();private Singleton04() {}private static Singleton04 getInstance() {return singleton04;}public static void main(String[] args) {Singleton04 instance1 = Singleton04.getInstance();Singleton04 instance2 = Singleton04.getInstance();System.out.println(instance1 == instance2);}}

public class Singleton04 {/*** 提前创建单例对象，优点先天性 保证线程安全，比较占用内存*/public static final Singleton04 singleton04 = new Singleton04();private Singleton04() {}private static Singleton04 getInstance() {return singleton04;}public static void main(String[] args) {Singleton04 instance1 = Singleton04.singleton04;Singleton04 instance2 = Singleton04.singleton04;System.out.println(instance1 == instance2);}}

public class Singleton05 {private static Singleton05 singleton05;static {singleton05 = new Singleton05();}public static Singleton05 getInstance() {return singleton05;}public static void main(String[] args) {Singleton05 instance1 = Singleton05.getInstance();Singleton05 instance2 = Singleton05.getInstance();System.out.println(instance1 == instance2);}}

public class Singleton06 {private Singleton06() {System.out.println(">>>Singleton06");}private static class SingletonHolder {private static final Singleton06 singleton06 = new Singleton06();}public static final Singleton06 getInstance() {return SingletonHolder.singleton06;}public static void main(String[] args) {Singleton06 instance1 = Singleton06.getInstance();Singleton06 instance2 = Singleton06.getInstance();System.out.println(instance1==instance2);}}

public enum Singleton07 {INSTANCE;public void getInstance() {System.out.println("<<<getInstance>>>");}}

private Singleton01() throws Exception {if (singleton01 != null) {throw new Exception("该对象已经创建");}System.out.println("无参构造函数");}

Class<?> aClass = Class.forName("com.mayikt.Singleton01");Constructor<?> constructor = aClass.getDeclaredConstructor();constructor.setAccessible(true);Singleton01 instance02 = Singleton01.getInstance();Singleton01 singleton01 = (Singleton01) constructor.newInstance();System.out.println(singleton01==instance02);

// 1.将对象序列化存入到本地文件中FileOutputStream fos = new FileOutputStream("d:/code/a.txt");ObjectOutputStream oos = new ObjectOutputStream(fos);Singleton04 singleton1 = Singleton04.singleton04;oos.writeObject(singleton1);oos.close();fos.close();//2.从硬盘中反序列化对象到内存中ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:/code/a.txt"));Singleton04 singleton2 = (Singleton04) ois.readObject();System.out.println(singleton1);System.out.println(singleton2);

public class Singleton04 implements Serializable {/*** 提前创建单例对象，优点先天性 保证线程安全，比较占用内存*/public static final Singleton04 singleton04 = new Singleton04();private Singleton04() {System.out.println("Singleton04");}private static Singleton04 getInstance() {return singleton04;}public static void main(String[] args) {Singleton04 instance1 = Singleton04.singleton04;Singleton04 instance2 = Singleton04.singleton04;System.out.println(instance1 == instance2);}}

private Object readResolve() throws ObjectStreamException {return singleton04;}

//         1.将对象序列化存入到本地文件中FileOutputStream fos = new FileOutputStream("d:/code/a.txt");ObjectOutputStream oos = new ObjectOutputStream(fos);Singleton07 singleton1 = Singleton07.INSTANCE;oos.writeObject(singleton1);oos.close();fos.close();//2.从硬盘中反序列化对象到内存中ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:/code/a.txt"));Singleton07 singleton2 = (Singleton07) ois.readObject();System.out.println(singleton1==singleton2);