设计模式之单例模式（singleton）☆

以你之姓@ 2024-03-26 15:41 70阅读 0赞

**目录**

基本概念和功能

1-1、饿汉模式

1-2、懒汉模式

1-3、双锁机制

1-4、静态内部类

1-5、枚举

--------------------

## 基本概念和功能 ##

让设计的类在整个应用程序期间，能且**只能产生一个对象**

### **1-1、饿汉模式** ###

#### 思路 ####

构造方法私有化,剥夺外部 随意产生对象的权利；用static修饰 获取对象，对象在**加载期**产生，全类共享的唯一对象；用静态方法去返回 预先产生好的对象

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

public class Singleton {
        private Singleton(){
        }
        public static Singleton instance=new Singleton();
    }

> 优点：线程安全，因为实例对象在加载期就产生了  
> 缺点：会预加载，对内存空间有消耗；无论使用者是否调用了方法，都会在加载类的时候，产生它的对象

### 1-2、懒汉模式 ###

#### 思路 ####

构造私有化；用static修饰 对象初始化为null； 调用指定实例方法的时候，再进行实例化

在多线程的情况下，由于可能两个线程都会得到一份instance=null，这是因为如果线程1修改了自己线程中的instance后还没来得及修改主内存中的instance，所导致线程2也实例化出了一份instance对象，这时候也就不再是单例模式了。导致了对instance的修改操作，失去了原子性，为了保证原子性，我们想到了加锁，从而实现线程安全问题，所以需要用同步方法（加synchronized关键字），以确保代码不可分割，但是这样的话，这个方法每次只能被一个线程调用，其他线程需要等待。执行完一个线程后，其他线程才能调用，所以这样就不支持高并发了

public class Singleton {
        private static Singleton instance=null;
        private Singleton(){
        }
        public static synchronized Singleton getInstance(){
            if(instance==null){
                instance=new Singleton();
            }
            return instance;
        }
    }

> 优点：延迟加载（使用时再产生对象 ）
> 
> 缺点：不支持高并发

### **1-3、双锁机制** ###

#### 思路 ####

用两个if判断

第一层if，判断当前是否已经把实例创建出来，一旦instance产生后，所有调用方法的线程不用排队，支持高并发

用同步块，让线程来竞争锁，当拿到锁的线程进入到第二层if之后判断是否为空，不为空就是实例化对象，然后再释放锁，释放锁之后，instance已经不为空了，后面的线程就被阻挡在了第二层if这里了。之后再访问getInstance()方法，发现该instance已经不为空了，就不用再抢占锁资源了，也就不用再执行new语句。因为竞争锁也消耗大量的时间。通过这样处理，既保证了线程安全，也提高了效率。

volatile刷新缓存，解决可见性问题（不然一个线程调用了方法 instance已经不为空了，另外一个线程去判断的时候还是空）

public class Singleton {
        private static volatile Singleton instance=null;
        private Singleton2(){
        }
        public static  Singleton getInstance(){
            if(instance==null){
                synchronized (Singleton.class){
                    if(instance==null) {
                        instance=new Singleton();
                    }
                }
            }
            return instance;
        }
    }

> 优点：延迟加载，线程安全，支持高并发
> 
> 缺点：在JDK1.5之前，Java程序员只能看，不能用。 JDK1.5之后，加入了volatile关键字，解决了可见性问题，这个代码Java 才可以使用

### **1-4、静态内部类** ###

#### 思路 ####

当任何一个线程第一次调用方法，开始使用这个类时内部类才会被加载和被初始化，所以它是延迟加载；内部静态类只会被加载一次，一个线程调用了方法后，加载了内部类，后面的线程再怎么调用，用的都是那个初始的那个，所以它是线程安全的；这个方法没有用锁机制，不会出现排队等待的问题，因此支持高并发

public class Singleton {
        private static class InnerClass{
            private static Singleton instance = new Singleton();
        }
    
        private Singleton(){}
    
        public static Singleton getInstance(){
            return InnerClass.instance;
        }
    }

> 优点：延迟加载、线程安全、高并发
> 
> 缺点：对初级程序员不友好，因为用了内部类以及static的语法机制

### **1-5、枚举** ###

#### 思路 ####

利用枚举的语法特性，只给这个枚举类型定义一个枚举对象值， 底层自动实现单例模式。

public enum Singleton5 {
        INSTANCE;
    }

> 优点：线程安全，高并发；
> 
> 缺点：不是延迟加载的