java单例模式几种实现方式

布满荆棘的人生 2022-03-20 06:20 301阅读 0赞

### 一、什么是单例模式 ###

单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。

### 二、为什么要使用单例模式 ###

对于系统中的某些类来说，只有一个实例很重要，例如，一个系统中可以存在多个打印任务，但是只能有一个正在工作的任务；一个系统只能有一个窗口管理器或文件系统；一个系统只能有一个计时工具或ID(序号)生成器。如在Windows中就只能打开一个任务管理器。如果不使用机制对窗口对象进行唯一化，将弹出多个窗口，如果这些窗口显示的内容完全一致，则是重复对象，浪费内存资源；如果这些窗口显示的内容不一致，则意味着在某一瞬间系统有多个状态，与实际不符，也会给用户带来误解，不知道哪一个才是真实的状态。因此有时确保系统中某个对象的唯一性即一个类只能有一个实例非常重要。  
如何保证一个类只有一个实例并且这个实例易于被访问呢？定义一个全局变量可以确保对象随时都可以被访问，但不能防止我们实例化多个对象。一个更好的解决办法是让类自身负责保存它的唯一实例。这个类可以保证没有其他实例被创建，并且它可以提供一个访问该实例的方法。这就是单例模式的模式动机。

### 三、常见的单例模式 ###

1、有频繁实例化然后销毁的情况，也就是频繁的 new 对象，可以考虑单例模式  
2、创建对象时耗时过多或者耗资源过多，但又经常用到的对象  
3、频繁访问 IO 资源的对象，例如数据库连接池或访问本地文件

举例：

1.网站在线人数统计，其实就是全局计数器，也就是说所有用户在相同的时刻获取到的在线人数数量都是一致的。要实现这个需求，计数器就要全局唯一，也就正好可以用单例模式来实现。当然这里不包括分布式场景，因为计数是存在内存中的，并且还要保证线程安全。

public class Counter {
       
        private static class CounterHolder{
            private static final Counter counter = new Counter();
        }
     
        private Counter(){
            System.out.println("init...");
        }
     
        public static final Counter getInstance(){
            return CounterHolder.counter;
        }
     
        private AtomicLong online = new AtomicLong();
     
        public long getOnline(){
            return online.get();
        }
     
        public long add(){
            return online.incrementAndGet();
        }
    }

2.配置文件访问类，项目中经常需要一些环境相关的配置文件，比如短信通知相关的、邮件相关的。比如 properties 文件，这里就以读取一个properties 文件配置为例，如果你使用的 Spring ，可以用 @PropertySource 注解实现，默认就是单例模式。如果不用单例的话，每次都要 new 对象，每次都要重新读一遍配置文件，很影响性能，如果用单例模式，则只需要读取一遍就好了。

public class SingleProperty {
     
        private static Properties prop;
     
        private static class SinglePropertyHolder{
            private static final SingleProperty singleProperty = new SingleProperty();
        }
     
        /**
        * config.properties 内容是 test.name=kite 
        */
        private SingleProperty(){
            System.out.println("构造函数执行");
            prop = new Properties();
            InputStream stream = SingleProperty.class.getClassLoader()
                    .getResourceAsStream("config.properties");
            try {
                prop.load(new InputStreamReader(stream, "utf-8"));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
     
        public static SingleProperty getInstance(){
            return SinglePropertyHolder.singleProperty;
        }
        
        
        public String getName(){
            return prop.get("test.name").toString();
        }
     
        public static void main(String[] args){
            SingleProperty singleProperty = SingleProperty.getInstance();
            System.out.println(singleProperty.getName());
        }
    }

3.数据库连接池的实现，也包括线程池。为什么要做池化，是因为新建连接很耗时，如果每次新任务来了，都新建连接，那对性能的影响实在太大。所以一般的做法是在一个应用内维护一个连接池，这样当任务进来时，如果有空闲连接，可以直接拿来用，省去了初始化的开销。所以用单例模式，正好可以实现一个应用内只有一个线程池的存在，所有需要连接的任务，都要从这个连接池来获取连接。如果不使用单例，那么应用内就会出现多个连接池，那也就没什么意义了。如果你使用 Spring 的话，并集成了例如 druid 或者 c3p0 ，这些成熟开源的数据库连接池，一般也都是默认以单例模式实现的。

### 四、单例模式实现方式 ###

1、饿汉式(线程安全，调用效率高，但是不能延时加载)，不推荐

public class ImageLoader{ 
         private static ImageLoader instance = new ImageLoader; 
         private ImageLoader(){} 
         public static ImageLoader getInstance(){  
              return instance;  
          } 
    }

2、懒汉式(线程安全，调用效率不高，但是能延时加载)，不推荐

public class SingletonDemo2 {
         
        //类初始化时，不初始化这个对象(延时加载，真正用的时候再创建)
        private static SingletonDemo2 instance;
         
        //构造器私有化
        private SingletonDemo2(){}
         
        //方法同步，调用效率低
        public static synchronized SingletonDemo2 getInstance(){
            if(instance==null){
                instance=new SingletonDemo2();
            }
            return instance;
        }
    }

3、Double CheckLock实现单例：DCL也就是双重锁判断机制（由于JVM底层模型原因，偶尔会出问题，不建议使用）

public class SingletonDemo5 {
              private volatile static SingletonDemo5 SingletonDemo5;
       
              private SingletonDemo5() {
              }
       
              public static SingletonDemo5 newInstance() {
                  if (SingletonDemo5 == null) {
                      synchronized (SingletonDemo5.class) {
                         if (SingletonDemo5 == null) {
                             SingletonDemo5 = new SingletonDemo5();
                         }
                     }
                 }
                 return SingletonDemo5;
             }
         }

4、静态内部类实现模式（线程安全，调用效率高，可以延时加载）

public class SingletonDemo3 {     
          private static class SingletonClassInstance{
              private static final SingletonDemo3 instance=new SingletonDemo3();
          }
           
          private SingletonDemo3(){}
           
          public static SingletonDemo3 getInstance(){
             return SingletonClassInstance.instance;
         }
          
     }

5、枚举类（线程安全，调用效率高，不能延时加载，可以天然的防止反射和反序列化调用），推荐

public enum SingletonDemo4 {
          
         //枚举元素本身就是单例
         INSTANCE;
          
         //添加自己需要的操作
         public void singletonOperation(){     
         }
     }

如何选用：

\-单例对象 占用资源少，不需要延时加载，枚举 好于 饿汉

\-单例对象 占用资源多，需要延时加载，静态内部类 好于 懒汉式