【编程进阶知识】Java单例模式深度解析：饿汉式与懒汉式实现技巧

Java单例模式深度解析：饿汉式与懒汉式实现技巧

摘要： 在Java编程中，单例模式是一种常用的设计模式，用于确保一个类只有一个实例，并提供一个全局访问点。本文深入探讨了饿汉式和懒汉式单例模式的实现方法，包括它们的特点、实现代码和适用场景。通过阅读本文，你将能够理解单例模式的核心要点，并掌握如何在实际项目中正确应用这两种单例模式。

关键词： Java单例模式，饿汉式，懒汉式，设计模式，线程安全

1. 单例模式概述

单例模式是一种创建型设计模式，它确保某个类只有一个实例，并提供一个全局访问点。这种模式在Java中广泛应用，如Runtime类。

核心要点：

1. 唯一实例： 类的实例必须是唯一的。
2. 内部创建： 构造器必须私有化，防止外部创建实例。
3. 全局访问： 提供一个公共的静态方法获取实例。
4. 创建时机： 分为饿汉式和懒汉式。

2. 饿汉式单例模式

饿汉式单例模式在类加载时就创建实例，避免了线程同步问题。

2.1 实现方式

1. 静态常量实例化
2. 枚举类
3. 静态代码块

2.2 代码示例

//1、静态常量直接实例化（代表jvm运行环境的Runtime类生成单例，采用的就是这种实现方式，简洁直观）;
class HungrySigleton1 {
   
    private HungrySigleton1(){
   
    }
    private final static HungrySigleton1 INSTANCE = new HungrySigleton1();
    public static HungrySigleton1 getInstance(){
   
        return INSTANCE;
    }
}

//2、枚举类（最简洁）;
enum HungrySigleton3{
   
    INSTANCE;
    private HungrySigleton3() {
   
    }
}

//3、静态代码块（适合复杂的场景，如从配置文件读取所需参数）。
class HungrySigleton2 {
   
    private HungrySigleton2(String info){
   System.out.println(info);}
    private  static HungrySigleton2 INSTANCE =null;
    static {
   
        Properties prop = new Properties();
        InputStream inStream = HungrySigleton2.class.getClassLoader().getResourceAsStream("project.properties");
        try {
   prop.load(inStream);} catch (IOException e) {
   e.printStackTrace();}
        String info =(String) prop.get("info");
        //扩展：读取配置文件的几种方式 1、Properties继承自Hashtable 2、ResourceBundle 3、Spring种利用ApplicationContext加载xml文件
         INSTANCE = new HungrySigleton2(info);
    }
    public static HungrySigleton2 getInstance(){
   
        return INSTANCE;
    }
}
public class Hungry{
   
    public static void main(String[] args) {
   
        HungrySigleton1 ins1 = HungrySigleton1.getInstance();
        HungrySigleton2 ins2 = HungrySigleton2.getInstance();
        HungrySigleton3 ins3 = HungrySigleton3.INSTANCE;
    }
}

        

          
        
        
        

          

          AI 代码解读
        
      
      

3. 懒汉式单例模式

懒汉式单例模式在第一次使用时才创建实例，可能需要处理线程同步问题。

3.1 实现方式

1. 非线程安全版本
2. 同步方法实现
3. 同步代码块实现
4. 双重检查锁定（DCL）
5. 静态内部类

3.2 代码示例

class LazySigleton1 {
   
    private LazySigleton1(){
   
    }
    private  static LazySigleton1 INSTANCE =null;
    public static LazySigleton1 getInstance(){
   
        if(null == INSTANCE){
   
            INSTANCE = new LazySigleton1();
        }
        return INSTANCE;
    }
}

//2、懒汉式版本2（同步方法实现线程安全，但效率很低）;
class LazySigleton2 {
   
    private LazySigleton2(){
   
    }
    private  static LazySigleton2 INSTANCE =null;
    public synchronized static LazySigleton2 getInstance(){
   
        if(null == INSTANCE){
   
            try {
   Thread.sleep(100);} catch (InterruptedException e) {
   e.printStackTrace();}
            INSTANCE = new LazySigleton2();
        }
        return INSTANCE;
    }
}

//3、懒汉式版本2（同步代码块提供了一定效率，但存在线程安全问题）;
class LazySigleton3 {
   
    private LazySigleton3(){
   
    }
    private  static LazySigleton3 INSTANCE =null;
    public  static LazySigleton3 getInstance(){
   
        if(null == INSTANCE){
   
            try {
   Thread.sleep(100);} catch (InterruptedException e) {
   e.printStackTrace();}
            synchronized(INSTANCE){
   
                INSTANCE = new LazySigleton3();
            }
        }
        return INSTANCE;
    }
}

//4、懒汉式版本2（DCL（Double Check Lock），线程安全效率较高，但由于synchronized无法避免jvm优化时可能出现的乱序执行，可能会遇到拿到的实例对象尚未被正确初始化的问题，这时可以利用volatile来解决）;
class LazySigleton4 {
   
    private LazySigleton4(){
   
    }
    private  static volatile LazySigleton4 INSTANCE =null;
    public  static LazySigleton4 getInstance(){
   
        if(null == INSTANCE){
   
            try {
   Thread.sleep(100);} catch (InterruptedException e) {
   e.printStackTrace();}
            synchronized(INSTANCE){
   
                if(null == INSTANCE){
   
                    INSTANCE = new LazySigleton4();
                }
            }
        }
        return INSTANCE;
    }
}
//5、静态内部类（内部类被加载和初始化时才会创建对象，即调用时）
class LazySigleton5 {
   
    private LazySigleton5(){
   
    }
    private static class Inner{
   
         private final static LazySigleton5 INSTANCE = new LazySigleton5();
    }
    public static LazySigleton5 getInstance(){
   
        return Inner.INSTANCE;
    }
}

public class Lazy {
   
    public static void main(String[] args) throws InterruptedException, ExecutionException {
   
        ExecutorService exec = Executors.newFixedThreadPool(2);
        Callable task = new Callable(){
   
            @Override
            public Object call() {
   
                LazySigleton1 instance = LazySigleton1.getInstance();
                System.out.println(Thread.currentThread().getName()+instance);
                return instance;
            }
        };
        Future f1 = exec.submit(task);
        Future f2 = exec.submit(task);
        LazySigleton1 l1 = (LazySigleton1) f1.get(),l2 = (LazySigleton1) f2.get();
        System.out.println("l1:" + l1);
        System.out.println("l2:" + l2);
        System.out.println(l1==l2);
        exec.shutdown();
    }
}

        

          
        
        
        

          

          AI 代码解读
        
      
      

4. 优缺点对比

5. 流程图

graph TD
    A[开始] --> B[检查实例]
    B -->|不存在| C[创建实例]
    B -->|存在| D[返回实例]
    C --> D

        

          
        
        
        

          

          AI 代码解读
        
      
      

6. 结语

单例模式是Java中一种非常重要的设计模式，适用于需要严格控制实例数量的场景。通过本文的介绍，你应该对饿汉式和懒汉式单例模式有了更深入的理解。希望这些信息能帮助你在实际开发中做出更好的设计决策。

思维导图：

graph LR
    A[单例模式] --> B[饿汉式]
    A --> C[懒汉式]
    B --> D[静态常量]
    B --> E[枚举类]
    B --> F[静态代码块]
    C --> G[非线程安全]
    C --> H[同步方法]
    C --> I[同步代码块]
    C --> J[双重检查锁定]
    C --> K[静态内部类]

        

          
        
        
        

          

          AI 代码解读
        
      
      

Excel表格：

鼓励话语： 掌握单例模式，就像是掌握了控制Java世界的一把钥匙。如果你有更多的见解或者遇到了难题，不妨在评论区分享，让我们一起探讨，共同进步！