【设计模式】单例设计模式

待我称王封你为后i 2024-03-04 07:21 104阅读 0赞

**目录**

1、前言

2、基本语法

2.1、懒汉式单例

2.2、饿汉式单例

2.3、双重检验锁单例模式

2.4、静态内部类单例模式

2.5、枚举单例模式

2.6、ThreadLocal单例模式

2.7、注册单例模式

3、使用场景

4、使用示例

5、常见问题

5、总结

## 1、前言 ##

单例模式是一种设计模式，它确保一个类只能创建一个实例，并提供一种全局访问这个实例的方式。在Java中，单例模式可以通过多种方式来实现，其中最常见的是使用私有构造函数和静态方法实现

## 2、基本语法 ##

在Java中，实现单例模式的方式有多种，其中最常见的实现方式包括以下几种：

### 2.1、懒汉式单例 ###

懒汉式单例模式指的是在第一次使用单例对象时才创建实例。具体实现方式是在getInstance()方法中判断实例是否已经被创建，如果没有则创建一个新实例并返回。懒汉式单例模式的缺点是线程不安全，在多线程环境下可能会创建多个实例。

public class Singleton {
        private static Singleton instance;
    
        private Singleton() {
            // 私有构造函数
        }
    
        public static Singleton getInstance() {
            if (instance == null) {
                instance = new Singleton();
            }
            return instance;
        }
    }

### 2.2、饿汉式单例 ###

饿汉式单例模式指的是在类加载时就创建实例，因此也被称为静态单例模式。具体实现方式是将实例化语句放在静态代码块中。由于在类加载时就创建了实例，因此不存在线程安全性问题。

public class Singleton {
        private static Singleton instance = new Singleton();
        
        private Singleton() {
            // 私有构造函数
        }
        
        public static Singleton getInstance() {
            return instance;
        }
    }

### 2.3、双重检验锁单例模式 ###

双重检验锁单例模式是一种线程安全的单例模式实现方式，它通过使用synchronized关键字来确保线程安全性。具体实现方式是在getInstance()方法中添加双重检验锁，这可以避免不必要的锁竞争和实例化。

public class Singleton {
        private static volatile Singleton instance;
        
        private Singleton() {
            // 私有构造函数
        }
        
        public static Singleton getInstance() {
            if (instance == null) {
                synchronized (Singleton.class) {
                    if (instance == null) {
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }

### 2.4、静态内部类单例模式 ###

静态内部类单例模式是一种比较常用的单例模式实现方式，它利用了静态内部类只会在被使用时才会加载的特点，从而避免了饿汉式单例模式的资源浪费和懒汉式单例模式的线程不安全问题。

public class Singleton {
        private static class SingletonHolder {
            private static final Singleton INSTANCE = new Singleton();
        }
        
        private Singleton() {
            // 私有构造函数
        }
        
        public static Singleton getInstance() {
            return SingletonHolder.INSTANCE;
        }
    }

### 2.5、枚举单例模式 ###

枚举单例模式是一种更为简单和安全的单例模式实现方式，它利用了Java中枚举类型本身就是单例的特点。枚举单例模式是一种天然线程安全的单例模式实现方式，而且可以防止反射和序列化等攻击。

public enum Singleton {
        INSTANCE;
        
        // 其他方法
    }

### 2.6、ThreadLocal单例模式 ###

ThreadLocal单例模式是一种可以在多线程环境下确保单例对象的线程安全单例模式实现方式。具体实现方式是在ThreadLocal中保存单例对象，每个线程都有自己的ThreadLocal副本，从而避免了线程安全性问题。

public class Singleton {
        private static final ThreadLocal<Singleton> INSTANCE = new ThreadLocal<Singleton>() {
            @Override
            protected Singleton initialValue() {
                return new Singleton();
            }
        };
        
        private Singleton() {
            // 私有构造函数
        }
        
        public static Singleton getInstance() {
            return INSTANCE.get();
        }
    }

### 2.7、注册单例模式 ###

注册式单例模式指的是通过一个注册表来管理所有单例对象，从而实现单例模式。具体实现方式是在一个静态的Map中保存所有单例对象，然后在需要使用单例对象时通过Map来获取。

public class Singleton {
        private static Map<String, Singleton> instances = new HashMap<>();
        
        private Singleton() {
            // 私有构造函数
        }
        
        public static Singleton getInstance(String name) {
            if (!instances.containsKey(name)) {
                instances.put(name, new Singleton());
            }
            return instances.get(name);
        }
    }

## 3、使用场景 ##

单例模式通常在需要确保全局只有一个实例的场景中使用，例如：

1.  线程池：在多线程环境下，线程池需要保证只有一个实例。
2.  数据库连接池：同样地，数据库连接池也需要保证只有一个实例。
3.  日志对象：日志对象通常是全局可见的，因此需要保证只有一个实例。
4.  配置文件：在某些情况下，需要全局共享的配置文件也需要保证只有一个实例。

## 4、使用示例 ##

下面是一个简单的例子，演示如何使用单例模式实现线程池：

public class ThreadPool {
        private static ThreadPool instance;
        
        private ThreadPool() {
            // 初始化线程池
        }
        
        public static synchronized ThreadPool getInstance() {
            if (instance == null) {
                instance = new ThreadPool();
            }
            return instance;
        }
        
        // 线程池相关的方法
    }

在上述代码中，我们使用synchronized关键字来保证getInstance()方法的线程安全性。这意味着每次只有一个线程可以访问getInstance()方法，从而避免了多个线程同时创建线程池实例的问题。

## 5、常见问题 ##

单例模式的实现有一些常见问题，需要注意：

1.  线程安全性：如上所述，如果多个线程同时访问getInstance()方法，可能会导致多个实例的创建。因此，需要确保getInstance()方法是线程安全的，可以通过synchronized关键字来实现。
2.  序列化问题：如果单例类实现了Serializable接口，那么在反序列化时可能会创建多个实例。解决方法是在类中添加readResolve()方法，并返回单例实例。
3.  反射问题：通过反射机制，可以调用私有构造函数创建实例。解决方法是在构造函数中添加判断，如果已经存在实例则抛出异常

## 5、总结 ##

单例模式是一种非常常用的设计模式，在多线程环境下，它可以确保只有一个实例被创建，并提供一种全局访问这个实例的方式。在Java中，可以通过私有构造函数和静态方法实现单例模式。在实现单例模式时，需要注意线程安全性、序列化问题以及反射问题。尽管单例模式非常有用，但也有一些缺点，例如它可能导致代码变得更加复杂，而且在多线程环境下可能会影响性能。因此，在使用单例模式时需要根据具体情况进行权衡。