Java多线程（七）单例模式与多线程 7.31

最新推荐文章于 2023-12-10 17:31:58 发布
最新推荐文章于 2023-12-10 17:31:58 发布
阅读量116 收藏
点赞数
分类专栏： Java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zyl042/article/details/97925605
版权

立即加载/饿汉模式：

public class MyObject {
//立即加载方式 == 饿汉模式
	private static MyObject myObject = new MyObject();
	private MyObject() {
		
	}
	public static MyObject getInstance() {
		return myObject;
	}
}
public class MyThread extends Thread{
	public void run() {
		System.out.println(MyObject.getInstance().hashCode());
	}
}
public class Run {
	public static void main(String[] args) {
		MyThread t1 = new MyThread();
		MyThread t2 = new MyThread();
		MyThread t3 = new MyThread();
		t1.start();
		t2.start();
		t3.start();
	}
}

延迟加载/懒汉模式：


public class MyObject {
//延迟加载方式 == 懒汉模式
	private static MyObject myObject ;
	private MyObject() {
	}
	public static MyObject getInstance() {
		if (myObject != null) {
		} else {
			myObject = new MyObject();
		}
		return myObject;
	}
}
public class Run {
	public static void main(String[] args) {
		MyThread t1 = new MyThread();
		t1.start();
	}
}
public class MyThread extends Thread{
	public void run() {
		System.out.println(MyObject.getInstance().hashCode());
	}
}

立即加载  就是使用类的时候已经将对象创建完毕，常见的实现办法就是直接new实例化；

延迟加载  就是在调用get（）方法时才被创建，常见的实现办法就是在get（）方法中进行new实例化。

延迟加载 的解决方案：（在多线程中无法保持单例）

（1）声明synchronized

（2）尝试代码同步块

（3）针对某些重要的代码进行单独的同步

public class MyObject {
//延迟加载方式 == 懒汉模式
	private static MyObject myObject = new MyObject();
	private MyObject() {
	}
	//设置同步方法效率太低了
	//整个方法被上锁
	//同步代码块，效率也比较低
	//针对某些重要得代码进行单独的同步；
	public static MyObject getInstance() {
		try {
			if (myObject != null) {
			} else {
				Thread.sleep(3000);
				synchronized (MyObject.class) {
					myObject = new MyObject();
				}
			}
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return myObject;
	}
}
public class MyThread extends Thread{
	public void run() {
		System.out.println(MyObject.getInstance().hashCode());
	}
}
public class Run {
	public static void main(String[] args) {
		MyThread t1 = new MyThread();
		MyThread t2 = new MyThread();
		MyThread t3 = new MyThread();
		t1.start();
		t2.start();
		t3.start();
	}
}

（4）使用DCL双检查锁机制

public class MyObject {
//延迟加载方式 == 懒汉模式
	private static MyObject myObject = new MyObject();
	private MyObject() {
	}
	//使用双检测机制来解决问题，既保证了不需要同步代码的异步执行性，又保证了单例的效果；
	public static MyObject getInstance() {
		try {
			if (myObject != null) {
			} else {
				Thread.sleep(3000);
				synchronized (MyObject.class) {
					if (myObject == null) {
						myObject = new MyObject();
					}
				}
			}
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return myObject;
	}
}

public class MyThread extends Thread{
	public void run() {
		System.out.println(MyObject.getInstance().hashCode());
	}
}

public class Run {
	public static void main(String[] args) {
		MyThread t1 = new MyThread();
		MyThread t2 = new MyThread();
		MyThread t3 = new MyThread();
		t1.start();
		t2.start();
		t3.start();
	}
}

使用静态内部类实现单例模式：

public class MyObject {
//延迟加载方式 == 懒汉模式
	//内部类方式
	private static class MyObjectHandler{
		private static MyObject myObject = new MyObject();
	}
	
	private MyObject() {
	}
	
	public static MyObject getInstance() {
		return MyObjectHandler.myObject;
	}
}

public class MyThread extends Thread{
	public void run() {
		System.out.println(MyObject.getInstance().hashCode());
	}
}
public class Run {
	public static void main(String[] args) {
		MyThread t1 = new MyThread();
		MyThread t2 = new MyThread();
		MyThread t3 = new MyThread();
		t1.start();
		t2.start();
		t3.start();
	}
}

序列化与反序列化的单例模式实现：

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SaveAndRead {
	public static void main(String[] args) {
		
		try {
			MyObject myObject = MyObject.getInstance();
			FileOutputStream fosRef = new FileOutputStream(new File("myObjectFile.txt"));
			ObjectOutputStream oosRef = new ObjectOutputStream(fosRef);
			oosRef.writeObject(myObject);
			oosRef.close();
			fosRef.close();
			System.out.println(myObject.hashCode());
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		try {
			FileInputStream fisRef = new FileInputStream(new File("myObjectFile.txt"));
			ObjectInputStream iosRef = new ObjectInputStream(fisRef);
			MyObject myObject = (MyObject) iosRef.readObject();
			iosRef.close();
			fisRef.close();
			System.out.println(myObject.hashCode());
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

import java.io.ObjectStreamException;
import java.io.Serializable;

public class MyObject implements Serializable{
//序列化与反序列化的单例模式的实现
	private static final long serialVersiouUID = 888L;
	private static class MyObjectHandler{
		private static MyObject myObject = new MyObject();
	}
	
	private MyObject() {
	}
	
	public static MyObject getInstance() {
		return MyObjectHandler.myObject;
	}
	protected Object readResolve() throws ObjectStreamException{
		System.out.println("调用了readResolve方法");
		return MyObjectHandler.myObject;
	}
}

使用static代码块实现单例模式：


public class MyObject {
//使用static代码块实现单例模式
	private static MyObject instance = null;
	private MyObject() {
	}
	static {
		instance = new MyObject();
	}
	public static MyObject getInstance() {
		return instance;
	}
}
public class MyThread extends Thread{
	public void run() {
		for (int i = 0; i < 5; i++) {
			System.out.println(MyObject.getInstance().hashCode());
		}
	}
}
public class Run {
	public static void main(String[] args) {
		MyThread t1 = new MyThread();
		MyThread t2 = new MyThread();
		MyThread t3 = new MyThread();
		t1.start();
		t2.start();
		t3.start();
	}
}

使用enum枚举数据类型实现单例模式：


import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class MyObject {
	//使用enum枚举数据类型实现单例模式
	//将枚举类进行暴露，违反了“职责单一原则”
	//完善使用enum枚举数据类型实现单例模式
	public enum MyEnumSingleton{
		connectionFactory;
		private Connection connection;

		private MyEnumSingleton() {

			try {
				System.out.println("调用了MyObject的构造");
				String url = "";
				String username = "";
				String password = "";
				String driverName = "";
				Class.forName(driverName);
				connection = DriverManager.getConnection(url, username, password);
			} catch (ClassNotFoundException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

		}


		public Connection getConnection() {
			return connection;
		}
	}
	public static Connection getConnection() {
		return MyEnumSingleton.connectionFactory.getConnection();
	}

}

public class MyThread extends Thread{
	public void run() {
		for (int i = 0; i < 5; i++) {
			System.out.println(MyObject.getConnection().hashCode());
		}
	}
	
}
public class Run {
	public static void main(String[] args) {
		MyThread t1 = new MyThread();
		MyThread t2 = new MyThread();
		MyThread t3 = new MyThread();
		t1.start();
		t2.start();
		t3.start();
	}
}

 

构建新一代的K8s原生Java微服务+Quarkus实战
Java 技术专栏，从入门到精通，熟悉企业级开发
10-18 2万+
过去几年来，Quarkus 作为一种微服务开发框架大为流行，而Eclipse MicroProfile 也持续演进成一组Java 微服务开发API。本书详细介绍如何基于MicroProfile 和Spring API新建、开发和调试Quarkus 微服务，并部署到Kubernetes 上。 除了微服务的开发和部署，本书还涵盖Kubernetes 微服务的其他方方面面，比如应用健康管理、监控、可观测性、安全性以及API 可视化。
线程安全(2)--多线程逸出分析和正确处理
weixin_30369087的博客
10-30 71
多线程溢出写法： public class ThisEscape { public ThisEscape(EventSource source) { source.registerListener(new EventListener() { public void onEvent(Event e) { ...
mysql jdbc 单利_java多线程(一)——线程安全的单例模式
weixin_39943370的博客
01-27 212
概念：java中单例模式是一种常见的设计模式，单例模式分三种：懒汉式单例、饿汉式单例、登记式单例三种。单例模式有一下特点：1、单例类只能有一个实例。2、单例类必须自己创建自己的唯一实例。3、单例类必须给所有其他对象提供这一实例。单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都...
java 常用设计模式学习笔记
qq_38022739的博客
07-11 974
设计模式学习笔记1、23种设计模式概述 1、23种设计模式概述 1. 简单工厂 提供一个创建对象实例的功能，而无需关心其具体实现。被创建实例的类型可以是接口、抽象类，也可以是具体的类。 2. 外观模式（结构型） 为子系统中的一组接口提供一个一致的页面，Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用 3. 适配器模式（结构型） 为一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 4. 单例模式（创建型） 保证一个类仅有一个实
Java初级工程师面试题
_山月见光的博客
11-17 785
Spring MVC 拦截器是一种可以拦截请求的组件，它可以在请求到达 Controller 之前或者之后执行一些操作，比如日志记录、权限检查、国际化处理等。拦截器可以用于对请求进行预处理和后处理，而不影响 Controller 的实际处理过程。创建拦截器类：首先需要创建一个类，实现 Spring MVC 提供的 HandlerInterceptor 接口，该接口包括了三个方法：preHandle、postHandle 和 afterCompletion。根据需求重写这些方法，在请求处理前后执行相应的逻辑。
java每日一练：面试题集合
不放手，不错过的博客
07-12 5798
工作日每天一个小知识点回顾，加深理解，增强表达能力
2021年 秋招面试记录
Kunaly
01-08 560
2021年 春招面试记录 提前批： 招银网络：笔试凉 vivo: 简历凉 Tplink: 简历凉 同花顺：笔试凉 字节跳动：一面凉 投错了 大华 HR 面 京东 简历没过 蔚来 8.23 收到 意向书 拼多多 简历 中止 商汤科技 简历凉 滴滴（？？？） 端点 面完 7.26 shoppe： 简历凉 虎牙直播 https://app.mokahr.com/m/candidate/applications/deliver-query/huya 希音SHEIN Zoo
MyBatis的核心配置(第七章)
weixin_51237324的博客
06-25 542
最详细的Spring框架学习笔记
lfTechの博客
12-15 824
Spring 1、Spring 框架体系结构 1.1 Core Container(核心容器) 核心容器由 spring-core，spring-beans，spring-context，spring-context-support和spring-expression（SpEL，Spring 表达式语言，Spring Expression Language）等模块组成 导入的jar包： spring-beans-5.0.2.RELEASE.jar spring-core-5.0.2.RELEASE.jar
文章收录1
热门推荐
ithome
08-02 1万+
3.Hive Metastore 代码简析 4.受限的玻尔兹曼机 5.以公司实际应用讲解OpenStack到底是什么 6.Ubuntu12.04安装hadoop 7.vpsmate安装完再重启服务器，vpsmate不无再次打开的解决方法 8.如何使用JDBC快速处理大数据 9.关于集群技术的几个新工具的介绍 10.CHD4 impa...
WinScan2PDF 7.31
最新发布
09-04
此工具支持扫描多张保存为1个PDF文件，支持扫描多张选其中一个保存位PDF文件，支持扫描单个保存位单个PDF文件，另外还支持保存位JPG图片和PNG图片； 仅提供程序资源，不提供任何技术支持，请知悉。包内不含任何...
nuttx-7.31.tar.gz_nuttx-7.31源码_虚拟机跑px4
09-22
标题中的“nuttx-7.31.tar.gz”是一个压缩文件，它包含了NuttX操作系统的一个特定版本——7.31。NuttX是一个实时操作系统（RTOS），它被广泛用于嵌入式系统，特别是那些对资源有限且需要高效运行时间性能的设备。这...
7.25~7.31.txt
08-23
7.25~7.31.txt
（万字长文）C语言多线程之threads函数库
wozuishuai_的博客
12-10 1181
这个函数将会创建一个运行func函数的线程，在thrd_create(3)函数里，arg将会作为func函数的参数。如果线程创建成功，thr指向的对象将被设置为所创建线程的标识符。这个函数完成的同时，所创建的线程将开始。
Java基础学习（八）其他内容 Swing中 按钮的 点击和回车确认问题
zyl042的博客
07-08 750
import java.awt.BorderLayout; import java.awt.EventQueue; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import javax.swing.JButton; import javax.swing.JFrame; import jav...
Java基础学习（八）Swing和NetBeans的使用 2019.7.5
zyl042的博客
07-05 731
NetBeans是Sun公司（2009年被甲骨文收购）在2000年创立的开放源代码供开发人员和客户社区的家园，旨在构建世界级的Java IDE。NetBeans当前可以在Solaris、Windows、Linux和Macintosh OS X平台上进行开发，并在SPL(Sun公用许可)范围内使用。 NetBeans包括开源的开发环境和应用平台，NetBeans IDE可以使开发人员利用Java平台...
Java基础学习（三）2019.6.27
zyl042的博客
06-30 705
9.抽象类 <访问符> abstract class 类名 { [访问符] abstract<返回类型> 方法名([参数列表])； ...... } 注意：1）abstract放在class前，指明该类是抽象类； 2）abstract放在方法声明中，则该方法是抽象方法，抽象方法没有方法体； 3）一个抽象类至少含有一个抽象类，可以含有多个抽...
复选框工具8.7——Needleman Wusch算法全局比对
zyl042的博客
08-07 667
Needleman Wusch算法 是经典的全局比对算法，用于比对两条DNA序列或者蛋白质序列的同源性或者说相似性； 全局序列比对： 尝试找到两个完整的序列 S1 和 S2 之间的最佳比对。如S1=GCCCTAGCG S2=GCGCAATG 如果设定每个匹配字符为1分，每个空格为-2分，每个不匹配为-1分，则下面的比对就是全局最优比对：S1'=GCCCTAGCG S2'=GCGC_AATG...
在虚拟机中运行px4：nuttx-7.31源码编译与烧写指南
4. 编译与烧写过程：在文档中提到使用NuttX-7.31源码在虚拟机环境中进行编译烧写，这个过程包括准备编译环境、配置NuttX源码、编译生成固件、将固件烧写到目标开发板等步骤。这些步骤通常需要一定的嵌入式系统开发...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值