实践篇：如何编写线程安全的类

毕小宝2024-09-22 8:41

引言

本章节来聊聊线程安全类的实现方式，日常开发中读者可能都用过的，这里作一个简单的汇总。目前有几种常用的线程安全类的实现方式，悉数如下：

  1. 设计不变的类，如枚举类；
  2. 利用同步锁来保证线程操作的安全性，参考示例如何实现线程安全的单例类；
  3. 使用 ThreadLocal ，每个线程维护自己的复本数据，避免共享数据；

如何设计不变类

并发环境中，一个类如果是不变的，那么它一定就是线程安全的。这是设计模式中不变模式的一种：一个对象在创建之后，它的状态就不会再发生变化，它就是不变类。

Java 中的 String，各种基本类型的封装类型，都是不变类。在设计任何一个类的时候，应当慎重考虑其状态是否需要变化，如果其状态没有变化的必要，那么就应当将它设计成不变类。

设计不变的类，应该限制成员变量的操作，只提供 get 方法，且所有引用属性的访问都使用拷贝，避免直接与外界发生联系。一个简单的不变类编写如下：

typescript 复制代码 
import java.util.Date;

/**
 * 不可变对象定义，不提供set方法，避免外界对该对象属性进行修改
 * 对象中用到的引用类型，使用拷贝而非直接引用
 * 引用对象的get方法，也是提供拷贝
 */
public class ImmutableModel {
	private String name;
	private int age;
	private Date birthday;
	
	public ImmutableModel(String name,int age,Date birthday){
		this.name = name;
		this.age = age;
		//引用类型，使用拷贝，避免原对象的状态变化的影响
		if(birthday!=null){
			this.birthday = new Date(birthday.getTime());
		}
	}

	public String getName() {
		return name;
	}

	public int getAge() {
		return age;
	}

	//返回引用类型，也使用拷贝，避免外界直接拿到引用数据后修改造成的影响
	public Date getBirthday() {
		if(birthday!=null){
			return new Date(birthday.getTime());
		}
		return null;
	}
}

这个不变类一旦创建，它的状态就是恒定的，所以也是线程安全的。

单例模式的数据库连接管理类

单例，顾名思义，就是整个系统中，某个类的实例只有一个，这是一种设计模式，它可以保证系统中的重要资源类只能创建一个实例对象。艾迪生维斯理 1994 年对单例模式的描述为：

保证一个类仅有一个实例，并提供一个访问它的全局访问点。

单例模式的静态类图如下（引自百度百科）：

自定义单例模式的要点

  1. 构造函数私有化；
  2. 实例获取方法是线程安全的；
  3. 根据创建实例的时间不同，区分懒汉模式和饿汉模式。

单例类，由于全局只有一个实例，所以需要使用同步措施来保证单例对象操作的安全性。数据库连接池或者数据库连接等管理类，通常被设计为单例类。

SQLite 数据库的元数据存在在一个 .db 文件中，它在开启一个事务时，会将整个数据库文件锁定，因此并发环境下使用 SQLite 数据库需要警惕数据库被锁定的情况发生，将 SQLite 数据库操作类设计成单例、且线程安全的类，可以避免锁库异常。

这是 SqliteJdbcManager 单例实现方式：

csharp 复制代码 
    import java.sql.*;
	import java.util.List;

	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;

	/**
	 *  sqlite数据库管理实体类，单例模式设计，避免锁库异常
	 */
	public class SqliteJdbcManager {

		/**
		 *  数据库 Connection对象
		 */
		private Connection connection;
		
		/**
		 *  数据库 Statement对象
		 */
		private Statement statement;

		/**
		 * 定义单例实例，提供静态方法
		 */
		private static SqliteJdbcManager instance = null;

		/**
		 * 单例必须提供一个私有的构造函数
		 */
		private SqliteJdbcManager(){

		}

		/**
		 * 提供单例方法：懒汉模式
		 * @return
		 */
		public static SqliteJdbcManager getInstance(){
			if(instance == null ){
				synchronized (SqliteJdbcManager.class) {
					if (instance == null) {
						instance = new SqliteJdbcManager();
						return instance;
					}
				}
			}

			return instance;
		}

		/**
		 *  日志打印对象 
		 */
		private static Logger logger = LoggerFactory.getLogger(SqliteJdbcManager.class);
		
		
		/**
		 *  sqlite数据文件 
		 */
		private static String dataFile = SystemConstants.dataFilePath + "/monitor.db";
		
		/**
		 *  取得数据库连接 
		 */
		public synchronized Connection getConnection(){
			try {
				Class.forName("org.sqlite.JDBC");
				connection = DriverManager.getConnection("jdbc:sqlite:" + dataFile);
				connection.setAutoCommit(false);
			} catch (Exception e) {
				logger.error("取数据库连接异常", e);	
			}		
			
			return connection;
		}

		/**
		 *  执行数据库操作： 添加  更新  删除
		 */
		public synchronized int executeUpdate(String sql, List<Object> params){
			if(connection == null){
				connection = getConnection();
			}

			int result = 0;
			PreparedStatement statement = null;
			try {
				statement = connection.prepareStatement(sql);
				if(params!=null && params.size()>0){
					for(int i =1 ;i< params.size()+1;i++){
						statement.setObject(i,params.get(i-1));
					}
				}
				result = statement.executeUpdate();
				connection.commit();
			} catch (SQLException e) {
				logger.error("数据操作异常", e);
			}finally {
				if(statement != null ){
					try {
						statement.close();
					} catch (SQLException e) {
						logger.error("数据操作异常", e);
					}
				}
			}
			return result;
		}
		
		/**
		 *  关闭资源
		 */
		public synchronized void close(){
			if(statement != null){
				try {
					statement.close();
					statement = null;
				} catch (SQLException e) {
					logger.error("资源关闭异常", e);	
				}
			}
			
			if(connection != null){
				try {
					connection.close();
					connection = null;
				} catch (SQLException e) {
					logger.error("资源关闭异常", e);	
				}
			}
		}
	}

ThreadLocal 变量和普通变量的区别

Java 提供了 ThreadLocal 这个类型，具有该类型的成员变量，每个线程都可以保留一份它的复本数据，通过set方法设置；在线程内部用 get 方法获取自己备份的数据。

这个备份并不是 JVM 自己备份的，而是通过 ThreadLocal 的 set 方法完成的，它的本质是以当前线程的 Id 为 key ，存储该线程的数据。如果每个线程 set 的值都没有关联，那么这个成员的值肯定是线程安全的；但是如果两个线程在 set 时引用了同一个数据，那么就仍然会存在同步问题。

ThreadLocal 的本质是，每个线程只能获取到自己 set 的数据，它和普通成员的区别是：在多线程环境，每个线程都会存一个ThreadLocal 的值到自己的上下文环境，每个线程 get 到的都是自己 set 的复本数据，该类型的变量的数据在整个应用中有 N 份复本；而普通成员则被所有线程共享，是一份数据。

编写一个基于 ThreadLocal 的类，它同时含有两个成员变量，一个为普通类型，一个为 ThreadLocal 类型：

typescript 复制代码 
import java.util.Date;

public class MyThreadLocal {
	private ThreadLocal date = new ThreadLocal();
	private Date d = null;
	
	public void process(){
		if(date.get()==null){
			date.set(new Date());
			System.out.println("thread local fileld:"+date.get());
		}
	}
	//操作普通成员，需要同步处理
	public void p(){
		synchronized(MyThreadLocal.class){
			if(d==null){
				d = new Date();
				System.out.println("ordinary field:"+d);
			}
		}
	}
}

测试类：定义一个 MyThreadLocal 对象实例，由 5 个线程同时访问它的方法。

ini 复制代码 
import java.util.Date;

public class Test {
	public static void main(String[] args) {
		final MyThreadLocal t = new MyThreadLocal();
		for(int i = 0;i<5;i++){
			Thread thread = new Thread(){
				public void run(){
					t.process();
					t.p();
				}
			};
			thread.start();
		}
		Date d1 = new Date();
		Date d2 = new Date();
		System.out.println(d1==d2);
		System.out.println(d1.hashCode()==d2.hashCode());
	}
}

测试结果：

yaml 复制代码 
false
true
thread local fileld:Fri Apr 10 14:47:30 CST 2019
ordinary field:Fri Apr 10 14:47:31 CST 2019
thread local fileld:Fri Apr 10 14:47:30 CST 2019
thread local fileld:Fri Apr 10 14:47:30 CST 2019
thread local fileld:Fri Apr 10 14:47:30 CST 2019
thread local fileld:Fri Apr 10 14:47:30 CST 2019

测试结果分析：共享成员变量 d 只被一个线程初始化了一次，所以 p方法只执行了一次；而 ThreadLocal 类型的成员变量，每个访问该变量的线程都会自己创建一个副本数据，process 方法被执行了五次。

此外，还发现两次 new Date() 得到的对象的 hashCode 很容易相等，但的确是两个不同对象。

笔者本以为 ThreadLocal 的副本是对 set（Object） 传入的对象进行深拷贝后，存在对应线程的 value 中，测试发现自己对误解了。它的 set 仅仅仅是往全局 Map 中存了一个值，这是 set 操作的源码：

scss 复制代码 
    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

多个线程的 ThreadLocal 维护的是同一个数据时，这个值同样存在同步问题。即当多个线程 set 的是同一个引用时，还是需要留意同步问题。

相关推荐
郑祎亦10 分钟前
Spring Boot 项目 myblog 整理
spring boot·后端·java-ee·maven·mybatis
不是二师兄的八戒10 分钟前
本地 PHP 和 Java 开发环境 Docker 化与配置开机自启
java·docker·php
爱编程的小生22 分钟前
Easyexcel（2-文件读取）
java·excel
本当迷ya23 分钟前
💖2025年不会Stream流被同事排挤了┭┮﹏┭┮（强烈建议实操）
后端·程序员
带多刺的玫瑰39 分钟前
Leecode刷题C语言之统计不是特殊数字的数字数量
java·c语言·算法
计算机毕设指导61 小时前
基于 SpringBoot 的作业管理系统【附源码】
java·vue.js·spring boot·后端·mysql·spring·intellij-idea
Gu Gu Study1 小时前
枚举与lambda表达式，枚举实现单例模式为什么是安全的，lambda表达式与函数式接口的小九九~
java·开发语言
Chris _data1 小时前
二叉树oj题解析
java·数据结构
牙牙7051 小时前
Centos7安装Jenkins脚本一键部署
java·servlet·jenkins
paopaokaka_luck2 小时前
[371]基于springboot的高校实习管理系统
java·spring boot·后端
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07【目标跟踪】相机运动补偿08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10怎样让音频速度变慢？请跟随以下方法进行操作