创建型模式(Creational Pattern)

单例模式(SingleTon)

第一种UML图

第二种UML图

单例模式的写法有多种写法,主要介绍三种:懒汉式单例,饿汉式单例,登记式单例

单例有以下特点:

1.单例类只有一个实例

2.单例类必须自己创建自己的唯一对象

3.单例类必须给所有其他对象提供这一实例

单例模式确保某个类只有一个实例对象,而且自行实例化并向整个系统提供这个实例.在计算机系统中,线程池,缓存,日志对象,对话框,打印机,显卡就驱动对象都是常见的单例,这些应用都或多或少的具有资源管理器的功能.每台计算机可以若干个打印机,但是只有一个Printer Spooler,以避免两个打印作业同时输出到打印机中,每台计算机可以有若干通信端口,系统应当集中管理这些通信端口,以避免一个通信端口同时被两个请求同时调用.总之,选择单例模式就是为了避免不一致的状态.

一.懒汉模式单例

//懒汉式单例类.在第一次调用的时候实例化自己

public class Singleton { 

    private Singleton() {} 

    private static Singleton single=null; 

    //静态工厂方法 

    public static Singleton getInstance() { 

        if (single == null) {   

            single = new Singleton(); 

        }   

        return single; 

    } 

}

SingleTon通过将构建方法限定为private避免了类在外部的实例化,在用一个虚拟机的范围内,Singleton的唯一实例只能通过getInstance()方法访问

但是以上懒汉式的实现没有考虑县城安全问题,他是县城不安全的,并发环境下很有可能出现多个SingleTon实例,要实现线程安全,有一下三种方式,都是对getInstance方法的构造,保证了懒汉式单例的线程安全,如果你第一次接触单例模式,对线程安全不是很了解,可以先跳过下面的这三小条,去看饿汉式单例,等看完后面的再回头考虑线程安全问题:

1.getInstance方法上加同步

publicstaticsynchronized Singleton getInstance() {

            if(single ==null) {   

                single =new Singleton(); 

            }   

            return single; 

    }

2.双重检查锁定

public static Singleton getInstance() {

        if (singleton == null) {   

            synchronized (Singleton.class) {   

              if (singleton == null) {   

                  singleton = new Singleton(); 

              }   

            }   

        }   

        return singleton; 

    }

3.静态内部类

public class Singleton {

    private static class LazyHolder {   

      private static final Singleton INSTANCE = new Singleton();   

    }   

    private Singleton (){}   

    public static final Singleton getInstance() {   

      return LazyHolder.INSTANCE;   

    }   

}

第三种比上面1.2都好一些,即实现了线程安全,又避免了同步带来的性能影响

二.饿汉式单例

//饿汉式单例类.在类初始化时，已经自行实例化

public class Singleton1 { 

    private Singleton1() {} 

    private static final Singleton1 single = new Singleton1(); 

    //静态工厂方法 

    public static Singleton1 getInstance() { 

        return single; 

    } 

}

饿汉式再累创建的同事就已经创建好一个静态的对象供系统使用,以后不再改变,所以天生的是线程安全的.

三.登记式单例

//类似Spring里面的方法，将类名注册，下次从里面直接获取。

public class Singleton3 { 

    private static Map<String,Singleton3> map = new HashMap<String,Singleton3>(); 

    static{ 

        Singleton3 single = new Singleton3(); 

        map.put(single.getClass().getName(), single); 

    } 

    //保护的默认构造子 

    protected Singleton3(){} 

    //静态工厂方法,返还此类惟一的实例 

    public static Singleton3 getInstance(String name) { 

        if(name == null) { 

            name = Singleton3.class.getName(); 

            System.out.println("name == null"+"--->name="+name); 

        } 

        if(map.get(name) == null) { 

            try { 

                map.put(name, (Singleton3) Class.forName(name).newInstance()); 

            } catch (InstantiationException e) { 

                e.printStackTrace(); 

            } catch (IllegalAccessException e) { 

                e.printStackTrace(); 

            } catch (ClassNotFoundException e) { 

                e.printStackTrace(); 

            } 

        } 

        return map.get(name); 

    } 

    //一个示意性的商业方法 

    public String about() {     

        return "Hello, I am RegSingleton.";     

    }     

    public static void main(String[] args) { 

        Singleton3 single3 = Singleton3.getInstance(null); 

        System.out.println(single3.about()); 

    } 

}

登记式单例实际上维护了一组单例类的实例,将这些实例存在一个Map(登记簿)中,对于已经登记过的实例,