单例模式

单例模式(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))。

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

相关推荐
©️2020 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页