【Java高频面试题】-- 单例模式

秒速五厘米 2023-03-13 05:14 55阅读 0赞

## 1. 什么是Singleton？ ##

Singleton，即单例，在Java中表示的是单例模式，所谓的单例模式，指的就是在程序中，有且仅有一个该实例对象。

单：唯一，单独。  
例：实例对象。

## 2. 单例模式有几种创建方式？ ##

### 2.1 饿汉式（在程序启动过程中，就开始创建实例对象，饿汉式是线程安全的，它的缺点是不管程序是否需要该实例都会创建） ###

#### 2.1.1 直接创建实例对象(简介明了) ####

1.  将构造方法私有化。
2.  提供一个static修饰的常量对象。

package com.qingyun.demo.single.test;
    
    import com.qingyun.demo.single.Singleton1;
    
    /** * Created with IntelliJ IDEA. * User: 李敷斌. * Date: 2020-05-11 * Time: 08:58 * Explain: */
    public class TestSingleton1 { 
    
        public static void main(String[] args) { 
            Singleton1 singleton1=Singleton1.INSTANCE;
    
            System.out.println(singleton1);
        }
    
    }

*  测试代码

public static void main(String[] args) { 
            Singleton1 singleton1=Singleton1.INSTANCE;
    
            System.out.println(singleton1);
        }

**可以成功创建实例对象**

#### 2.1.2 通过枚举类的方式实现（最简洁的方式） ####

public class TestSingleton2 { 
    
        public static void main(String[] args) { 
            Singleton2 singleton2=Singleton2.INSTANCE;
    
            System.out.println(singleton2);
        }
    
    }

#### 2.1.2 通过静态代码块的方式实现 ####

package com.qingyun.demo.single;
    
    import java.io.IOException;
    import java.util.Properties;
    
    /** * Created with IntelliJ IDEA. * User: 李敷斌. * Date: 2020-05-11 * Time: 08:59 * Explain: 单例模式-饿汉式（静态代码块方式） */
    public class Singleton3 { 
    
        public static final Singleton3 INSTANCE;
    
        public String info;
    
    
        static{ 
            //创建一个读取properties的实例对象
            Properties properties=new Properties();
    
            try { 
                properties.load(Singleton3.class.getClassLoader().getResourceAsStream("info.properties"));
                INSTANCE=new Singleton3(new String(properties.getProperty("info").getBytes("iso-8859-1"),"utf-8"));
            } catch (IOException e) { 
                throw new RuntimeException(e);
            }
    
        }
    
        private Singleton3(String info){ 
            this.info=info;
        }
    
        public String getInfo() { 
            return info;
        }
    
        public void setInfo(String info) { 
            this.info = info;
        }
    
        @Override
        public String toString() { 
            return "Singleton3{" +
                    "info='" + info + '\'' +
                    '}';
        }
    }

### 2.2 懒汉式（通过延时加载的方式创建实例对象，只有程序调用了指定方法才会创创建对象） ###

#### 2.2.1 通过定义方法，当其他程序调用该方法时创建对象（使用与单线程，多线程条件下，可能会发生线程安全问题） ####

package com.qingyun.demo.single;
    
    /** * Created with IntelliJ IDEA. * User: 李敷斌. * Date: 2020-05-11 * Time: 09:38 * Explain: 单例模式-懒汉式（适用于单线程） * 延时创建实例，getInstance()方法的时候才创建 */
    public class Singleton4 { 
    
        private static Singleton4 instance;
    
        private Singleton4(){ 
    
        }
    
        public static Singleton4 getInstance() { 
    
            //当instance为空的时候才需要 创建实例 (这种方式可能存在线程安全问题)
            if (instance==null){ 
    
                try { 
                    Thread.sleep(100);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
    
                instance=new Singleton4();
            }
    
            return instance;
        }
    }

测试代码

package com.qingyun.demo.single.test;
    
    
    import com.qingyun.demo.single.Singleton4;
    
    import java.util.concurrent.*;
    
    public class Singleton4Test { 
    
        public static void main(String[] args) throws ExecutionException, InterruptedException { 
    
    // //单线程情况下 不存在安全问题
    // Singleton4 s1=Singleton4.getInstance();
    // Singleton4 s2=Singleton4.getInstance();
    //
    // System.out.println(s1==s2);
    // System.out.println(s1);
    // System.out.println(s2);
    
            Callable<Singleton4> callable=new Callable<Singleton4>() { 
                @Override
                public Singleton4 call() throws Exception { 
                    return Singleton4.getInstance();
                }
            };
    
            ExecutorService es= Executors.newFixedThreadPool(2);
    
            Future<Singleton4> future1 = es.submit(callable);
            Future<Singleton4> future2 = es.submit(callable);
    
            Singleton4 s1 = future1.get();
            Singleton4 s2 = future2.get();
    
            System.out.println(s1==s2);
            System.out.println(s1);
            System.out.println(s2);
    
            es.shutdown();
        }
    
    }

单线程执行测试代码，不会出现问题。  
多线程执行结果，如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTk5MDE2_size_16_color_FFFFFF_t_70]  
可以发现，两个对象的hashCode值是不一样的，故该方式存在线程安全问题。

#### 2.2.1 通过加锁的方式解决线程安全问题（适用于多线程环境） ####

package com.qingyun.demo.single;
    
    /** * Created with IntelliJ IDEA. * User: 李敷斌. * Date: 2020-05-11 * Time: 09:49 * Explain: 单例模式-懒汉式（使用与多线程，通过加锁的方式解决线程安全问题） */
    public class Singleton5 { 
    
        private static Singleton5 instance;
    
        private Singleton5(){ 
    
        }
    
        public static Singleton5 getInstance() { 
    
            //为了提高性能再加一层if判断
            if (instance==null){ 
                synchronized(Singleton5.class){ 
                    //当instance为空的时候才需要 创建实例 (这种方式可能存在线程安全问题)
                    if (instance==null){ 
    
                        try { 
                            Thread.sleep(1000);
                        } catch (InterruptedException e) { 
                            e.printStackTrace();
                        }
    
                        instance=new Singleton5();
                    }
                }
            }
    
            return instance;
        }
    }

测试代码：

public class Singleton5Test { 
    
        public static void main(String[] args) throws ExecutionException, InterruptedException { 
    
            Callable<Singleton5> callable=new Callable<Singleton5>() { 
                @Override
                public Singleton5 call() throws Exception { 
                    return Singleton5.getInstance();
                }
            };
    
            ExecutorService es= Executors.newFixedThreadPool(2);
    
            Future<Singleton5> future1 = es.submit(callable);
            Future<Singleton5> future2 = es.submit(callable);
    
            Singleton5 s1 = future1.get();
            Singleton5 s2 = future2.get();
    
            System.out.println(s1==s2);
            System.out.println(s1);
            System.out.println(s2);
    
            es.shutdown();
        }
    
    }

执行结果，如下图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTk5MDE2_size_16_color_FFFFFF_t_70 1]  
从执行结果中可以很清楚的看出，通过加锁的方式可以解决懒汉式的线程安全问题。

#### 2.2.3 通过内部类的方式实现饿汉式（线程安全的） ####

package com.qingyun.demo.single.test;
    
    
    import com.qingyun.demo.single.Singleton6;
    
    import java.util.concurrent.*;
    
    public class Singleton6Test { 
    
        public static void main(String[] args) throws ExecutionException, InterruptedException { 
    
            Callable<Singleton6> callable=new Callable<Singleton6>() { 
                @Override
                public Singleton6 call() throws Exception { 
                    return Singleton6.getInstance();
                }
            };
    
            ExecutorService es= Executors.newFixedThreadPool(2);
    
            Future<Singleton6> future1 = es.submit(callable);
            Future<Singleton6> future2 = es.submit(callable);
    
            Singleton6 s1 = future1.get();
            Singleton6 s2 = future2.get();
    
            System.out.println(s1==s2);
            System.out.println(s1);
            System.out.println(s2);
    
            es.shutdown();
        }
    
    }

测试代码,同3.2.2,测试结果也是线程安全的。

##### 那么为什么通过内部类创建实例对象就是线程安全的呢？ #####

因为内部类，不会随着外部类的实例而实例化，它只有在其他地方被调用的时候才会真正的实例化对象。

## 3.小结 ##

单例模式中，如果使用饿汉式，那么通过使用枚举的方式实现是最简单的。  
如果是使用懒汉式，那么推荐使用静态内部类的方式最好。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTk5MDE2_size_16_color_FFFFFF_t_70]: /images/20230312/531120f6af79492dafc3aec482cf360d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTk5MDE2_size_16_color_FFFFFF_t_70 1]: /images/20230312/b26bd66592f847169f0de44981217a32.png