【设计模式】单例模式

系列文章目录

---

---

类也需要计划生育

我们写一个窗体程序时，当中有一个是‘工具箱’窗体，问题就是，我们希望工具箱要么不出现，出现也只出现一个，而实际上却是我每次单击菜单，实例化‘工具箱’，就会出现一个，多次点击就会出现多个？这里我们应该怎么办呢？

我们的第一版代码是这样的，首先我们建立一个Java的swing窗体应用程序，默认窗体为JFame，左上角有一个打开工具箱按钮，我们希望单击此按钮后，可以另建一个窗体，也就是‘工具箱’窗体，里面可以有一些相关工具按钮。

public class Test{
        public static void main(String[] args) {
            new SingletonWindow();
        }
    }
    class SingletonWindow{
        public SingletonWindow(){
            JFrame frame = new JFrame("单例模式");
            frame.setSize(1024,768);
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            JPanel panel = new JPanel();
            frame.add(panel);
            panel.setLayout(null);
            JButton button = new JButton("打开工具箱");  //容器中有一个JButton按钮，叫打开工具箱
            button.setBounds(10,10,120,25);
            button.addActionListener(new ActionListener() {   //按钮单击会触发打开一个叫工具箱的JFrame窗体
                @Override
                public void actionPerformed(ActionEvent e) {
                    JFrame toolkit = new JFrame("工具箱");
                    toolkit.setSize(150,300);
                    toolkit.setLocation(100,100);
                    toolkit.setResizable(false);
                    toolkit.setAlwaysOnTop(true);
                    toolkit.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
                    toolkit.setVisible(true);
                }
            });
            panel.add(button);
            frame.setVisible(true);
        }
    }

上述代码，我们每单击一次‘打开工具箱’按钮，就会产生一个新的‘工具箱’窗体，但实际上，我们只希望它出现第一次，不会出现第二次。除非单击关闭之后，才会再次出现。

判断对象是否为null

这里我们需要做的是判断JFrame有没有实例化就好了。在上述代码中，我们是在单击了按钮时，才去JFrame tookit = new JFrame(“工具箱”)；当然是新实例化了。但其实问题也就出现在这里，为什么要单击按钮时才声明JFrame对象呢？，我们完全可以把声明的工作放到类的全局变量中完成。这样就可以去判断这个变量是否被实例化过了。

public class Test{
        public static void main(String[] args) {
            new SingletonWindow();
        }
    }
    class SingletonWindow{
        public SingletonWindow(){
            JFrame frame = new JFrame("单例模式");
            frame.setSize(1024,768);
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            JPanel panel = new JPanel();
            frame.add(panel);
            panel.setLayout(null);
            JButton button = new JButton("打开工具箱");  //容器中有一个JButton按钮，叫打开工具箱
            button.setBounds(10,10,120,25);
            button.addActionListener(new ActionListener() {//按钮单击会触发打开一个叫工具箱的JFrame窗体
                JFrame toolkit;
                @Override
                public void actionPerformed(ActionEvent e) {
                    if(toolkit == null || !toolkit.isVisible()){    //判断是否实例化，如果没有或隐藏，那么就重新实例化
                        JFrame toolkit = new JFrame("工具箱");
                        toolkit.setSize(150,300);
                        toolkit.setLocation(100,100);
                        toolkit.setResizable(false);
                        toolkit.setAlwaysOnTop(true);
                        toolkit.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
                        toolkit.setVisible(true);
                    }
                  
                }
            });
            panel.add(button);
            frame.setVisible(true);
        }
    }

基本需求上述代码可以实现，现在我们需求，不但要在菜单里启动‘工具箱’，还需要‘工具栏’上有一个按钮来启动‘工具箱’，如何做？也就是要有两个按钮都要能打开这个工具箱。我们可以提炼一个方法来让它们调用。

//工具箱事件类
  class ToolkitListener implements ActionListener {
        JFrame toolkit;

        @Override
        public void actionPerformed(ActionEvent e) {
            if (toolkit == null || !toolkit.isVisible()) {    //判断是否实例化，如果没有或隐藏，那么就重新实例化
                JFrame toolkit = new JFrame("工具箱");
                toolkit.setSize(150, 300);
                toolkit.setLocation(100, 100);
                toolkit.setResizable(false);
                toolkit.setAlwaysOnTop(true);
                toolkit.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
                toolkit.setVisible(true);
            }
        }
    }
  //窗体类
  class SingletonWindow {
        public SingletonWindow() {
            JFrame frame = new JFrame("单例模式");
            frame.setSize(1024, 768);
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            JPanel panel = new JPanel();
            frame.add(panel);
            panel.setLayout(null);
            JButton button = new JButton("打开工具箱");  //容器中有一个JButton按钮，叫打开工具箱
            button.setBounds(10, 10, 120, 25);
            button.addActionListener(new ToolkitListener());
            panel.add(button); 
            
            JButton button2 = new JButton("打开工具箱2");  //容器中有一个JButton按钮，叫打开工具箱
            button.setBounds(130, 10, 120, 25);
            button.addActionListener(new ToolkitListener());
            panel.add(button2);
            frame.setVisible(true);
        }
    }

这样可以分别单击打开工具箱和打开工具箱2，此时两个按钮分别打开了一个工具箱窗体，这依然不符合我们只打开一个‘工具箱’的需求。

目前的代码中我们将工具箱‘JFrame’是否实例化都由外部的代码决定，这好像很不合逻辑。

 class ToolkitListener implements ActionListener {
        JFrame toolkit;   
        @Override
        public void actionPerformed(ActionEvent e) {
            if (toolkit == null || !toolkit.isVisible()) {    //判断是否实例化，如果没有或隐藏，那么就重新实例化
                JFrame toolkit = new JFrame("工具箱");
                toolkit.setSize(150, 300);
                toolkit.setLocation(100, 100);
                toolkit.setResizable(false);
                toolkit.setAlwaysOnTop(true);
                toolkit.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
                toolkit.setVisible(true);
            }
        }
    }

在主窗体里，应该只是通知启动‘工具箱’，至于工具箱窗体是否实例化过，应该有工具箱自己的类来判断。实例化的过程就是new的过程，问题是如何让外部代码不使用new呢？这里我们只能对构造方法做改动，不可能阻止他人不使用new的，所以我们可以直接就把这个类的构造方法改成私有，所有类的构造方法，不编码则系统默认生成空的构造方法，若有显示的定义的构造方法，默认的构造方法就会失效。 所以我们需要将‘工具箱’类的构造方法写成是private的，那么外部程序就不能用new 来实例化他了。

私有的方法外界不能访问，但是这样来看，这个类一个实例化都不能了，这与我们的让这个类实例化一次又矛盾了。这里这样理解是有问题的，经过对构造方法的private修饰，我们只能说对于外部代码，不能用new来实例化它，但是我们完全可以再写一个public 方法叫做getInstance(),这个方法的目的就是返回一个类实例，而此方法中，去做是否有实例化的判断。如果没有实例化，由调用private的构造方法new出这个实例，之后它就可以调用，因为在同一个类中，所以private方法是可以被调用的。

//工具箱类
  class Toolkit extends JFrame {
        private static Toolkit toolkit;
        
        private Toolkit(String title){
            super(title);
        }
        
        public static Toolkit getInstance(){
            //判断是否实例化，如果没有或隐藏，可以实例化
            if (toolkit == null || !toolkit.isVisible()) {    
                JFrame toolkit = new JFrame("工具箱");
                toolkit.setSize(150, 300);
                toolkit.setLocation(100, 100);
                toolkit.setResizable(false);
                toolkit.setAlwaysOnTop(true);
                toolkit.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
                toolkit.setVisible(true);
            }
            return toolkit;   //如果已经存在，就直接返回存在的实例，并不在new新的实例
        }
    }

有了上面的代码，我们在写工具箱事件类时，就可以改造如下

//工具箱事件类
class ToolkitListener implements ActionListener{
        @Override
        public void actionPerformed(ActionEvent e) {
            //Toolkit toolkit = new Toolkit("工具箱");  传统的new来获得实例会报错
            Toolkit.getInstance();  //实例化唯一的一个对象 -- 单例对象
        }
    }

上面的代码可以达到一个效果，只有在实例不存在时，才会去new新的实例，而但存在时，可以直接返回存在的同一个实例。这就是设计模式 – 单例模式

单例模式

> 单例模式： 保证一个类仅有一个实例，并提供一个访问它的全局访问点。

通常我们可以让一个全局变量使得一个对象被访问，但它不能防止你实例化多个对象。一个最好的方法就是，让类自身负责保存它的唯一实例。这个类可以保证没有其他实例可以被创建，并且他可以提供一个访问该实例的方法 。

Singleton类，定义一个GetInstance操作，允许客户访问它的唯一实例。GetIntance是一个静态方法，主要负责创建自己的唯一实例

 //单例模式类
    class Singleton{
        private static Singleton instance;
        private Singleton{
            
        }
        public static Singleton getInstance(){
            if(instance == null){
                instance = new Singleton();
            }
            return instance;
        }
    }

客户端代码：

 public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        
        if(s1 == s2){
            System.out.println("两个对象是相同的实例");
        }
    }

单例模式不光可以保证只存在唯一的实例，另外单例模式因为Singleton类封装它的唯一实例，这样它可以严格的控制顾客怎样访问他以及何时访问它。简单的说就是对唯一实例的受控访问。

多线程时的单例

在多线程的程序中，多个线程同时访问Singleton类，调用getInstance(),调用getInstance()方法，会有可能造成创建多个实例。
我们可以给进程一把锁来处理，这里需要解释一下synchronized语句的含义。synchronized是Java中的关键字，是一种同步锁。意思就是当一个线程还没有退出之前，先锁住这段代码不被其他其他线程代码调用执行，以保证同一时间只有一个线程在执行此段代码。

 class Singleton{
        private static Singleton instance;
        private Singleton(){

        }
        //通过增加synchronized关键字到getInstance方法中，可以让每个线程在进入此方法之前，都要等到别的线程离开此方法
        public static synchronized Singleton getInstance(){
            if(instance == null){
                instance = new Singleton();
            }
            return instance;
        }
    }

这段代码使得对象实例由最先进入的那个线程来创建，以后的线程在进入时不会再去创建对象实例了，由于有了synchronized，就保证了多线程环境下的同时访问也不会造成多个实例的生成。这里为什么不直接锁实例，而是使用synchronized锁是因为加锁的时候，我们不清楚instance是否已经被创建，也就无法加锁。但是这样的话，每次调用getInstance()都需要锁，性能降低，所以这个代码还是有可以优化的地方的。

双重锁定

class Singleton{
        //volatile关键词是当synchronized变量初始化成Single时，多个线程能够正确地处理synchronized变量
        private volatile static Singleton instance;
        private Singleton(){

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

这版的代码，我们不用让线程每次都加锁，而只是在实例未被创建的时候再加锁处理。同时也能保证多线程的安全，这种方法叫做Double-Check Locking(双重否定)。

那么这里为什么在外面已经判断了instance的实例是否存在，为什么在synchronized里面还需要做一次instance实例是否存在的判断呢？对于instance存在的情况就直接返回，这没问题，当instance为null并且同时有两个线程调用getInstance()方法时，他们将都可以通过第一重instance == null的判断，然后由于锁机制，这两个线程则只有一个进入，另一个在排队等待，必须要其中的一个进入并出来后，另一个才能进去，而此时没有了instance == null的判断，就会创建多个实例，没有达到单例的目的

静态初始化

上述代码基本对实际应用中的大部分情况都能应付自如，不过为了确保实例唯一，还是会带来很大的性能代价，对于那些性能要求特别高的程序来说，传统单例代码实现还不是最好的办法。

   class Singleton{
      private static Singleton instance = new Singleton();
      //构造方法private化
        private Singleton(){}
        //得到Singleton的实例
        public static Singleton getInstance(){
            return instance;
        }
    }

这样的实现与前面的示例相似，解决了单例模式的全局访问和实例化控制，公共静态属性为访问实例提供了一个全局访问点。不同之处在于它依赖公共语言运行库来初始化变量。由于构造方法是私有的，因此不能在类本身以外实例化Singleton类；因此，变量引用的是可以在系统中存在的唯一实例。由于这种静态初始化的方式是在自己被加载时就将自己实例化，所以被形象的称之为饿汉式单例类，原先的单例模式的处理方式是要在第一次被引用时，才会将自己实例化，所以就被称为懒汉式单例类。

总结

以上就是本文全部内容，本文主要向大家介绍了设计模式中的单例模式，通过对窗口的单例创建为例，引出单例模式的模板代码，之后介绍了多线程下的单例模式。介绍了双重否定和静态初始化两种实现单例模式的方法。 感谢各位能够看到最后，如有问题，欢迎各位大佬在评论区指正，希望大家可以有所收获！创作不易，希望大家多多支持！