单例模式 订阅
单例模式,属于创建类型的一种常用的软件设计模式。通过单例模式的方法创建的类在当前进程中只有一个实例(根据需要,也有可能一个线程中属于单例,如:仅线程上下文内使用同一个实例) 展开全文
单例模式,属于创建类型的一种常用的软件设计模式。通过单例模式的方法创建的类在当前进程中只有一个实例(根据需要,也有可能一个线程中属于单例,如:仅线程上下文内使用同一个实例)
信息
外文名
Singleton pattern
类    别
设计模式
中文名
单例模式
解    释
常用的软件设计模式
单例模式定义
数学与逻辑学中,singleton定义为“有且仅有一个元素的集合”。单例模式最初的定义出现于《设计模式》(艾迪生维斯理, 1994):“保证一个类仅有一个实例,并提供一个访问它的全局访问点。”Java中单例模式定义:“一个类有且仅有一个实例,并且自行实例化向整个系统提供。”Java单例模式例子
收起全文
精华内容
下载资源
问答
  • JAVA设计模式之单例模式

    万次阅读 多人点赞 2014-04-16 06:51:34
    本文继续介绍23种设计模式系列之单例模式。 概念:  java中单例模式是一种常见的设计模式,单例模式的写法有好几种,这里主要介绍三种:懒汉式单例、饿汉式单例、登记式单例。  单例模式有以下特点:  1、单例类...

    本文继续介绍23种设计模式系列之单例模式。

    概念:
      java中单例模式是一种常见的设计模式,单例模式的写法有好几种,这里主要介绍三种:懒汉式单例、饿汉式单例、登记式单例。
      单例模式有以下特点:
      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()方法访问。

    (事实上,通过Java反射机制是能够实例化构造方法为private的类的,那基本上会使所有的Java单例实现失效。此问题在此处不做讨论,姑且掩耳盗铃地认为反射机制不存在。)

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

     

    1、在getInstance方法上加同步

     

    public static synchronized 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(登记薄)中,对于已经登记过的实例,则从Map直接返回,对于没有登记的,则先登记,然后返回。 

    这里我对登记式单例标记了可忽略,我的理解来说,首先它用的比较少,另外其实内部实现还是用的饿汉式单例,因为其中的static方法块,它的单例在类被装载的时候就被实例化了。

     

    饿汉式和懒汉式区别

    从名字上来说,饿汉和懒汉,

    饿汉就是类一旦加载,就把单例初始化完成,保证getInstance的时候,单例是已经存在的了,

    而懒汉比较懒,只有当调用getInstance的时候,才回去初始化这个单例。

    另外从以下两点再区分以下这两种方式:

     

    1、线程安全:

    饿汉式天生就是线程安全的,可以直接用于多线程而不会出现问题,

    懒汉式本身是非线程安全的,为了实现线程安全有几种写法,分别是上面的1、2、3,这三种实现在资源加载和性能方面有些区别。


     

    2、资源加载和性能:

    饿汉式在类创建的同时就实例化一个静态对象出来,不管之后会不会使用这个单例,都会占据一定的内存,但是相应的,在第一次调用时速度也会更快,因为其资源已经初始化完成,

    而懒汉式顾名思义,会延迟加载,在第一次使用该单例的时候才会实例化对象出来,第一次调用时要做初始化,如果要做的工作比较多,性能上会有些延迟,之后就和饿汉式一样了。

    至于1、2、3这三种实现又有些区别,

    第1种,在方法调用上加了同步,虽然线程安全了,但是每次都要同步,会影响性能,毕竟99%的情况下是不需要同步的,

    第2种,在getInstance中做了两次null检查,确保了只有第一次调用单例的时候才会做同步,这样也是线程安全的,同时避免了每次都同步的性能损耗

    第3种,利用了classloader的机制来保证初始化instance时只有一个线程,所以也是线程安全的,同时没有性能损耗,所以一般我倾向于使用这一种。

     

    什么是线程安全?

    如果你的代码所在的进程中有多个线程在同时运行,而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的,而且其他的变量的值也和预期的是一样的,就是线程安全的。

    或者说:一个类或者程序所提供的接口对于线程来说是原子操作,或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题,那就是线程安全的。

     

    应用

    以下是一个单例类使用的例子,以懒汉式为例,这里为了保证线程安全,使用了双重检查锁定的方式:

     

    public class TestSingleton {
    	String name = null;
    
            private TestSingleton() {
    	}
    
    	private static volatile TestSingleton instance = null;
    
    	public static TestSingleton getInstance() {
               if (instance == null) {  
                 synchronized (TestSingleton.class) {  
                    if (instance == null) {  
                       instance = new TestSingleton(); 
                    }  
                 }  
               } 
               return instance;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public void printInfo() {
    		System.out.println("the name is " + name);
    	}
    
    }

    可以看到里面加了volatile关键字来声明单例对象,既然synchronized已经起到了多线程下原子性、有序性、可见性的作用,为什么还要加volatile呢,原因已经在下面评论中提到,

    还有疑问可参考http://www.iteye.com/topic/652440
    和http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html

     

     

     

    public class TMain {
    	public static void main(String[] args){
    		TestStream ts1 = TestSingleton.getInstance();
    		ts1.setName("jason");
    		TestStream ts2 = TestSingleton.getInstance();
    		ts2.setName("0539");
    		
    		ts1.printInfo();
    		ts2.printInfo();
    		
    		if(ts1 == ts2){
    			System.out.println("创建的是同一个实例");
    		}else{
    			System.out.println("创建的不是同一个实例");
    		}
    	}
    }
    

     运行结果:

    结论:由结果可以得知单例模式为一个面向对象的应用程序提供了对象惟一的访问点,不管它实现何种功能,整个应用程序都会同享一个实例对象。

    对于单例模式的几种实现方式,知道饿汉式和懒汉式的区别,线程安全,资源加载的时机,还有懒汉式为了实现线程安全的3种方式的细微差别。

    更多设计模式:23种设计模式系列

    作者:jason0539

    博客:http://blog.csdn.net/jason0539(转载请说明出处)

    展开全文
  • 单例模式

    万次阅读 2018-12-25 16:49:30
    单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一。 这种模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式,可以直接访问,不...

    单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一。

    这种模式涉及到一个单一的类该类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象

    注意:

    1、单例类只能有一个实例。

    2、单例类必须自己创建自己的唯一实例。

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

    主要解决:一个全局使用的类频繁地创建与销毁。

    何时使用:当您想控制实例数目,节省系统资源的时候。

    如何解决:判断系统是否已经有这个单例,如果有则返回,如果没有则创建。

    关键代码:构造函数是私有的。

    优点: 1、在内存里只有一个实例,减少了内存的开销,尤其是频繁的创建和销毁实例(比如管理学院首页页面缓存)。

    2、避免对资源的多重占用(比如写文件操作)。

    缺点:没有接口,不能继承,与单一职责原则冲突,一个类应该只关心内部逻辑,而不关心外面怎么样来实例化。

    单例模式的应用场景:

    1.在应用场景中,某类只要求生成一个对象的时候,如一个班中的班长、每个人的身份证号等。

    2.当对象需要被共享的场合。由于单例模式只允许创建一个对象,共享该对象可以节省内存,并加快对象访问速度。如 Web 中的配置对象、数据库的连接池等。

    3.当某类需要频繁实例化,而创建的对象又频繁被销毁的时候,如多线程的线程池、网络连接池等。

    实现

    1.懒汉式,线程不安全

    /**
     * 
     * @ClassName: Singleton
     * @Description: 懒汉式单例(在第一次调用的时候实例化自己)
     * 这种方式是最基本的实现方式,这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized,所以严格意义上它并不算单例模式。
     * @author: ljx
     * @date: 2018年12月25日 下午3:15:34
     */
    public class Singleton {
    	//构造函数私有化
    	private Singleton(){}
    	
    	private static Singleton singleton = null;
    	
    	//构建实例化方法
    	public static Singleton getSingleton(){
    		if(singleton == null){
    			singleton = new Singleton();
    		}
    		return singleton;
    	}
    }

    2.懒汉式,线程安全

    /**
     * 
     * @ClassName: Singleton
     * @Description: 懒汉式单例(在第一次调用的时候实例化自己)
     * 这种方式具备很好的 lazy loading,能够在多线程中很好的工作,但是,效率很低,99% 情况下不需要同步。
     * 优点:第一次调用才初始化,避免内存浪费。
     * 缺点:必须加锁 synchronized 才能保证单例,但加锁会影响效率。
     * @author: ljx
     * @date: 2018年12月25日 下午3:15:34
     */
    public class Singleton {
    	//构造函数私有化
    	private Singleton(){}
    	
    	private static Singleton singleton = null;
    	
    	//构建实例化方法
    	public static synchronized Singleton getSingleton(){
    		if(singleton == null){
    			singleton = new Singleton();
    		}
    		return singleton;
    	}
    }

    3.饿汉式

    /**
     * 
     * @ClassName: Singleton2
     * @Description: 饿汉式
     * 这种方式比较常用,但容易产生垃圾对象。
     * 优点:没有加锁,执行效率会提高。
     * 缺点:类加载时就初始化,浪费内存。
     * @author: ljx
     * @date: 2018年12月25日 下午3:30:39
     */
    class Singleton2 {
            //私有构造函数
    	private Singleton2(){};
    	private static Singleton2 singleton2= new Singleton2();
    	public static Singleton2 getSingleton2(){
    		return singleton2;
    	}
    }

    4.双检锁/双重校验锁

    /**
     * 
     * @ClassName: Singleton3
     * @Description: 双检锁/双重校验锁(DCL,即 double-checked locking)
     * 这种方式采用双锁机制,安全且在多线程情况下能保持高性能。
     * @author: ljx
     * @date: 2018年12月25日 下午3:44:16
     */
    class Singleton3{
    	//私有构造函数
    	private Singleton3(){}
    	
    	private static Singleton3 singleton3 = null;
    	
    	public static Singleton3 getSingleton3(){
    		//先检查实例是否存在,如果不存在才进入下面的同步块
    		if(singleton3 == null){
    			//同步块,线程安全的创建实例
    			synchronized (Singleton3.class) {
    				//再次检查实例是否存在,如果不存在才真正的创建实例
    				if(singleton3 == null){
    					singleton3 = new Singleton3();
    				}
    			}
    		}
    		return singleton3;
    	}
    	
    }

    5.静态(类级)内部类

    /**
     * 
     * @ClassName: Singleton4
     * @Description: 静态(类级)内部类:这种方式能达到双检锁方式一样的功效,但实现更简单。
     * 对静态域使用延迟初始化,应使用这种方式而不是双检锁方式。
     * 这种方式只适用于静态域的情况,双检锁方式可在实例域需要延迟初始化时使用。
     * @author: ljx
     * @date: 2018年12月25日 下午4:05:11
     */
    class Singleton4{
    	private Singleton4(){};
    	
    	/**
    	 * 
    	 * @ClassName: Singleton4Holder
    	 * @Description: 类级内部类,也就是静态的成员式内部类,该内部类的实例与外部类的实例
             * 没有绑定关系,而且只有被调用到时才会装载,从而实现了延迟加载。
    	 * @author: ljx
    	 * @date: 2018年12月25日 下午4:04:03
    	 */
    	private static class Singleton4Holder{
    		//静态初始化器,由JVM来保证线程安全
    		private static Singleton4 singleton4 = new Singleton4();
    	}
    	
    	public static Singleton4 getSingleton4(){
    		return Singleton4Holder.singleton4;
    	}
    }

    6.单例和枚举

    /**
     * 
     * @ClassName: Singleton5
     * @Description: 枚举单例模式
     * @author: ljx
     * @date: 2018年12月25日 下午4:16:09
     */
    enum Singleton5{
    	SINGLETON5;
    }

    是不是非常简单,非常简洁,而且无偿地提供了序列化机制,并由JVM从根本上提供保障,绝对防止多次实例化,是更简洁、高效、安全的实现单例的方式。

    enum有且仅有private的构造器,防止外部的额外构造,这恰好和单例模式吻合,也为保证单例性做了一个铺垫。

    想要了解enum是如何工作的,就要对其进行反编译。

    反编译后就会发现,使用枚举其实和使用静态类内部加载方法原理类似。枚举会被编译成如下形式:

    public final class Singleton5 extends Enum{
        //私有构造方法,这里调用了父类的构造方法,其中参数s对应了常量名,参数i代表枚举的一个顺序(这个顺                       序与枚举的声明顺序对应,用于oridinal()方法返回顺序值)
        private Singleton5()
        {
            super();
        }
        //定义的枚举在这里声明了SINGLETON5 Singleton5的常量对象引用
        public static final Singleton5 $VALUES;
    
        //将所有枚举的实例存放在数组中
        private static final Singleton5 $VALUES[];
        
        //对象的实例化在static静态块中
        static 
        {
            SINGLETON5 = new Singleton5("SINGLETON5", 0);
            //将所有枚举的实例存放在数组中
            $VALUES = (new Singleton5[] {
                SINGLETON5
            });
        }
    }

    其中,Enum是Java提供给编译器的一个用于继承的类。枚举量的实现其实是public static final T 类型的未初始化变量,之后,会在静态代码中对枚举量进行初始化。所以,如果用枚举去实现一个单例,这样的加载时间其实有点类似于饿汉模式,并没有起到lazy-loading的作用。

    对于序列化和反序列化,因为每一个枚举类型和枚举变量在JVM中都是唯一的,即Java在序列化和反序列化枚举时做了特殊的规定,枚举的writeObject、readObject、readObjectNoData、writeReplace和readResolve等方法是被编译器禁用的,因此也不存在实现序列化接口后调用readObject会破坏单例的问题。

    测试:

    /**
     * 
     * @ClassName: Singleton5
     * @Description: 枚举单例模式
     * @author: ljx
     * @date: 2018年12月25日 下午4:16:09
     */
    enum Singleton5{
    	SINGLETON5;//定义枚举类型
    	private String name;
    	public void setName(String name){
    		this.name = name;
    	}
    	public String getName(){
    		return name;
    	}
    }
    class Test{
    	public static void main(String[] args) {
    		Singleton5 singleton1 = Singleton5.SINGLETON5;//枚举类型实例化(静态块中)
    		singleton1.setName("单例1");
    		System.out.println(singleton1.getName());
    		
    		Singleton5 singleton2 = Singleton5.SINGLETON5;
    		singleton2.setName("单例2");
    		System.out.println(singleton2.getName());
    		
    		System.out.println(singleton1.getName() + ":" + singleton2.getName());
    		
    	}
    }

    结果:

    单例1

    单例2

    单例2:单例2

     

    评论区说了加volatile关键字防止指令重排,了解了一下:

    指令重排:简单来说,就是计算机为了提高执行效率,会做的一些优化,在不影响最终结果的情况下,可能会对一些语句的执行顺序进行调整。

    我们来看双检锁/双重校验锁的问题,主要在于singleton = new Singleton()这句,这并非是一个原子操作,事实上在 JVM 中这句话大概做了下面 3 件事情。
      1. 给 singleton 分配内存
      2. 调用 Singleton 的构造函数来初始化成员变量,形成实例
      3. 将singleton对象指向分配的内存空间(执行完这步 singleton才是非 null了)

    这在JVM的即时编译器中存在指令重排序的优化。

    也就是说上面的第二步和第三步的顺序是不能保证的,最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者,则在 3 执行完毕、2 未执行之前,被线程二抢占了,这时 instance 已经是非 null 了(但却没有初始化),所以线程二会直接返回 instance,然后使用,然后顺理成章地报错。

    再稍微解释一下,就是说,由于有一个(instance已经不为null但是仍没有完成初始化)的中间状态,而这个时候,如果有其他线程刚好运行到第一层if (instance ==null)这里,这里读取到的instance已经不为null了,所以就直接把这个中间状态的instance拿去用了,就会产生问题。这里的关键在于线程T1对instance的写操作没有完成,线程T2就执行了读操作。

    对于双检锁/双重校验锁出现的问题,解决方案为:给instance的声明加上volatile关键字

    private static volatile Singleton singleton = null;

               volatile可以保证线程可见性且提供了一定的有序性,但是无法保证原子性。在JVM底层volatile是采用“内存屏障”来实现的。观察加入volatile关键字和没有加入volatile关键字时所生成的汇编代码发现,加入volatile关键字时,会多出一个lock前缀指令,lock前缀指令实际上相当于一个内存屏障(也成内存栅栏),内存屏障会提供3个功能:

    I. 它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置,也不会把前面的指令排到内

    存屏障的后面;即在执行到内存屏障这句指令时,在它前面的操作已经全部完成;

    II. 它会强制将对缓存的修改操作立即写入主存;

    III. 如果是写操作,它会导致其他CPU中对应的缓存行无效。

    被volatile关键字修饰的变量,如果值发生了变更,其他线程立马可见,避免出现脏读的现象。把instance声明为volatile之后,对它的写操作就会有一个内存屏障,这样,在它的赋值完成之前,就不用会调用读操作。

    注意:volatile阻止的不是singleton = new Singleton()这句话内部[1-2-3]的指令重排,而是保证了在一个写操作([1-2-3])完成之前,不会调用读操作(if (instance == null))。

    ......,欢迎指正!

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 96,455
精华内容 38,582
关键字:

单例模式