详解:设计模式之-单例设计模式

分享一波:程序员赚外快-必看的巅峰干货

前言

近期预计1-2周左右会更新设计模式专题文章。

单例设计模式：保证在一个JVM中，只能存在一个实例。

应用场景：Servlet，Spring IOC，线程池，连接池，Spring AOP

单例设计模式的优缺点

好处：节约内存，重复利用，方便管理

缺点：存在线程安全问题

单例设计模式分类

  1. 饿汉式:类初始化时,会立即加载该对象，线程天生安全,调用效率高。

  2. 懒汉式: 类初始化时,不会初始化该对象,真正需要使用的时候才会创建该对象,具备懒加载功能。

  3. 静态内部方式:结合了懒汉式和饿汉式各自的优点，真正需要对象的时候才会加载，加载类是线程安全的。

  4. 枚举单例: 使用枚举实现单例模式 优点:实现简单、调用效率高，枚举本身就是单例，由jvm从根本上提供保障。避免通过反射和反序列化的漏洞， 缺点没有延迟加载。

5.双重检测锁方式 (因为JVM本质重排序的原因，可能会初始化多次，不推荐使用)

其中 ，饿汉式和懒汉式使用最为普遍

饿汉式创建单例

/**

  • 饿汉式
    /
    public class User01 {
    /    *

    • 类初始化时,会立即加载该对象，线程天生安全,调用效率高
      */
      private static User01 singletonDemo01 = new User01();

    private User01() {
    System.out.println(“SingletonDemo01初始化”);
    }

    public static User01 getInstance() {
    System.out.println(“getInstance”);
    return singletonDemo01;
    }

    public static void main(String[] args) {
    User01 s1 = User01.getInstance();
    User01 s2 = User01.getInstance();
    System.out.println(s1 == s2);
    }

}

懒汉式创建单例

/**

  • 懒汉式
    */
    public class User02 {

    /**

    • 类初始化时，不会初始化该对象，真正需要使用的时候才会创建该对象。
      */
      private static User02 singletonDemo02;

    private User02() {

    }

    public synchronized static User02 getInstance() {
    if (singletonDemo02 == null) {
    singletonDemo02 = new User02();
    }
    return singletonDemo02;
    }

    public static void main(String[] args) {
    User02 s1 = User02.getInstance();
    User02 s2 = User02.getInstance();
    System.out.println(s1 == s2);
    }

}

静态内部类方式创建单例

/**

  • 静态内部类方式
    */
    public class SingletonDemo03 {
    private SingletonDemo03() {
    System.out.println(“初始化…”);
    }

    public static class SingletonClassInstance {
    private static final SingletonDemo03 singletonDemo03 = new SingletonDemo03();
    }

    // 方法没有同步
    public static SingletonDemo03 getInstance() {
    System.out.println(“getInstance”);
    return SingletonClassInstance.singletonDemo03;
    }

    public static void main(String[] args) {
    SingletonDemo03 s1 = SingletonDemo03.getInstance();
    SingletonDemo03 s2 = SingletonDemo03.getInstance();
    System.out.println(s1 == s2);
    }
    }

优势：兼顾了懒汉模式的内存优化（使用时才初始化）以及饿汉模式的安全性（不会被反射入侵）。

劣势：需要两个类去做到这一点，虽然不会创建静态内部类的对象，但是其 Class 对象还是会被创建，而且是属于永久带的对象。

枚举方式创建单例

enum UserEnum {
HTTP_200(200, “请求成功”),HTTP_500(500,“请求失败”);
private Integer code;
private String name;
UserEnum(Integer code, String name) {
this.code = code;
this.name = name;
}
public Integer getCode() {
return code;
}

public void setCode(Integer code) {
	this.code = code;
}

public String getName() {
	return name;
}

public void setName(String name) {
	this.name = name;
}

}

public class TestEnum {

public static void main(String[] args) {
	System.out.println(UserEnum.HTTP_500.getCode());
}

}

public class User {
public static User getInstance() {
return SingletonDemo04.INSTANCE.getInstance();
}

private static enum SingletonDemo04 {
	INSTANCE;
	// 枚举元素为单例
	private User user;

	private SingletonDemo04() {
        System.out.println("SingletonDemo04");
        user = new User();
	}

public User getInstance() {
    return user;
    }
}

public static void main(String[] args) {
User u1 = User.getInstance();
User u2 = User.getInstance();
System.out.println(u1 == u2);
}

}

分享一波:程序员赚外快-必看的巅峰干货

如果以上内容对你觉得有用,并想获取更多的赚钱方式和免费的技术教程

请关注微信公众号:HB荷包
在这里插入图片描述
一个能让你学习技术和赚钱方法的公众号,持续更新

posted @ 2020-12-17 11:47  游在空中的鱼  阅读(73)  评论(0)  编辑  收藏  举报