单例遇上多线程

最新推荐文章于 2018-08-25 17:15:33 发布
最新推荐文章于 2018-08-25 17:15:33 发布
阅读量697 收藏
点赞数 1
分类专栏： 设计模式 多线程 文章标签： 单例 懒汉式 饿汉式 单例设计模式 多线程中的单例
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A784586/article/details/68937079
版权
单例遇上多线程
单例：一个类只能有一个实例；
多线程：程序并发执行；

总结：六种实现方式
【DCL+静态内置类/静态代码块/枚举+序列化：有特点的DCL，思想一样的静态内置类/静态代码块/枚举,特殊的序列化】
1.立即加载/饿汉式 ： 单线程和多线程下都是安全的；
2.延迟加载/懒汉式： 一般：私有静态volatile成员+私有构造函数+同步获取函数+重写克隆函数； 优化：DCL双检查锁机制 ；
3.静态内置类;在 静态内置类 中实例化；类饿汉式的思想；
4.静态代码块：在 静态代码块 中实例化；类饿汉式的思想；
5.枚举类enum:和静态代码块类似，枚举类的构造方法自动会被调用；
6.序列化和反序列化：需要函数 readResolve() ;


java实现代码：
1.立即加载/饿汉式 ： 单线程和多线程下都是安全的； 
package com.mytestsinglonandmutilthread;

//MyObject位单例
class MyObject{
	//1. 私有静态变量
	private static MyObject myObject=new MyObject();
	//2.私有构造函数
	private MyObject(){	
	}
	//3.静态获取方法
	public static MyObject getmyObject(){
		return myObject;
	}
	//4.重写clone函数
	@Override
	protected Object clone() throws CloneNotSupportedException {
		return getmyObject();
	}	
}
//实现接口的方式实现
class MyThread01 implements Runnable{
	@Override
	public void run() {
		System.out.println(MyObject.getmyObject().hashCode());	
	}	
}
//继承的方式实现 
class MyThread02 extends Thread{
	@Override
	public void run() {
		System.out.println(MyObject.getmyObject().hashCode());	
	}	
}
public class Singleton01 {
	//测试的主函数
	 public static void main(String[] args) {
		 MyThread01 t1=new MyThread01();
		 MyThread02 t2=new MyThread02();
		 MyThread02 t3=new MyThread02();
		 new Thread(t1).start();//实现接口的启动方式
		 new Thread(t2).start();//利用构造函数，一个线程的任务也可以交由另外个线程执行
		 t3.start();//start（）是Thread类的方法；
	}
}



运行截图：


2.延迟加载/懒汉式： 一般：私有静态volatile成员+私有构造函数+同步获取函数+重写克隆函数； 优化： DCL双检查锁机制 ；
java实现代码： 
package com.mytestsinglonandmutilthread;

//MyObject位单例
class MyObject02 {
	// 1. 私有静态变量
	private static MyObject02 myObject = null;

	// 2.私有构造函数
	private MyObject02() {
	}

	// 3.同步的静态获取方法
	public static synchronized MyObject02 getmyObject() {
		if (myObject == null)
			myObject = new MyObject02();
		return myObject;
	}

	// 4.重写clone函数
	@Override
	protected Object clone() throws CloneNotSupportedException {
		return getmyObject();
	}
}

/*// 实现接口的方式实现
class MyThread03 implements Runnable {
	@Override
	public void run() {
		System.out.println(MyObject02.getmyObject().hashCode());
	}
}*/

// 继承的方式实现
class MyThread03 extends Thread {
	@Override
	public void run() {
		System.out.println(MyObject02.getmyObject().hashCode());
	}
}

public class Singleton02 {
	// 测试的主函数
	public static void main(String[] args) {
		MyThread03 t1 = new MyThread03();
		MyThread03 t2 = new MyThread03();
		MyThread03 t3 = new MyThread03();
		t1.start();
		t2.start();
		t3.start(); 
	}
}
优化： DCL双检查锁机制 ； 
package com.mytestsinglonandmutilthread;

//MyObject位单例
class MyObject02 {
	// 1. 私有静态变量,DCL 优化这个私有静态变量需要加volatile保证变量修改的可见性
	private static MyObject02 myObject = null;

	// 2.私有构造函数
	private MyObject02() {
	}

	// 3.同步的静态获取方法【跟同步整个块效果一致】---》去掉synchronized。
	public static MyObject02 getmyObject(){
		try {
			if (myObject == null){//双重检查1
				Thread.sleep(3000);	 
				synchronized (MyObject02.class) {//减少锁的粒度，提高并发度
					if(myObject==null){//双重检查2
						myObject = new MyObject02();
					}
				}
			}
		} catch (Exception e) {
		}
		return myObject;
	}

	// 4.重写clone函数
	@Override
	protected Object clone() {
		return getmyObject();
	}
}

// 继承的方式实现
class MyThread03 extends Thread {
	@Override
	public void run() {
		System.out.println(MyObject02.getmyObject().hashCode());
	}
}

public class Singleton02 {
	// 测试的主函数
	public static void main(String[] args) {
		MyThread03 t1 = new MyThread03();
		MyThread03 t2 = new MyThread03();
		MyThread03 t3 = new MyThread03();
		t1.start();
		t2.start();
		t3.start(); 
	}
}
运行结果：三个hashcode相同。


3.静态内置类;在 静态内置类 中实例化；类饿汉式思想； 
package com.mytestsinglonandmutilthread;

//MyObject为单例
class MyObject03 {
	// 1. 私有静态内置类（类饿汉式思想）
	private static class myobjecthandler{
		private static MyObject03 myObject03=new MyObject03();
	}

	// 2.私有构造函数
	private MyObject03() {
	}

	// 3.静态获取方法
	public static MyObject03 getmyObject(){
		return myobjecthandler.myObject03;//访问私有静态内置类中的成员
	}

	// 4.重写clone函数
	@Override
	protected Object clone() {
		return getmyObject();//访问静态获取方法3
	}
}

// 继承的方式实现
class MyThread04 extends Thread {
	@Override
	public void run() {
		System.out.println(MyObject03.getmyObject().hashCode());
	}
}

public class Singleton03 {
	// 测试的主函数
	public static void main(String[] args) {
		MyThread04 t1 = new MyThread04();
		MyThread04 t2 = new MyThread04();
		MyThread04 t3 = new MyThread04();
		t1.start();
		t2.start();
		t3.start(); 
	}
}



4.静态代码块：在 静态代码块 中实例化；类饿汉式的思想。 
package com.mytestsinglonandmutilthread;

//MyObject为单例
class MyObject04 {
	// 1. 私有静态成员+静态代码块（类饿汉式思想）
	private static MyObject04 MyObject04=null;
	static{
		 MyObject04=new MyObject04();
	}

	// 2.私有构造函数
	private MyObject04() {
	}

	// 3.静态获取方法
	public static MyObject04 getmyObject(){
		return MyObject04;//访问私有静态内置类中的成员
	}

	// 4.重写clone函数
	@Override
	protected Object clone() {
		return getmyObject();//访问静态获取方法3
	}
}

// 继承的方式实现
class MyThread05 extends Thread {
	@Override
	public void run() {
		System.out.println(MyObject04.getmyObject().hashCode());
	}
}

public class Singleton04 {
	// 测试的主函数
	public static void main(String[] args) {
		MyThread05 t1 = new MyThread05();
		MyThread05 t2 = new MyThread05();
		MyThread05 t3 = new MyThread05();
		t1.start();
		t2.start();
		t3.start(); 
	}
}
5.枚举类enum:和静态代码块类似，使用枚举类的时候，利用枚举类的构造方法自动会被调用；
 
package com.mytestsinglonandmutilthread;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

//枚举类不暴露，直接写枚举类，会违反职责单一原则；MyObject05=枚举类+静态获取方法
class MyObject05 {
	//1.枚举类+静态获取方法
	public enum MyEnumSingleton{
		//001枚举类的成员
		connectionFactory;
		//002枚举类的私有成员
		private Connection connection;//connection为单例
		//003枚举类的构造方法
		private MyEnumSingleton(){
			System.out.println("创建连接对象");
			String url="jdbc:sqlserver://localhost:1079;databaseName=mydatabase01";
			String username="sa";
			String password="";
			String driverName="com.microsoft.sqlserver.jdbc.SQLServerDriver";
			try {
				Class.forName(driverName);
				connection=DriverManager.getConnection(url, username, password);
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			}catch (SQLException e) {
				e.printStackTrace();
			}
			
			
		}
		//004枚举类的非静态获得函数
		public Connection getConnection(){
			return connection;
		}
		
		
	}

	// 2.静态获取方法
	public static Connection getConnection() {
		return MyEnumSingleton.connectionFactory.getConnection();//访问私有静态内置类中的成员
	}

	// 3.重写clone函数
	@Override
	protected Object clone() {
		return getConnection();//访问静态获取方法3
	}
}

// 继承的方式实现
class MyThread06 extends Thread {
	@Override
	public void run() {
		System.out.println(MyObject05.getConnection().hashCode());
	}
}

public class Singleton05 {
	// 测试的主函数
	public static void main(String[] args) {
		MyThread06 t1 = new MyThread06();
		MyThread06 t2 = new MyThread06();
		MyThread06 t3 = new MyThread06();
		t1.start();
		t2.start();
		t3.start(); 
	}
}


6.序列化和反序列化：需要在单例的对象中多写一个函数 readResolve() ;
这个函数的代码如下： 
//###序列化保证单例需要多写的一个函数，少了这个而函数就不能保证单例 ###
	protected Object readResolve(){
		return MysingletonHandler.instance;
		}


java代码如下： 
package com.mytestsinglonandmutilthread;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

class Mysingleton implements Serializable{
	private static final long serialVersionUID = 1L;
	
	private static class MysingletonHandler{//静态内置类实现单例
		private static final Mysingleton instance=new Mysingleton();
	}
	private Mysingleton(){}//私有构造函数
	public static Mysingleton getInstance(){//静态公开获取函数
		return MysingletonHandler.instance;
	}
	@Override
	protected Object clone(){//重写克隆
		return getInstance();
	}
	//###序列化保证单例需要多写的一个函数，少了这个而函数就不能保证单例 ###
	protected Object readResolve(){
		return MysingletonHandler.instance;
		}
}

public class Singleton06 {
	// 测试的主函数
	public static void main(String[] args) {
	//模拟业务类的代码saveAndRead
		//取到单例
		Mysingleton object=Mysingleton.getInstance();
		System.out.println("存到文件的对象hash:"+object.hashCode());
		//001保存对象到文件
		try {
			FileOutputStream fos=new FileOutputStream(new File("object.txt"));
			ObjectOutputStream oos=new ObjectOutputStream(fos);
			oos.writeObject(object);
			oos.close();
			fos.close();
		}catch (Exception e) {
			e.printStackTrace();
		}
		
		//002读文件中的对象
		try {
			FileInputStream fip=new FileInputStream(new File("object.txt"));
			ObjectInputStream ois=new ObjectInputStream(fip);
			Mysingleton objectread=(Mysingleton) ois.readObject();//此处调用readResolve()
			ois.close();
			fip.close();
			
			System.out.println("从文件读到的对象hash:"+objectread.hashCode());
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}







江说江湖
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程实战之单例模式与多线程的实例详解
08-26
Java多线程实战之单例模式与多线程的实例详解 单例模式是Java多线程编程中最常用的设计模式之一，它的主要作用是确保一个类在应用程序中只有一个实例，并提供一个全局访问点。单例模式有多种实现方式，如饿汉模式、...
你所不知道的单例模式和多线程并发在单例模式中的影响
a_lonely_dancer的博客
09-06 1万+
本博客是根据一篇博客修改的。因为原文博客对于菜鸟不是很易理解，所以在这里加了点东西单例对象（Singleton）是一种常用的设计模式。在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。这样的模式有几个好处：1、某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。2、省去了new操作符，降低了系统内存的使用频率，减轻GC压力。3、有些类如交易所的核心交易引擎，控制着交
C# 单线程和多线程下的单例模式的实现
qq_36512517的博客
07-15 2664
该单例模式是线程不安全的，只能在单线程下执行，在多线程中如果被两个线程同时调用Instance属性时，此时两个线程判断 if (_instance==null)时都会返回true，就会创建两个实例。public class Singleton{ /// <summary> /// 静态变量(用来存放类的实例) /// </summary> stati...
单例模式多线程不安全，浅解析ThreadLocal类
qq_42217505的博客
08-25 1932
1、单例模式下出现的安全问题 先看下面小段代码，一个controller，一个service。 controller.Java代码： …….. @Autowired private XXXService xxxService; …….. @RequestMapping(“/doXXX.do”) public void doXXX(){ ….. xxxServ...
单例模式与多线程
limin0983的博客
04-26 252
如何使单例模式遇到多线程使安全的，正确的。 1.1单例模式之饿汉模式       饿汉模式（立即加载）：就是使用类的时候已经将对象创建完毕，常见的实现办法就是直接new 实例化。       立即加载是在方法调用前，实例已经被创建了，实现代码如下： package testSingleton; public class MyObject { private static MyO
Spring Scope
courage的专栏
08-12 2万+
详细参考：http://blog.csdn.net/songfuyu_1997/article/details/6224094 1. 什么是scope？     scope用来声明IOC容器中的对象应该处的限定场景或者说该对象的存活空间，即在IOC容器在对象进入相应的scope之前，生成并装配这些对象，在该对象不再处于这些scope的限定之后，容器通常会销毁这些对象。 2. scope分
QT单例模式、多线程、双重校验加锁
06-11
在QT中，单例模式、多线程以及双重校验加锁（Double-Checked Locking）是常见的编程模式和技术，尤其在处理并发和资源管理时显得尤为重要。 **单例模式** 是一种设计模式，确保一个类只有一个实例，并提供一个全局...
C++ 多线程和多线程下的单例模式
01-08
本资源描述了C++11 中多线程的创建，C++11中std命名空间中将boost库中的Thread加入，boost多线程从准标准变为标准，其中还介绍了C++ 多线程下的单例模式的使用，本文档为txt文档
Java多线程下的单例模式参考
09-02
在多线程环境中，实现单例模式时需要特别注意线程安全问题，以防止在并发访问时产生多个实例。本篇将探讨如何在Java多线程下实现单例模式，重点关注`synchronized`关键字和`java.util.concurrent.locks.Lock`接口的`...
JAVA多线程并发下的单例模式应用
08-31
JAVA多线程并发下的单例模式应用 单例模式是设计模式中比较简单的一个，也是非常常见的，但是在多线程并发的环境下使用却是不那么简单了。今天我们将分享一个在开发过程中遇到的单例模式的应用。 单例模式的定义：...
高并发下线程安全的单例模式（最全最经典）
热门推荐
05-11 14万+
在所有的设计模式中，单例模式是我们在项目开发中最为常见的设计模式之一，而单例模式有很多种实现方式，你是否都了解呢？高并发下如何保证单例模式的线程安全性呢？如何保证序列化后的单例对象在反序列化后任然是单例的呢？这些问题在看了本文之后都会一一的告诉你答案，赶快来阅读吧！
chromedriver-mac-arm64_126.0.6474.0.zip
07-31
chromedriver-mac-arm64_126.0.6474.0.zip
chromedriver-mac-arm64_128.0.6548.0.zip
07-31
chromedriver-mac-arm64_128.0.6548.0.zip
MySQL查询加速器：利用Query Cache提升效率
07-31
MySQL是一个流行的开源关系型数据库管理系统（RDBMS），广泛用于Web应用程序的后端数据存储。它基于结构化查询语言（SQL）来管理数据，并且是LAMP（Linux, Apache, MySQL, PHP/Python/Perl）技术栈的一部分，这个技术栈常用于构建动态网站和Web应用程序。 MySQL的特点包括： - **开放源代码**：MySQL的源代码是公开的，任何人都可以自由使用和修改。 - **跨平台**：MySQL可以在多种操作系统上运行，包括Linux、Windows、macOS等。 - **高性能**：MySQL以其快速的查询处理和良好的性能而闻名。 - **可靠性**：MySQL提供了多种机制来确保数据的完整性和可靠性，包括事务支持、备份和恢复功能。 - **易于使用**：MySQL提供了简单直观的界面和丰富的文档，便于用户学习和使用。 - **可扩展性**：MySQL支持从小型应用到大型企业级应用的扩展。 - **社区支持**：由于其广泛的使用，MySQL拥有一个活跃的开发者社区，提供大量的资源和支持。 MySQL被广泛应用于各种场景，包括在线事务处理（OL
Objective-C语言的基础教程.md
最新发布
07-31
Objective-C是一种面向对象的编程语言，是C语言的扩展。它主要用于苹果的iOS和macOS应用程序开发。
暂存暂存暂存暂存暂存暂存暂存暂存
07-31
暂存暂存暂存暂存暂存暂存暂存暂存
Java实现HTTP断点续传的多线程安全解决方法.zip
07-31
Java实现HTTP断点续传的多线程安全解决方法
数据库课程设计报告-宿舍信息管理系统.doc
07-31
系统要处理的对象包括宿舍楼基本信息、学生基本信息、宿舍基本信息、楼栋管理员基本信息、物品出入基本信息等五个方面，各个对象包括信息如下所示（详细的数据见于数据字典）： 1．学生基本信息(Student)：包括 学生编号、学生所在学院信息、学生姓名、学生性别、学生来自省份、学生出生日期、学生入学时间、学生所学专业、所在班级等方面的信息，可以方便学生信息的查询和更新； 2．宿舍楼基本信息(Dormitory)：包括 宿舍楼编号、每一幢宿舍楼楼管处的电话、宿舍楼楼管员信息、宿舍楼性别分类信息等方面，这样可以方便管理者对宿舍楼的管理，提高查询效率； 3．宿舍基本信息(Room)： 包括 宿舍编号、舍长信息、舍员信息、楼栋号； 4．楼栋管理员基本信息(Worker)：包括 工作人员编号、工作人员姓名、工作类型、工资、性别、联系方式、工作时间等数据项，可以方便管理人员对宿舍楼道工人的任用、信息查询及更改； 6．物品出入基本信息(ArticalInOut)：包括出入物品的学生信息、出入的物品信息、出入物品时的负责人信息、出入物品时间，尽量减少宿舍事故的发生，保障学生宿舍财产的安全。
Java面试经验、面试技巧、常见面试知识点整理。.zip
07-31
Java面试经验、面试技巧、常见面试知识点整理。
掌握单例模式与多线程安全实践
"单例模式详解深入解析" 在IT领域，单例模式...在IDEA环境下，熟练掌握多线程调试有助于更好地排查和优化单例模式的并发问题。掌握这些知识点将有助于提升技术面试的表现，增强项目开发中的代码质量和效率。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值