实现单例模式的方式有哪些

拼搏现实的明天。 2022-07-21 11:13 140阅读 0赞

### 单例模式特点 ###

1、单例模式是用来实现在整个程序中只有一个实例的。  
2、单例类的构造函数必须为私有，同时单例类必须提供一个全局访问点。

### 有哪些实现方式？ ###

synchronized同步锁的方式导致性能低下，考虑以下实现方式：

1、静态内部类，常用的简单实现方式，既保证了安全又实现了懒加载

2、饿汉式，应用启动时初始化实例对象

3、懒汉式，为了支持懒加载而设计，通过synchronized来实现

4、双重检测，懒汉式有性能问题

5、枚举

//饿汉式
    public class Singleton { 
           private static final Singleton singleton = new Singleton();
            //私有的构造函数 
           private Singleton() {}
    
           public static Singleton getInstance() { 
                return singleton; 
            } 
    }
    
    //懒汉式
    public class Singleton { 
           private static Singleton singleton;
    
            //私有的构造函数 
           private Singleton() {}
    
           public static synchronized Singleton getInstance() { 
                if(singleton == null){
                    singleton = new Singleton(); 
                }
    
                return singleton;
            } 
    }

//双重锁定方式
    public class Singleton { 
           private static Singleton singleton;
    
            //私有的构造函数 
           private Singleton() {}
    
           public static Singleton getInstance() { 
                if (singleton == null) { 
                    sychronized(Singleton.class) {//这里是关键，一定是类级别的锁
                        if (singleton == null) { 
                            singleton = new Singleton(); 
                        } 
                    } 
                } 
                return singleton; 
            } 
    }

### 静态内部类方式来实现 ###

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

再来一例

public class JobQueue<T> {
        private LoanTask task;
        private JobQueue(LoanTask task){
    		super();
    		this.task = task;
        }
        /**
         * 用户相关处理：注册开户，绑定银行卡等
         * @return
         */
        public static JobQueue <ValueEvent> getUserInstance() {
            return LazyHolder.USER_INSTANCE;
        }
    
        //静态内部类
        private static class LazyHolder {
            // 用户相关队列
            private static final JobQueue <ValueEvent> USER_INSTANCE = new JobQueue<ValueEvent>(new UserTask());
        }
        
        
        
    }

为什么要用这种静态内部类方式？

1、内部类只在需要的时候才会被类加载器加载，实现了懒加载；

2、由于instance是static 类型，保证了内存中只有这样一个实例存在；

3、final 只能被赋值一次，从而保证了线程安全性（即使在高并发情况下多线程同时调用getInstance()方法，也能保证实例的唯一性）；

//利用AtomicLong的安全特性，java语言特有的实现方式
    public enum IdGenerator {
      INSTANCE;
      private AtomicLong id = new AtomicLong(0);
     
      public long getId() { 
        return id.incrementAndGet();
      }
    }

### 拓展思考 ###

实际场景下，单例模式又可以按情况分为：线程单例、进程单例和集群单例。

线程单例：如web一次会话session，ThreadLoacal可以实现，[ThreadLocal的使用][ThreadLocal]

进程单例：在一个jvm内的单例

集群单例：雪花算法生成唯一Id

[ThreadLocal]: https://blog.csdn.net/chang_li/article/details/52188824?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522160059318919725254029568%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=160059318919725254029568&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_v1~rank_blog_v1-1-52188824.pc_v1_rank_blog_v1&utm_term=threadlocal&spm=1018.2118.3001.4187