0.综述
单例模式八种方式
1)饿汉式(静态常量)
2)饿汉式(静态代码块)
3)懒汉式(线程不安全)
4)懒汉式(线程安全,同步方法)
5)懒汉式(线程安全,同步代码块)
6)双重检查
7)静念内部类
8)枚举
1.饿汉式(静态常量)
- 以代码说明
// 饿汉式(静态变量)
public class Singleton1 {
//1.构造器私有化
private Singleton1(){
}
//2.本类内部创建对象实例
private final static Singleton1 instance = new Singleton1();
//3.提供一个公有的静态方法,返回实例对象
public static Singleton1 getInstance(){
return instance;
}
}
2.测试代码
@Test
fun testSingleton1(){
Log.d(TAG, "====================Singleton1====================")
Log.d(TAG,"Singleton1 1 hashCode=" +Singleton1.getInstance().hashCode())
Log.d(TAG,"Singleton1 2 hashCode=" +Singleton1.getInstance().hashCode())
}
- 输出结果
06-22 11:34:29.749 D DesignPattern: Singleton1 1 hashCode=36222471
06-22 11:34:29.750 D DesignPattern: Singleton1 2 hashCode=36222471
优缺点说明:
1)优点:这种写法比较简单,就是在类装载的时侯就完成实例化。避免了线程同步
2)缺点:在类装载的时候就完成实例化,没有达到Lazy Loading的效果。如果从始
至终从未使用过这个实例,则会造成内存的浪费
3)这种方式基于classloder机制避免了多线程的同步问题,不过,instance在类装载
时就实例化,在单例模式中大多数都是调用getlnstance方法,但是导致类装载
的原因有很多种,因此不能确定有其他的方式(或者其他的静态方法)导致类
装载,这时候初始化instance就没有达到lazy loading的效果
4)结论:这种单例模式可用,可能造成内存浪费
2.饿汉式(静态代码块)
- 代码 (和静态变量类似)
public class Singleton2 {
//1.构造器私有化
private Singleton2() {
}
//2.本类内部创建对象实例
private static Singleton2 instance;
static {//在静态代码块中,创建单例对象
instance = new Singleton2();
}
//3.提供一个公有的静态方法,返回实例对象
public static Singleton2 getInstance() {
return instance;
}
}
优缺点说明:
1)这种方式和上面的方式其实类似,只不过将类实例化的过程放在了静态代码块
中,也是在类装载的时候,就执行静态代码块中的代码,初始化类的实例。优
缺点和上面是一样的。
2)结论:这种单例模式可用,但是可能造成内存浪费
3.懒汉式(线程不安全)
/**
* 懒汉式(线程不安全)
*/
public class Singleton3 {
//1.构造器私有化
private Singleton3() {
}
//2.本类内部创建对象实例
private static Singleton3 instance;
//3.提供一个公有的静态方法,返回实例对象
// 当用到该方法时,才去创建对象实例
public static Singleton3 getInstance() {
if (instance == null) {// 当多个线程跑入这个条件时,可能会导致创建多个对象实例
instance = new Singleton3();
}
return instance;
}
}
优缺点说明:
1)起到了Lazy Loading的效果,但是只能在单线程下使用。
2)如果在多线程下,一个线程进入了if (singleton == null)判断语句块,还未来得及
往下执行,另一个线程也通过了这个判断语句,这时便会产生多个实例,所以
在多线程环境下不可使用这种方式
3)结论:在实际开发中,不要使用这种方式。
4.懒汉式(线程安全,同步方法)
优缺点说明:
1)解决了线理不安全问题
2)效率太低了,每个线程在想获得类的实例时候,执行getinstancel)方法都要进行
同步,而其实这个方法只执行一次实例化代码就够了,后面的想获得该类实例,
直接return就行了。方法进行同步效率太低
3)结论:在实际开发中,不推荐使用这种方式
5.懒汉式(线程安全,同步代码块)
/**
* 懒汉式(同步方法, 线程安全)
*/
public class Singleton4 {
//1.构造器私有化
private Singleton4() {
}
//2. 本类内部创建对象实例
private static Singleton4 instance;
//3.提供一个公有的静态方法,返回实例对象
// 对方法加同步锁
public static synchronized Singleton4 getInstance() {
if (instance == null) {
instance = new Singleton4();
}
return instance;
}
}
优缺点说明:
1)这种方式,本意是想对第四种实现方式的改进,因为前面同步方法效率太低,
改为同步产生实例化的的代码块
2)但是这种同步并不能起到线程同步的作用。跟第3种实现方式遇到的情形一
致,假如一个线程进入了if(singleton=w nul)判断语句块,还未来得及往下执行,
另一个线程也通过了这个判断语句,这时便会产生多个实例
3)结论:在实际开发中,不能使用这种方式
6. 双重检查
/**
* 双重检查(推荐, 使用volatile修饰成员变量,防止指令重排; 也是同步代码块的改善)
*/
public class Singleton6 {
//1.构造器私有化
private Singleton6() {
}
//2.本类内部创建对象实例
private static volatile Singleton6 instance;
//3.提供一个公有的静态方法,返回实例对象 (双重检查)
public static Singleton6 getInstance() {
if (instance == null) {
synchronized (Singleton6.class) {
if (instance == null) {
instance = new Singleton6();
}
}
}
return instance;
}
}
优缺点说明:
- Double-Check概念是多线程开发中常使用到的,如代码中所示,我们进行了两
次if(singleton == nul)检查,这样就可以保证线程安全了。
2)这样,实例化代码只用执行一次,后面再次访问时,判断if (singleton == nul),
直接return实例化对象,也避免的反复进行方法同步
3)线程安全;延迟加载:效率较高
4)结论:在实际开发中,推荐使用这种单例设计模式
7.静态内部类
/**
* 内部静态类(线程安全,推荐)
*/
public class Singleton7 {
//1.构造器私有化
private Singleton7() {
}
//2.本类内中的内部静态类, 创建对象实例(仅在第一调用该类时,创建)
private static class Singleton7Instance {
private static final Singleton7 INSTANCE = new Singleton7();
}
//3.提供一个公有的静态方法,返回实例对象
public static Singleton7 getInstance() {
return Singleton7Instance.INSTANCE;
}
}
优缺点说明:
这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
2)静态内部类方式在Singleton类被装载时并不会立即实例化,而是在需要实例化
时,调用getinstance方法,才会装载Singletoninstance类,从而完成Singleton的
实例化。
3)类的静态属性只会在第一次加载类的时候初始化,所以在这里,VM帮助我们
保证了线程的安全性,在类进行初始化时,别的线程是无法进入的。
4)优点:避免了线程不安全,利用静态内部类特点实现延迟加载,效率高
5)结论:推靠使用。
8.枚举
/**
* 枚举(线程安全,推荐)
*/
public enum Singleton8 {
INSTANCE;//属性
public String sayOK(){
return "枚举类型OK";
}
}
测试代码:
@Test
fun testSingleton8() {
Log.d(TAG, "====================Singleton8====================")
Log.d(TAG, "Singleton8 1 hashCode=" + Singleton8.INSTANCE.hashCode())
Log.d(TAG, "Singleton8 2 hashCode=" + Singleton8.INSTANCE.hashCode())
Log.d(TAG, "Singleton8 3 call function return=" + Singleton8.INSTANCE.sayOK())
}
输出结果
2020-06-24 11:21:09.285 22001-22060/? D/DesignPattern: ====================Singleton8====================
2020-06-24 11:21:09.286 22001-22060/? D/DesignPattern: Singleton8 1 hashCode=36222471
2020-06-24 11:21:09.286 22001-22060/? D/DesignPattern: Singleton8 2 hashCode=36222471
2020-06-24 11:21:09.287 22001-22060/? D/DesignPattern: Singleton8 3 call function return=枚举类型OK
优缺点说明:
1)这借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题,而
2)这种方式是Effective Java作者Josh Bloch提倡的方式
3)结论:推荐使用
因此,推荐使用 双重检查、静态内部类、枚举的实现方式,确保线程安全的同时,起到懒加载,并且保证效率。
如果能确保会用这个类,也可以使用懒汉式的线程安全方式