Java 设计模式---单例模式

杀神lwz

已于 2023-09-30 21:57:56 修改

阅读量436

点赞数 1

分类专栏：设计模式文章标签： java 设计模式单例模式

于 2021-09-25 11:43:11 首次发布

本文链接：https://blog.csdn.net/weixin_42472027/article/details/120468998

版权

设计模式专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1.4、DCL(Double Check Lock 双端检测机制)

1.5、静态代码块

1.6、静态内部类方式

1.7、枚举类方式

一、单例模式

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。

单例模式的创建：

1.首先必须将类的构造器的访问权限设置为private，这样，就不能用new操作符在类的外部产生类的对象了，但在类内部仍可以产生该类的对象。

2.因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象。

3.静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的。

单例设计模式的好处：

1、某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。

2、省去了new操作符，降低了系统内存的使用频率，减轻GC压力。

3、有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统完全乱了。（比如一个军队出现了多个司令员同时指挥，肯定会乱成一团），所以只有使用单例模式，才能保证核心交易服务器独立控制整个流程。

单例(Singleton)设计模式-应用场景

1.网站的计数器，一般也是单例模式实现，否则难以同步。

2.应用程序的日志应用，一般都使用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。

3.数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。

4.项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，都生成一个对象去读取。

5.Application 也是单例的典型应用

6.Windows的Task Manager (任务管理器)就是很典型的单例模式

7.Windows的Recycle Bin (回收站)也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。

8.java.lang.Runtime：

public class Runtime {
    private static Runtime currentRuntime = new Runtime();

    /**
     * Returns the runtime object associated with the current Java application.
     * Most of the methods of class <code>Runtime</code> are instance
     * methods and must be invoked with respect to the current runtime object.
     *
     * @return  the <code>Runtime</code> object associated with the current
     *          Java application.
     */
    public static Runtime getRuntime() {
        return currentRuntime;
    }

    /** Don't let anyone else instantiate this class */
    private Runtime() {}

1、单例模式创建方式

1.1、饿汉式

public class SingletonTest1 {
	public static void main(String[] args) {
		Singleton s1 = Singleton.getInstance();
		Singleton s2 = Singleton.getInstance();
		System.out.println(s1 == s2);//true
	}
}

//饿汉式
class Singleton{

	//1.私有化类的构造器
	private Singleton(){
	}
	
	//2.内部创建类的对象
	//4.要求此对象也必须声明为静态的
	private static Singleton INSTANCE = new Singleton();
	
	//3.提供公共的静态的方法，返回类的对象
	public static Singleton getInstance(){
		return INSTANCE;
	}
}

1.2、懒汉式

public class SingletonTest2 {
	public static void main(String[] args) {
		Singleton2 s1 = Singleton2.getInstance();
		Singleton2 s2 = Singleton2.getInstance();
		System.out.println(s1 == s2);//true
	}
}

//懒汉式
class Singleton2{
	
	//1.私有化类的构造器
	private Singleton2(){
		
	}
	
	//2.声明当前类对象，没有初始化
	//4.此对象也必须声明为static的
	private static Singleton2 instance = null;
	
	//3.声明public、static的返回当前类对象的方法
	public static Singleton2 getInstance(){
		
		if(instance == null){
			instance = new Singleton2();
		}
		return instance;
	}
	
}

饿汉式和懒汉式的区别？

饿汉式：

坏处：对象加载时间过长。

好处：饿汉式是线程安全的

懒汉式：

好处：延迟对象的创建。

目前的写法坏处：线程不安全。

1.3、解决懒汉式线程不安全写法：

public class SingletonTest2 {
	public static void main(String[] args) {
		Singleton2 s1 = Singleton2.getInstance();
		Singleton2 s2 = Singleton2.getInstance();
		System.out.println(s1 == s2);//true
	}
}

//懒汉式
class Singleton2{
	
	//1.私有化类的构造器
	private Singleton2(){
		
	}
	
	//2.声明当前类对象，没有初始化
	//4.此对象也必须声明为static的
	private static Singleton2 instance = null;
	
	//3.声明public、static的返回当前类对象的方法
	public static Singleton2 getInstance(){
		
		if(instance == null){
			syncInit();
		}
		return instance;
	}
	
	private static synchronized void syncInit() {
		if (instance == null) {
			instance = new Singleton2();
		}
	}
	
}

1.4、DCL(Double Check Lock 双端检测机制)

public class SingletonTest3 {
	public static void main(String[] args) {

		for (int i = 0; i < 10000; i++) {
			new Thread(() -> {
				Singleton2 s3 = Singleton2.getInstance();
			}, String.valueOf(i)).start();
		}
	}
}

//懒汉式
class Singleton2 {

	// 1.私有化类的构造器
	private Singleton2() {
		System.out.println(Thread.currentThread().getName() + "\t 我是构造方法Singleton2()");
	}

	// 2.声明当前类对象，没有初始化
	// 4.此对象也必须声明为static的
	private static volatile Singleton2 instance = null;

	// 3.声明public、static的返回当前类对象的方法
	// DCL(Double Check Lock 双端检测机制)
	public static Singleton2 getInstance() {

		if (instance == null) {
			synchronized (Singleton2.class) {
				if (instance == null) {
					instance = new Singleton2();
				}
			}
		}
		return instance;
	}

}

DCL(Double Check Lock 双端检测机制) 不一定线程安全，原因是有指令重排序的存在，加入volatile可以禁止指令重排。

原因在于某一个线程执行到第一次检测，读取到的instance不为null时，instance的引用对象可能没有完成初始化。

instance = new Singleton2();可以分为以下3步完成(伪代码)
memory=allocate();//1.分配对象内存空间
instance(memory);//2.初始化对象
instance=memory;//3.设置instance指向刚分配的内存地址，此时instance!=null

步骤2和步骤3不存在数据依赖关系，而且无论重排前还是重排后程序的执行结果在单线程中并没有改变，因此这种重排优化是允许的。

memory=allocate();//1.分配对象内存空间
instance=memory;//3.设置instance指向刚分配的内存地址，此时instance!=null，但是对象还没有初始化完成
instance(memory);//2.初始化对象

但是指令重排只会保证串行语义的执行的一致性（单线程），但并不会关心多线程间的语义一致性。所以当一条线程访问instance不为null时，由于instance实例未必已初始化完成，也就造成了线程安全问题。

此时需要使用private static volatile Singleton2 instance = null;

1.5、静态代码块

public class Singleton04 {
	private static final Singleton04 INSTANCE;
	static {
		INSTANCE = new Singleton04();
	}

	private Singleton04() {
	}

	public static Singleton04 getInstance() {
		return INSTANCE;
	}

	public static void main(String[] args) {
		Singleton04 m1 = Singleton04.getInstance();
		Singleton04 m2 = Singleton04.getInstance();
		System.out.println(m1 == m2);
	}
}

1.6、静态内部类方式

//静态内部类的方式
public class Singleton05 {

	private Singleton05() {
	}

	private static class Singleton05Holder {
		private final static Singleton05 INSTANCE = new Singleton05();
	}

	public static Singleton05 getInstance() {
		return Singleton05Holder.INSTANCE;
	}

	public static void main(String[] args) {
		for (int i = 0; i < 100; i++) {
			new Thread(() -> {
				System.out.println(Singleton05.getInstance().hashCode());
			}).start();
		}
	}
}

1.7、枚举类方式

//枚举方式，不仅可以解决线程同步，还可以防止反序列化
public enum Singleton06 {

	INSTANCE;

	public static void main(String[] args) {
		for (int i = 0; i < 100; i++) {
			new Thread(() -> {
				System.out.println(Singleton06.INSTANCE.hashCode());
			}).start();
		}
	}
}

Java volatile学习

Java 设计模式(一)：Java 设计模式(一)