设计模式:单例模式,懒汉与饿汉
2017-10-12 18:23
197 查看
在某些情况下,有些对象只需要一个就可以了,换句话说,每个类只需要一个实例。比如,一台计算机连接多台打印机,但这个计算机上打印程序只能有一个,这里就需要单例模式来避免打印机左右同时输入到打印机中。、
单例模式的作用就是保证整个应用程序的生命周期中,任何一个时刻,单例类的实例都只存在一个。单例模式主要有三个特点:
1. 单例类只能有一个实例
2. 单例类必须创建自己唯一的实例。
3. 单例类必须为其他对象提供这一实例。
那么如何实现满足上述条件的单例类呢?答案是:
1. 私有构造方法。
2. 内部创建静态对象。
3. 提供静态方法返回该静态对象。
单例设计模式主要有两种实现方法:饿汉式和懒汉式。
1. 饿汉式单例:在定义开始,便实例化自己。
2. 懒汉式单例:在第一次调用时实例化自己。
那饿汉式和懒汉式分别有什么区别呢?
1. 线程安全:
饿汉式天生线程安全,可以直接用于多线程而不会出现问题。
懒汉式本身非线程安全,需要人为实现线程安全。
2. 资源加载和性能:
饿汉式在类创建的同时就实例化一个静态对象出来,不管之后会不会使用这个单例,都会占据一定的内存,造成内存泄漏,但相应的,在第一次调用时速度也会更快。
而懒汉式顾名思义,会延迟加载,在第一次使用该单例的时候才会实例化对象出来,第一次调用时要做初始化,如果要做的工作比较多,性能上会有些延迟,之后就和饿汉式一样了。
为了保证懒汉式的线程安全,通常有三种方法:
1. 全局访问点加同步。
由于synchronized是锁方法, 当两个线程都要进入getsingle()时, 只有一个能进入, 并创建出实例, 然后另外一个进入后, 判断 s不为null, 然后直接得到s。 这种做法是没有错误的. 但是由于线程都需要通过getsingle()来获取对象, 所以getsingle()调用频率很高, 所以线程被锁的频率也很高, 所以这种做法效率低。简言之,不管对象有没有被创建,其余线程都只能等待这个方法的锁。
2. 双重检查锁定。
由于上述都是在等待同步方法的锁,很容易想到把synchronized放在方法里面,这样可以避免方法的阻塞。
这种写法看似没有问题, 其实却有一个很大的隐患, 在于:如果两个线程同时执行getsingle(),判断 instance都不为null后, 进入if判断语句。这个时候一个线程获得锁, 然后进入new了一个对象, 并开心地执行完了。这个时候另外一个线程获得了锁, 但让它也不会再去判断 s是否为null,所以它也会再执行一次new操作。所以这里执行了两次new操作。当然最后s还是只指向后一次new的对象。
所以这个时候需要双重锁定, 就是在 synchronized中再加一次 null判断, 如下:
3. 静态内部类:既实现了线程安全,又避免了同步带来的性能影响。
单例模式的作用就是保证整个应用程序的生命周期中,任何一个时刻,单例类的实例都只存在一个。单例模式主要有三个特点:
1. 单例类只能有一个实例
2. 单例类必须创建自己唯一的实例。
3. 单例类必须为其他对象提供这一实例。
那么如何实现满足上述条件的单例类呢?答案是:
1. 私有构造方法。
2. 内部创建静态对象。
3. 提供静态方法返回该静态对象。
单例设计模式主要有两种实现方法:饿汉式和懒汉式。
1. 饿汉式单例:在定义开始,便实例化自己。
public class Single0 { private Single0() { //私有构造方法 } private static Single0 s=new Single0();//内部创建静态方法,实例化 public static Single0 getsingle() { return s;//提供静态方法,返回对象 } }
2. 懒汉式单例:在第一次调用时实例化自己。
class Single1{ private Single1() { //私有构造方法 } public static Single1 s=null; public static Single1 getsingle() { s=new Single1();//实例化 return s; } }
那饿汉式和懒汉式分别有什么区别呢?
1. 线程安全:
饿汉式天生线程安全,可以直接用于多线程而不会出现问题。
懒汉式本身非线程安全,需要人为实现线程安全。
2. 资源加载和性能:
饿汉式在类创建的同时就实例化一个静态对象出来,不管之后会不会使用这个单例,都会占据一定的内存,造成内存泄漏,但相应的,在第一次调用时速度也会更快。
而懒汉式顾名思义,会延迟加载,在第一次使用该单例的时候才会实例化对象出来,第一次调用时要做初始化,如果要做的工作比较多,性能上会有些延迟,之后就和饿汉式一样了。
为了保证懒汉式的线程安全,通常有三种方法:
1. 全局访问点加同步。
由于synchronized是锁方法, 当两个线程都要进入getsingle()时, 只有一个能进入, 并创建出实例, 然后另外一个进入后, 判断 s不为null, 然后直接得到s。 这种做法是没有错误的. 但是由于线程都需要通过getsingle()来获取对象, 所以getsingle()调用频率很高, 所以线程被锁的频率也很高, 所以这种做法效率低。简言之,不管对象有没有被创建,其余线程都只能等待这个方法的锁。
class Single1{ private Single1() { //私有构造方法 } public static Single1 s=null; public static synchronized Single1 getsingle() { s=new Single1();//实例化 return s; } }
2. 双重检查锁定。
由于上述都是在等待同步方法的锁,很容易想到把synchronized放在方法里面,这样可以避免方法的阻塞。
class Single2{ private Single2() { //私有构造方法 } public static Single2 s=null; public static Single2 getsingle() { if(s==null) { synchronized(Single2.class) { s=new Single2();//实例化 } } return s; } }
这种写法看似没有问题, 其实却有一个很大的隐患, 在于:如果两个线程同时执行getsingle(),判断 instance都不为null后, 进入if判断语句。这个时候一个线程获得锁, 然后进入new了一个对象, 并开心地执行完了。这个时候另外一个线程获得了锁, 但让它也不会再去判断 s是否为null,所以它也会再执行一次new操作。所以这里执行了两次new操作。当然最后s还是只指向后一次new的对象。
所以这个时候需要双重锁定, 就是在 synchronized中再加一次 null判断, 如下:
class Single3{ private Single3() { //私有构造方法 } public static Single3 s=null; public static Single3 getsingle() { if(s==null) { synchronized(Single3.class) { if(s==null) { s=new Single3();//实例化 } } } return s; } }
3. 静态内部类:既实现了线程安全,又避免了同步带来的性能影响。
相关文章推荐
- 设计模式之单例设计模式(饿汉单例设计模式&懒汉单例设计模式)
- Java基础 - 单例(饿汉、懒汉),Runtime类,Timer,线程通信,互斥锁,线程组,线程五种状态,线程池,工厂模式,GUI,适配器设计模式
- 设计模式C++实现(4)——饿汉懒汉之单例模式
- Java设计模式之单例模式(懒汉/饿汉)
- 设计模式之单例模式:懒汉&饿汉
- 单例设计模式(懒汉模式、饿汉模式)C++
- 多线程-单例设计模式懒汉 饿汉
- java的设计模式之单利设计模式(饿汉和懒汉)
- 设计模式 之 单例模式 (C++ 懒汉经典实现 & DCL实现 & 饿汉经典实现)
- 设计模式——单例模式之“饿汉模式”与“懒汉模式”
- Java设计模式中单例模式(Design Pattern):懒汉模式和饿汉模式
- java设计模式之单例模式写法,懒汉,饿汉,双检锁
- 设计模式:单例模式-懒汉模型和饿汉模型
- 单例设计模式(饿汉模式与懒汉模式)
- 黑马程序员——单例设计模式,饿汉加懒汉
- 设计模式-单例模式懒汉和饿汉的比较
- [置顶] 【设计模式】深入理解单例&懒汉饿汉&双重锁定
- JAVA单例设计模式(饿汉懒汉)
- Java中的单例设计模式之饿汉模式、懒汉模式
- 单类设计模式 --- 饿汉模式 & 懒汉模式