单例设计模式
文章目录
单例模式(Singleton Pattern)是Java中最简单的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。
饿汉式
类加载就会导致该单例对象被创建。存在内存浪费。
1️⃣静态变量方式
public class Demo1 {
public static void main(String[] args) {
//创建Singleton的对象
Singleton1 singleton1 = Singleton1.getInstance();
Singleton1 singleton2 = Singleton1.getInstance();
//判断两个对象是否是同一个对象
System.out.println(singleton1 == singleton2); //输出true
}
}
class Singleton1{
/**
* 1.私有构造方法
*/
private Singleton1(){}
//2.在本类中创建本类对象
private static Singleton1 instance = new Singleton1();
//3.提供一个公共的访问方式,因为不能创建对象就不能使用其中的方法,所以使用静态方法
public static Singleton1 getInstance(){
return instance;
}
}
2️⃣静态代码块的方式
/**
* 静态代码块方式
*/
class Singleton2{
//1.私有构造方法
private Singleton2(){};
//2.声明Singleton2类型的变量
private static Singleton2 instance; //初始值为null。。。
//3.在静态代码块中赋值
static{
instance = new Singleton2();
}
//4.对外提供一个方法
public static Singleton2 getInstance(){
return instance;
}
}
3️⃣枚举方式
枚举实现单例模式是极力推荐的单例实现模式,因为枚举类型是线程安全的,并且只会装载一次,设计者冲分的利用了枚举的这个特性来实现单例模式。
public class Test {
public static void main(String[] args) {
EnumSingleton instance = EnumSingleton.INSTANCE;
EnumSingleton instance1 = EnumSingleton.INSTANCE;
System.out.println(instance == instance1);
}
}
/**
* 枚举方式
*/
public enum EnumSingleton {
INSTANCE;
}
不考虑空间的情况下,首选枚举。
懒汉式
1️⃣线程不安全的方式
package com.wangze.pattern.singleton;
/**
* @author 结构化思维wz
*/
public class Demo2 {
public static void main(String[] args) {
System.out.println("懒汉式创建=====线程不安全====");
//单线程模式
Singleton3 singleton3 = Singleton3.getInstance();
Singleton3 singleton4 = Singleton3.getInstance();
System.out.println(singleton3 == singleton4);
}
}
class Singleton3{
//1.私有构造方法
private Singleton3(){}
//2.声明Singleton类型的变量
private static Singleton3 intance;
//3.对外提供访问方式
public static Singleton3 getInstance(){
if (intance == null){
intance = new Singleton3();
}
return intance;
}
}
2️⃣线程安全的情况
/**
* 线程安全的情况
*/
class Singleton4{
//1.私有构造方法
private Singleton4(){}
//2.声明Singleton类型的变量
private static Singleton4 intance;
//3.对外提供访问方式
public static synchronized Singleton4 getInstance(){
if (intance == null){
intance = new Singleton4();
}
return intance;
}
}
这种方式虽然线程安全,但是会使性能下降。
3️⃣ 双重检查锁
/**
* 双重检查锁方式(把读写分离,读不用锁)
*/
class Singleton{
//1.私有构造方法
private Singleton(){}
//声明Singleton类型的变量
private static Singleton instance;
//对外提供公共的访问方式
public static Singleton getInstance(){
//第一次判断,如果instance的值不为 null,不需要抢占锁,直接返回对象。
if (instance == null){
synchronized (Singleton.class){
//第二次判断
if (instance == null){
instance = new Singleton();
}
}
}
return instance;
}
}
这种写法还存在问题,在多线程的情况下可能会出现空指针的问题,出现问题的原因是JVM的重排序,可以使用volatile
保证可见性和有序性。
/**
* 双重检查锁方式(把读写分离,读不用锁)
*/
class Singleton{
//1.私有构造方法
private Singleton(){}
//声明Singleton类型的变量
private static volatile Singleton instance;
//对外提供公共的访问方式
public static Singleton getInstance(){
//第一次判断,如果instance的值不为 null,不需要抢占锁,直接返回对象。
if (instance == null){
synchronized (Singleton.class){
//第二次判断
if (instance == null){
instance = new Singleton();
}
}
}
return instance;
}
}
4️⃣ 静态内部类方式
由于JVM在加载外部类的过程中,是不会加载静态内部类
的,只有静态内部类的属性/方法被调用时才会被加载。静态属性由于被static
修饰,保证只被实例化一次,并且严格保证实例化顺序。
class Singleton5{
//私有构造方法
private Singleton5(){}
//定义静态内部类
private static class SingletonHolder{
//在内部类中声明并初始化类的对象
private static final Singleton5 INSTANCE = new Singleton5();
}
//公共访问方式
public static Singleton5 getInstance(){
return SingletonHolder.INSTANCE;
}
}
说明:
第一次加载Singleton类时不会去初始化INSTANCE
,只有第一次调用getInstance()
的时候,JVM加载SingletonHolder
并初始化INSTANCE
。这样仅仅能保证线程安全,又能保证单例。
小结:
静态内部类推荐使用,没有性能影响和资源浪费。
存在的问题
破坏单例模式:
使上面定义的单例类可以创建多个对象,枚举方式除外。有两种方式,分别是序列化
和反射
。
解决序列化单例模式被破坏的问题:
/**
* @author 结构化思维wz
*/
public class Singleton implements Serializable {
//私有构造方法
private Singleton(){}
//定义静态内部类
private static class SingletonHolder{
//在内部类中声明并初始化类的对象
private static final Singleton INSTANCE = new Singleton();
}
//公共访问方式
public static Singleton getInstance(){
return SingletonHolder.INSTANCE;
}
//当进行反序列化时,会自动调用该方法,将该方法的返回值直接返回。如果不定义会重新创建
public Object readResolve(){
return SingletonHolder.INSTANCE;
}
}
解决反射破解:
package com.wangze.pattern.singleton;
/**
* @program: code
* @description: 解决反射破坏单例模式
* @author: 结构化思维wz
* @create: 2021-11-21 13:53
**/
public class FanSingleton {
private static boolean flag = false;
//私有构造方法
private FanSingleton(){
synchronized (FanSingleton.class){
//判断flag的值,如果是true说明不是第一次访问,直接抛出一个异常,如果是flag说明是第一次访问
if(flag){
throw new RuntimeException("单例模式,不能创建多个对象");
}
flag =true;
}
}
//定义静态内部类
private static class SingletonHolder{
//在内部类中声明并初始化外部类的对象
private static final FanSingleton INSTANCE = new FanSingleton();
}
//提供公共的访问方式
public static FanSingleton getInstance(){
return SingletonHolder.INSTANCE;
}
}