JAVA设计模式（一）单例模式

素颜马尾好姑娘i 2024-04-17 06:29 33阅读 0赞

![format_png][]

# 1.介绍 #

单例模式是一种对象创建型模式，保证一个类只有一个实例，其私有化构造方法公开一个全局访问的代理方法。

# 2.应用场景 #

*  操作系统的任务管理器
 *  读取配置文件的类
 *  数据库连接池
 *  Javaweb 中的 Servlet 实例
 *  Spring 创建的实例，默认为单例

# 3.实现方式 #

/**
     * 饿汉式单例
     */
    public class EagerSingleton {
    
        private static EagerSingleton eagerSingleton = new EagerSingleton();
    
        private EagerSingleton() {
    
        }
    
        public static EagerSingleton getInstance() {
            return eagerSingleton;
        }
    }

优点：线程安全，不用加同步锁，因此在高并发时调用效率高。

缺点：不能懒加载，如果不使用该类的实例，浪费内存资源。

/**
     * 懒汉式
     */
    public class LazySingleton {
    
        private static LazySingleton lazySingleton;
    
        private LazySingleton() {
    
        }
    
        public static LazySingleton getInstance() {
            if (lazySingleton == null) {
                lazySingleton = new LazySingleton();
            }
            return lazySingleton;
        }
    }

优点：实现懒加载，合理利用系统资源。

缺点：需要添加同步锁，高并发时调用效率不高。

**（注意：懒汉式可以通过反射机制创建多个实例。）**

public class SingletonTest {
        public static void main(String[] args)throws Exception {
            Class<?> clazz = Class.forName("com.design.singleton.LazySingleton");
            Constructor<?> constructor = clazz.getDeclaredConstructor(null);
    
            // 跳过检测机制
            constructor.setAccessible(true);
    
            LazySingleton lazySingleton1 = (LazySingleton) constructor.newInstance();
    
            LazySingleton lazySingleton2 = (LazySingleton) constructor.newInstance();
    
            System.out.println(lazySingleton1 == lazySingleton2);// 结果返回 false
        }
    }

**优化方式：**

public class Optimizing {
    
        private Optimizing() {
    
        }
    
        private static class innerSingleton{
            private static final Optimizing optimizing1 = new Optimizing();
        }
    
        public static Optimizing getInstance() {
            return innerSingleton.optimizing1;
        }
    }

外部类没有静态属性，因此不会像饿汉式立即加载对象。

只有当调用公共方法（getInstance）时，才会加载静态内部类。加载内部类的过程是线程安全的。

内部类中通过 static final 确保内存中只有一个外部类的实例，因为实例变量（optimizing1）只能被赋值一次。

**测试：**

**测试结果是相对的，硬件等环境的不同会有影响，大致上的性能比例差不多。**

public static void main(String[] args) throws Exception {
            // 线程数
            int num = 10;
            // 计数器
            CountDownLatch cd = new CountDownLatch(num);
            long t1 = System.currentTimeMillis();
            for (int i = 0; i < num; i++) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        for (int i = 0; i < 100000; i++) {
                            // 此处替换不同实现方式的单例代码进行测试
    //                        EagerSingleton eagerSingleton = EagerSingleton.getInstance();//耗时：17ms
    //                        LazySingleton lazySingleton =LazySingleton.getInstance();//耗时：19ms
    //                        Optimizing optimizing = Optimizing.getInstance();//耗时：17ms
                        }
                        cd.countDown();
                    }
                }).start();
            }
            // 主线程等待
            cd.await();
            System.out.println("耗时：" + (System.currentTimeMillis() - t1) + "ms");
        }

[format_png]: https://imgconvert.csdnimg.cn/aHR0cDovL2ltYWdlcy5leHRsaWdodC5jb20vZ29mLmpwZw?x-oss-process=image/format,png