单例模式的简单分析

Posted 2020-09-09

第一次写东西，文体形式槽点多多，欢迎指正。

本文旨在交流学习，欢迎大神拍砖。

 

单例模式是设计模式中比较简单的一个，学习起来比较容易理解。下面开始聊聊各种场景下的单例模式。

单例模式的定义：     一个类有且仅有一个实例，并且自行实例化向整个系统提供。
单例模式的要素： 1.私有的静态的实例对象 2.私有的构造函数（保证在该类外部，无法通过new的方式来创建对象实例） 3.公有的、静态的、访问该实例对象的方法 
单例模式分为懒汉形和饿汉式 懒汉式 

一、懒汉式单例模式：

优点是：类Singleton被加载时并未被分配空间，当调用getInstance()方法时才分配空间，节省内存。
缺点是：并发环境下很可能出现多个Singleton实例。

 1 /**
 2  * 懒汉模式  
 3  * 在第一次调用实例方法的时候才会实例化对象
 4  * */
 5 public class Singleton {
 6 
 7     private static Singleton instance = null;
 8     private Singleton(){}
 9     public static Singleton getInstance(){
10         if(instance==null){
11             instance = new Singleton();
12         }
13         return instance;
14     }
15     
16     
17 }

二、饿汉式单例模式：

优点：简单，不存在线程同步问题，避免synchronized造成的资源浪费问题。

缺点：静态类被加载并分配空间，此后instance一直占用资源。

 1 /**
 2  * 饿汉模式 单例类在被编译加载时候，就实例化一个对象交给自己的引用
 3  * */
 4 public class Singleton1 {

 5     private Singleton1() {
 6     }
 7 
 8     private static Singleton1 instance = new Singleton1();
 9 
10     public static Singleton1 getInstance() {
11         return instance;
12     }
13 
14 }

三、懒汉式线程安全单例模式：

 1 public class Singleton {
 2 
 3     private static Singleton instance = null;
 4     private Singleton(){}
 5     public static synchronized Singleton getInstance(){
 6         if(instance==null){
 7             instance = new Singleton();
 8         }
 9         return instance;
10     }
11     
12     
13 }

 

三、多线程下的懒汉模式：

优点是：使用synchronized关键字避免多线程访问时，出现多个SingletonTest实例。
缺点是：同步方法频繁调用时，效率略低。

 1 /**
 2  * 多线程下的懒汉模式
 3  * 给懒汉式单例模式加锁，避免并发带来的错误，保证线程安全。
 4  * */
 5 public class Singleton2 {
 6     private Singleton2(){}
 7     private static volatile Singleton2 instance = null;
 8     public static synchronized Singleton2 getInstance(){
 9         if(instance==null){
10             synchronized(Singleton2.class){
11                 if(instance==null){
12                     instance = new Singleton2();
13                 }
14             }
15         }
16         return instance;
17     }
18 }

使用场景：

• 需要频繁实例化然后销毁的对象
• 创建对象时耗时或者耗费资源过多，但又经常使用的对象
• 频繁访问数据库或者文件的对象
• 要求只能存在一个对象

单例模式的优点：

1. 在内存中只有一个对象，节省内存空间
2. 避免频繁地创建销毁对象，可以提高性能
3. 避免对共享资源的多重占用
4. 可以全局访问