深入解析单例模式：定义、特点、优缺点及应用场景详解

1。单例模式的定义和特征

Singleton模式是一种创建设计模式，它是针对全球只需要一个对象的场景设计的，例如线程池，全局缓存，窗口对象等。它被定义为：

确保类只有一个实例，并提供一个全局访问点访问它。

Singleton模式的三个特征：

Singleton模式被特别广泛使用，因为其设计模式是在整个项目环境中只能有一个静态对象实例，这将增强资源的可重复性并避免项目中使用的频繁对象。系统的创建和破坏降低了系统的性能！

2。辛格尔顿模式的优点和缺点2.1 Singleton模式的优势2.2 Singleton模式的缺点3。singleton模式的应用程序场景

对于Java，Singleton模式可以确保JVM中只有一个实例。 Singleton模式的应用程序方案主要包括以下方面。

4。单例模式的结构和实施

Singleton模式是设计模式中最简单的模式之一。通常，正常类的构造函数是公开的，外部类可以通过“ new构造函数（）”生成多个实例。但是，如果类构造函数设置为私有，则外部类无法调用构造函数，并且无法生成多个实例。目前，课程本身必须定义静态私人实例，并提供静态公共功能来创建或获得静态私人实例。

以下是分析其基本结构和实现方法。

4.1单例模式的结构

4.2 Singleton模式的实现4.2.1懒惰的单身

这种模式的特征是，加载类时，没有生成单例，并且只有在第一次调用getlnstance方法时才会创建此单例。代码如下：

public class LazySingleton {
    private static volatile LazySingleton instance = null;    //保证 instance 在所有线程中同步
    private LazySingleton() {
    }    //private 避免类在外部被实例化
    public static synchronized LazySingleton getInstance() {
        //getInstance 方法前加同步
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

注意：如果您正在编写多线程程序，请不要在上面的示例代码中删除关键字挥发性并同步，否则将存在非线程问题。如果未删除这两个关键字，则可以确保线程安全性，但是每次访问时必须同步它会影响性能并消耗更多资源。这是懒惰单人的缺点。

4.2.1饥饿的人

这种模式的特征是，一旦加载了类，创建了一个单例，以确保在调用getInstance方法之前已经存在单例。

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

饥饿风格的单身人士创建了一个静态对象，供系统创建同类时使用，并且将来不会更改。因此，它是线程安全的，可以直接用于多线程而没有问题。

5。单例模式的申请示例

[示例1]使用Lazy Singleton模型模拟美国当前总统对象的产生。

分析：在每个学期中，只有一位美国总统，因此此示例适合使用Singleton模型实施。下图显示了使用Lazy Singleton实现的结构图。

public class SingletonLazy {
    public static void main(String[] args) {
        President zt1 = President.getInstance();
        zt1.getName();    //输出总统的名字
        President zt2 = President.getInstance();
        zt2.getName();    //输出总统的名字
        if (zt1 == zt2) {
            System.out.println("他们是同一人！");
        } else {
            System.out.println("他们不是同一人！");
        }
    }
}
class President {
    private static volatile President instance = null;    //保证instance在所有线程中同步
    //private避免类在外部被实例化
    private President() {
        System.out.println("产生一个总统！");
    }
    public static synchronized President getInstance() {
        //在getInstance方法上加同步
        if (instance == null) {
            instance = new President();
        } else {
            System.out.println("已经有一个总统，不能产生新总统！");
        }
        return instance;
    }
    public void getName() {
        System.out.println("我是美国总统：特朗普。");
    }
}

程序运行结果如下：

产生一个总统！
我是美国总统：特朗普。
已经有一个总统，不能产生新总统！
我是美国总统：特朗普。
他们是同一人！

示例2]使用饥饿中文的单例模型生成Zhu Bajie对象。

分析：类似于上面的示例，朱伊（Zhu Bajie）也只有一个，因此此示例也适合使用Singleton模型实现。由于此示例想显示Zhu Bajie的图像（单击此处以下载要在此程序中显示的Zhu Bajie的图像），因此使用框架表单Jframe组件。这里的Zhu Bajie班是Singleton类，可以定义为小组jpanel的子类。它包含一个标签来保存Zhu Bajie的图像。客户表格可以获取Zhu Bajie对象并显示它。图3显示了使用饥饿的单人实现的结构图。

import java.awt.*;
import javax.swing.*;
public class SingletonEager {
    public static void main(String[] args) {
        JFrame jf = new JFrame("饿汉单例模式测试");
        jf.setLayout(new GridLayout(1, 2));
        Container contentPane = jf.getContentPane();
        Bajie obj1 = Bajie.getInstance();
        contentPane.add(obj1);
        Bajie obj2 = Bajie.getInstance();
        contentPane.add(obj2);
        if (obj1 == obj2) {
            System.out.println("他们是同一人！");
        } else {
            System.out.println("他们不是同一人！");
        }
        jf.pack();
        jf.setVisible(true);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}
class Bajie extends JPanel {
    private static Bajie instance = new Bajie();
    private Bajie() {
        JLabel l1 = new JLabel(new ImageIcon("src/Bajie.jpg"));
        this.add(l1);
    }
    public static Bajie getInstance() {
        return instance;
    }
}