三、《重学设计模式》-单例模式

单例模式

单例模式分为四大类，饿汉式、懒汉式、静态内部类、枚举

饿汉式

优点：类装载时进行实例化，避免同步问题

缺点：造成内存浪费

实现一

1.构造器私有化

2.内部创建对象实例

3.提供静态方法

public class Type1 {public static void main(String[] args) {SingleTon1 instance = SingleTon1.getInstance();SingleTon1 instance1 = SingleTon1.getInstance();System.out.println(instance == instance1);System.out.println(instance.hashCode());System.out.println(instance1.hashCode());}
}class SingleTon1{// 加载实例化private static  final SingleTon1 instance = new SingleTon1();private SingleTon1(){}public static SingleTon1 getInstance(){return instance;}
}

实现二

1.构造器私有化

2.静态变量

3.静态代码块初始化

public class Type2 {public static void main(String[] args) {SingleTon2 instance = SingleTon2.getInstance();SingleTon2 instance1 = SingleTon2.getInstance();System.out.println(instance == instance1);System.out.println(instance.hashCode());System.out.println(instance1.hashCode());}
}class SingleTon2{private static SingleTon2 instance;private SingleTon2(){}// 静态块static {instance = new SingleTon2();}public static SingleTon2 getInstance(){return instance;}
}

懒汉式

方案一（线程不安全）

1.静态变量

2.构造函数私有化

3.静态方法调用时创建实例

public class Type3 {public static void main(String[] args) {SingleTon3 instance = SingleTon3.getInstance();SingleTon3 instance1 = SingleTon3.getInstance();System.out.println(instance == instance1);System.out.println(instance.hashCode());System.out.println(instance1.hashCode());}
}class SingleTon3 {private static SingleTon3 instance;private SingleTon3() {}public static SingleTon3 getInstance() {if (instance == null) {instance = new SingleTon3();}return instance;}
}

方案二（线程安全同步锁）

1.静态变量

2.构造函数私有化

3.静态方法调用时加synchronized同步锁，创建实例

缺点：效率低

public class Type4 {public static void main(String[] args) {SingleTon4 instance = SingleTon4.getInstance();SingleTon4 instance1 = SingleTon4.getInstance();System.out.println(instance == instance1);System.out.println(instance.hashCode());System.out.println(instance1.hashCode());}
}class SingleTon4 {private static SingleTon4 instance;private SingleTon4() {}// 同步锁，所有线程阻塞排队 public static synchronized SingleTon4 getInstance() {if (instance == null) {instance = new SingleTon4();}return instance;}
}

方案三（同步代码块，线程不安全， 不能用、不能用、不能用）

public class Type5 {public static void main(String[] args) {SingleTon5 instance = SingleTon5.getInstance();SingleTon5 instance1 = SingleTon5.getInstance();System.out.println(instance == instance1);System.out.println(instance.hashCode());System.out.println(instance1.hashCode());}
}class SingleTon5 {private static SingleTon5 instance;private SingleTon5() {}public static  SingleTon5 getInstance() {if (instance == null) {// 同步代码块，但是有两个线程同时进入if判断，就会创建多个实例synchronized (Type5.class){instance = new SingleTon5();}}return instance;}
}

方案四（双重检查）

优点：线程安全、懒加载、效率高

public class Type6 {public static void main(String[] args) {SingleTon6 instance = SingleTon6.getInstance();SingleTon6 instance1 = SingleTon6.getInstance();System.out.println(instance == instance1);System.out.println(instance.hashCode());System.out.println(instance1.hashCode());}
}class SingleTon6 {private volatile static  SingleTon6 instance;private SingleTon6() {}public static  SingleTon6 getInstance() {if (instance == null) {synchronized (Type5.class){if(instance == null){instance = new SingleTon6();}}}return instance;}
}

静态内部类

静态内部类特点，外部类装载时，内部类不会被装载

调用静态方法时，装载静态内部类，线程安全

静态内部类中定义静态变量

优点：静态内部类实现了延迟加载，线程安全有jvm控制

public class Type7 {public static void main(String[] args) {SingleTon7 instance = SingleTon7.getInstance();SingleTon7 instance1 = SingleTon7.getInstance();System.out.println(instance == instance1);System.out.println(instance.hashCode());System.out.println(instance1.hashCode());}
}class SingleTon7 {private SingleTon7() {}private static class SingleTon7Holder {private static final SingleTon7 INSTANCE = new SingleTon7();}public static SingleTon7 getInstance() {return SingleTon7Holder.INSTANCE;}
}

枚举

避免线程不安全，防止反序列化重新创建新对象

public class Type8 {public static void main(String[] args) {SingleTonEnum.INSTANCE.whateverMethod();}
}enum SingleTonEnum {INSTANCE;public void whateverMethod() {System.out.println("hhh");}
}

举例

JDK 中 RunTime

总结

1.频繁创建或销毁的对象适合使用单例模式

2.创建对象耗时过长或者资源过多适合使用单例模式

3.频繁用到的对象，类似工具类等，适合使用单例模式