单例模式各种写法

单例模式

单例设计模式,采取一定的方法保证在整个软件系统中,对某个类只能存在一个对象实例。

单例模式使用场景

  1. 单例模式保证了系统内存中该类只存在一个对象,节省了系统资源,对于一些需要频繁创建销毁的对象,使用单例模式可以提高系统性能。

  2. 当想实现一个单例类的时候,必须要记住使用相应获取对象的方法,而不是使用new

  3. 需要频繁的进行创建和销毁的对象,创建对象是消耗时间过多或耗费资源过多,但又经常用到的对象,工具类对象,频繁访问数据库或文件的对象等(比如数据源,session等)。

饿汉式(静态常量)

步骤:

  1. 构造器私有化

  2. 类的内部创建对象

  3. 向外部暴露一个静态的公共方法

 /**
  * @author 
  * (饿汉式 静态常量写法)
  */
 public class SingleTest01 {
     private SingleTest01(){
 ​
     }
     private final static SingleTest01 INSTANCE = new SingleTest01();
     public static  SingleTest01 getInstance (){
        return INSTANCE;
     }
 }
 ​
 ​

测试:

 //测试:  
     @Test
     public void test(){
         SingleTest01 singleTest01= SingleTest01.getInstance();
         SingleTest01 singleTest02= SingleTest01.getInstance();
         System.out.println(singleTest01);
         System.out.println(singleTest02);
 ​
     }  

优点:写法简单,在类装载时就完成了实例化,避免了线程同步问题

缺点: 在类装载就完成实例化,没有达到懒加载(lazy loading)的效果,如果没有用到这个实例,可能造成内存浪费。

饿汉式(静态代码块)

 **
  * @author 
  * (饿汉式: 静态代码块)
  */
 public class SingleTest02 {
     private SingleTest02(){
 ​
     }
     private  static SingleTest02 INSTANCE ;
     static {
         INSTANCE = new SingleTest02();
     }
     public static SingleTest02 getInstance (){
        return INSTANCE;
     }
 ​
 }
 ​

测试:

 //测试:
   
     @Test
     public void test(){
         SingleTest02 singleTest01= SingleTest02.getInstance();
         SingleTest02 singleTest02= SingleTest02.getInstance();
         System.out.println(singleTest01);
         System.out.println(singleTest02);
 ​
     }  

优缺点同饿汉式静态常量

懒汉式(线程不安全):

 /**
  * @author 
  * (懒汉式: 静态代码块)
  */
 public class SingleTest03 {
     private SingleTest03(){
 ​
     }
     private  static SingleTest03 INSTANCE ;
     public static SingleTest03 getInstance (){
        if(INSTANCE ==null){
            INSTANCE =new SingleTest03();
        }
        return INSTANCE;
     }
 ​
 }

优缺点:起到懒加载的效果,但是只能在单线程下使用

原因:在多线程情况下,一个线程进入了if(INSTANCE ==null)判断但还没来得及往下执行,另一个也通过了这个判断语句,产生多个实例。

懒汉式(线程安全):

 /**
  * @author
  * (懒汉式: 静态代码块)
  */
 public class SingleTest04 {
     private SingleTest04(){
 ​
     }
     private  static SingleTest04 INSTANCE ;
     //加入synchronized
     public static synchronized SingleTest04 getInstance (){
        if(INSTANCE ==null){
            INSTANCE = new SingleTest04();
        }
        return INSTANCE;
     }
 }

优点: 实现了懒加载解决了线程不安全问题。

缺点:效率太低,每个线程想获取类的实例时候,getInstance()方法都要进行同步。

双重检查

 /**
  * @author
  *  双重检查
  */
 public class SingleTest05 {
     private SingleTest05(){
 ​
     }
     // volatile 实时写入主存
     private  static volatile SingleTest05 INSTANCE ;
     //加入双重解决代码 解决线程安全 同时实现懒加载
     public static synchronized SingleTest05 getInstance (){
        if(INSTANCE ==null){
            synchronized (SingleTest05.class){
                if (INSTANCE == null) {
                    INSTANCE=new SingleTest05();
                }
            }
        }
        return INSTANCE;
     }
 }

优点:实现了懒加载,线程安全,同时提高了效率,推荐使用

静态内部类方式

 /**
  * @author
  * (静态内部类实例)
  */
 public class SingleTest06 {
     private SingleTest06(){
 ​
     }
     private static class SingletonInstance {
         private static final SingleTest06 INSTANCE = new SingleTest06();
     }
 ​
     public static SingleTest06 getInstance(){
         return SingletonInstance.INSTANCE;
     }
 ​
 }

优点:

  1. 这种方式采用类装载的机制来保证初始化实例只有一个线程

  2. 静态内部类方式在SingleTest06类被装载时并不会立即实例化,而是在需要实例化时,调用了getInstance方法,才会装载SingletonInstance类,从而完成SingleTest06 的实例化。

  3. 类的静态属性只会在第一次加载类的时候进行初始化,jvm保证了线程的安全性,在类进行初始化时,别的线程无法进入

  4. 避免了线程不安全,利用静态内部类特点实现了延迟加载,效率高

枚举方式

 public enum Singleton07 {
     INSTANCE;
     public void sayHello(){
         System.out.println("hello");
     }
 }

测试:

  @Test
     public void test5(){
         Singleton07 singleTest01= Singleton07.INSTANCE;
         Singleton07 singleTest02= Singleton07.INSTANCE;
         System.out.println(singleTest01 == singleTest02);
         singleTest01.sayHello();
     }

优缺点:不仅避免多线程同步问题,而且该方法还能防止反序列化从新创建新的对象。

单例模式是一种常用的软件设计模式,它保证一个类仅有一个实例,并提供一个全局访问点。以下是几种常见的单例模式实现方法: 1. **懒汉式**(Lazy Initialization): 这是最简单的实现方式,只有当第一次需要实例时才创建。典型地,通过静态变量和构造函数私有化来保证只有一个实例。 ```java public class Singleton { private static Singleton instance; private Singleton() {} public static synchronized Singleton getInstance() { if (instance == null) { instance = new Singleton(); } return instance; } } ``` 2. **饿汉式**(Eager Initialization): 在类加载时就预先初始化了实例。这种方式可能会消耗更多的内存资源,但能保证线程安全。 ```java public class Singleton { private static final Singleton INSTANCE = new Singleton(); private Singleton() {} public static Singleton getInstance() { return INSTANCE; } } ``` 3. **双重检查锁定(Double-Checked Locking)**: 针对多线程环境优化懒汉式,降低锁的持有时间。先判断是否已创建,如果未创建再加锁并创建。 ```java public class Singleton { private volatile static Singleton instance; private Singleton() {} public static Singleton getInstance() { if (instance == null) { synchronized (Singleton.class) { if (instance == null) { instance = new Singleton(); } } } return instance; } } ``` 4. **枚举单例**(Enum Singleton): 利用Java内置的枚举类型保证线程安全性,每个枚举只有一个实例。 ```java public enum Singleton { INSTANCE; } ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值