设计模式学习笔记之单例模式

Posted 2022-12-09 birdlove1987

设计模式中最简单的模式就要数单例模式了。

那么什么是单例模式呢？ 保证一个类仅有一个实例，并提供一个访问它的全局访问点。

上图为单例模式的结构示意图。

那么为什么要使用单例模式呢？

简单来说：单例模式的存在，一则，解决多线程并发访问的问题。二则，节约系统内存，提交系统运行的效率，提高系统性能。

下面我们就来看看程序中是怎么实现单例模式的：

一般我们设计一个类都是这样的：

public class Abc

	private Abc()
	
			
	;	

然后在其他部分调用：

public class Cbd

	public Cbd()
	
		Abc n1,n2;
		n1=new Abc();
		n2=new Abc();
	

但这样Abc这个类就会出现好多实体并不好控制，下面我们来改变一下啊Abc这个类的结构从而实现单例模式：

public class Abc
	
	private static Abc uniqeInstance_Abc = null; //通过内置私有静态参数实现单例状态
	
	private Abc()
		
	;
	
	//外部只能调用单例，单例实体有类内部控制
	public static Abc getInstance_Abc()
	
		if(uniqeInstance_Abc==null)
		
			uniqeInstance_Abc=new Abc();
		
		return uniqeInstance_Abc;
		
	

这样我们变实现了单例模式

public class Cbd

	public Cbd()
	
		Abc n1,n2;
		n1=Abc.getInstance_Abc();
	

可以看到Abc这个类的构造函数变成了private修饰，所以并不能在其他类中new出来只能通过调用getxxx函数来使用，这就保证了单例性。

写一个小例子，模拟一下我们计算机中的CPU处理程序：

package com.java.jikexueyuan.singleton;

public class Cpu 
	private boolean idle;
	private boolean compute;
	public volatile static Cpu uniqueInstance_cpu = null;
	int num;

	private Cpu() 
		idle = true;
		compute = false;
		num = 101;
	

	public static Cpu getInstance() 

		if (uniqueInstance_cpu == null) 
			synchronized (Cpu.class) 
				if (uniqueInstance_cpu == null) 
					uniqueInstance_cpu = new Cpu();
				
			
		
		return uniqueInstance_cpu;
	

	//判断cpu是否为空闲状态
	public boolean isIdle() 
		if (idle) 
			idle = false;
			compute = false;
			System.out.println("cpu空闲");
			return true;
		
		else
		
			System.out.println("cpu繁忙");
			return true;
		
	
	
	//cpu计算结束
	public void compute_over() 
		if ((!idle) && compute) 
			idle = true;
			compute = false;
			System.out.println("cpu计算完成");
		
	
	
	//启动cpu计算过程
	public void computing() 
		if ((!idle) && (!compute)) 
			compute = true;
			System.out.println("cpu正在计算,计算cpu编号为" + num);
		
	

我们来调用一下：

public class test 
	public static void main(String[] args) 
	
		for(int i = 0; i < 5 ; i++)
		
			Cpu c1 = Cpu.getInstance();
			if(c1.isIdle())
			
				c1.computing();
				c1.compute_over();
			
		
	

其实这样设计的单例模式有一个重大隐患，就是当两个线程同时创建一个Abc类的时候，可以会new出来两个实体而导致严重的错误。。。

解决传统的解决方式呢，有三种：

第一种：添加同步锁：

public class Abc
	
	private static Abc uniqeInstance_Abc = null; //通过内置私有静态参数实现单例状态
	
	private Abc()
		
	;
	
	//外部只能调用单例，单例实体有类内部控制
	//添加了同步所,保证不会有两个线程同是进入该方法
	public static synchronized Abc getInstance_Abc()
	
		if(uniqeInstance_Abc==null)
		
			uniqeInstance_Abc=new Abc();
		
		return uniqeInstance_Abc;
		
	

第二种：急切创建法：

public class Abc
	
	//通过内置私有静态参数实现单例状态
	//直接创建实例
	private static Abc uniqeInstance_Abc = new Abc();
	
	private Abc()
		
	;
	
	//外部只能调用单例，单例实体有类内部控制
	public static Abc getInstance_Abc()
	
		if(uniqeInstance_Abc==null)
		
			uniqeInstance_Abc=new Abc();
		
		return uniqeInstance_Abc;
		
	

第三种：双重检查加锁法

public class Abc
	
	//通过内置私有静态参数实现单例状态
	//volatile关键字确保多线程在处理时的正确性
	private volatile static Abc uniqeInstance_Abc = new Abc();
	
	private Abc()
		
	;
	
	//外部只能调用单例，单例实体有类内部控制
	public static Abc getInstance_Abc()
	
		//多重加锁
		if (uniqeInstance_Abc == null) 
			synchronized (Abc.class) 
				if (uniqeInstance_Abc == null) 
					uniqeInstance_Abc = new Abc();
				
			
		
		return uniqeInstance_Abc;
	

单例模式的使用场景：

1.资源共享的情况下，避免由于资源操作时导致的性能或损耗等。如上述中的日志文件，应用配置。 
2.控制资源的情况下，方便资源之间的互相通信。如线程池等。