单例设计模式（3种实现方式）

  1 package com.demo.designpattern;
  2 
  3 import java.util.HashMap;
  4 import java.util.Map;
  5 
  6 /**
  7  * 单例设计模式
  8  * @author yinbenyang
  9  * 单例模式分三种：懒汉式单例、饿汉式单例、登记式单例
 10  */
 11 public class SingletonPattern {
 12 
 13     /**
 14      * 懒汉式单例
 15      * 懒汉式单例在类被加载的时候，唯一实例已经被创建
 16      */
 17     //私有静态对象,加载时候不做初始化
 18     private static SingletonPattern m_instance = null;
 19     //私有构造方法,避免外部创建实例
 20     private SingletonPattern(){}    
 21     //静态工厂方法,返回此类的唯一实例.* 当发现实例没有初始化的时候,才初始化
 22     public static SingletonPattern getInstance(){
 23         if(m_instance == null){
 24             m_instance = new SingletonPattern();
 25         }
 26         return m_instance;
 27     }
 28     
 29     public static void main(String[] args) {
 30         SingletonPattern sp1 = SingletonPattern.getInstance();
 31         SingletonPattern sp2 = SingletonPattern.getInstance();
 32         if(sp1 == sp2){
 33             System.out.println("同一个实例");
 34         }else{
 35             System.out.println("不同的实例");
 36         }
 37     }
 38 }
 39 
 40 
 41 /**
 42  * 饿汉式单例
 43  * 饿汉式单例在类加载的时候不创建单例实例。只有在第一次请求实例的时候的时候创建，并且只在第一次创建后，以后不再创建该类的实例
 44  */
 45 class EagerSingleton{
 46     //私有的(private)唯一(static final)实例成员,在类加载的时候就创建好了单例对象
 47     private static final EagerSingleton m_instance = new EagerSingleton();
 48     //私有构造方法,避免外部创建实例
 49     private EagerSingleton(){}
 50     //静态工厂方法,返回此类的唯一实例
 51     public static EagerSingleton getInstance(){
 52         return m_instance;
 53     }
 54     
 55     public static void main(String[] args) {
 56         EagerSingleton sp1 = EagerSingleton.getInstance();
 57         EagerSingleton sp2 = EagerSingleton.getInstance();
 58         if(sp1 == sp2){
 59             System.out.println("同一个实例2");
 60         }else{
 61             System.out.println("不同的实例2");
 62         }
 63     }
 64 }
 65 
 66 /*
 67  * 登记式单例
 68  * 登记式单例这个单例实际上维护的是一组单例类的实例，将这些实例存放在一个Map（登记薄）中，
 69  * 对于已经登记过的实例，则从工厂直接返回，对于没有登记的，则先登记，而后返回
 70  */
 71 class RegSingleton{
 72     //登记薄,用来存放所有登记的实例 
 73     private static Map<String, RegSingleton> map_reg = new HashMap<String, RegSingleton>();
 74     //在类加载的时候添加一个实例到登记薄
 75     static{
 76         RegSingleton rp = new RegSingleton();
 77         map_reg.put(rp.getClass().getName(), rp);
 78     }
 79     //受保护的默认构造方法
 80     protected RegSingleton(){}
 81     //静态工厂方法,返回指定登记对象的唯一实例
 82     //对于已登记的直接取出返回,对于还未登记的,先登记,然后取出返回
 83     public static RegSingleton getInstance(String name){
 84         if(name == null){
 85             name = "RegSingleton";
 86         }
 87         if(map_reg.get(name) == null){
 88             try {
 89                 map_reg.put(name, (RegSingleton)Class.forName(name).newInstance());
 90             } catch (Exception e) {
 91                 e.printStackTrace();
 92             }
 93         }
 94         return map_reg.get(name);
 95     }
 96     
 97     private String about(){
 98         return new String("aaaaaaaaaaaaa");
 99     }
100     
101     public static void main(String[] args) {
102         RegSingleton sp1 = RegSingleton.getInstance(null);
103         RegSingleton sp2 = RegSingleton.getInstance(null);
104         if(sp1 == sp2){
105             System.out.println("同一个实例3");
106         }else{
107             System.out.println("不同的实例3");
108         }
109     }
110 }
单例设计模式（3种实现方式）

猜你喜欢
