事务的四种特性

最新推荐文章于 2024-08-21 16:30:56 发布
最新推荐文章于 2024-08-21 16:30:56 发布
阅读量4.7w 收藏 48
点赞数 8
分类专栏： java基础 文章标签： jdbc 事务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangsweet1991/article/details/83894268
版权

什么是事务:
数据库事务是指作为单个逻辑工作单元执行的一系列操作（SQL语句）。这些操作要么全部执行，要么全部不执行。
为什么需要事务
经典的银行转账行为，A账户转给B账户10元，数据库操作需要两步，第一步A账户减10元，第二步B账户加10元，如果没有事务并且在两步中间发生异常，就会导致A的账户少了10元，但B的账户没有变化，如果不能保证这两步操作统一，银行的转账业务也没法进行展开了。
事务管理是每个数据库（oracle、mysql、db等）都必须实现的。
事务特性（4种）:

  1. 原子性 （atomicity）:强调事务的不可分割.
  2. 一致性 （consistency）:事务的执行的前后数据的完整性保持一致.
  3. 隔离性 （isolation）:一个事务执行的过程中,不应该受到其他事务的干扰
  4. 持久性（durability） :事务一旦结束,数据就持久到数据库

事务运行模式（3种）

  1. 自动提交事务：默认事务管理模式。如果一个语句成功地完成，则提交该语句；如果遇到错误，则回滚该语句。
  2. 显式事务：以BEGIN TRANSACTION显式开始，以COMMIT或ROLLBACK显式结束。
  3. 隐性事务：当连接以此模式进行操作时，sql将在提交或回滚当前事务后自动启动新事务。无须描述事务的开始，只需提交或回滚每个事务。它生成连续的事务链。

下面做一个事务的示例：
JDBC用了Druid连接池
1、maven引包

	<!--mysql驱动包 -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.47</version>
		</dependency>
		<!--druid连接池 -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
			<version>1.1.10</version>
		</dependency>

2、数据库设计

CREATE TABLE `account` (
  `userid` varchar(64) NOT NULL,
  `username` varchar(64) NOT NULL,
  `accountbalance` decimal(10,2) NOT NULL DEFAULT '0.00',
  `createtime` datetime DEFAULT NULL,
  `updatetime` datetime DEFAULT NULL,
  PRIMARY KEY (`userid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

INSERT INTO `account` VALUES ('1001', '张三', '1000.00', '2018-11-09 09:39:52', '2018-11-09 09:39:55');

INSERT INTO `account` VALUES ('1002', '李四', '1000.00', '2018-11-09 09:40:12', '2018-11-09 09:40:14');

完成后的样子

3、建立jdbc.properties

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/zhd?useUnicode=true&characterEncoding=UTF-8&InnoDB=true&useSSL=false
username=root
password=123456

4、建立连接池工具类DBPoolConnection

import java.io.InputStream;
import java.sql.SQLException;
import java.util.Properties;

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

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import com.alibaba.druid.pool.DruidPooledConnection;

public class DBPoolConnection {
	static Logger log = LoggerFactory.getLogger(DBPoolConnection.class);
	private static DBPoolConnection dbPoolConnection = null;
	private static DruidDataSource druidDataSource = null;

	static {
		Properties properties = loadPropertiesFile("jdbc.properties");
		try {
			druidDataSource = (DruidDataSource) DruidDataSourceFactory.createDataSource(properties); // DruidDataSrouce工厂模式
		} catch (Exception e) {
			log.error("获取配置失败");
		}
	}

	/**
	 * @param string 配置文件名
	 * @return Properties对象
	 */
	private static Properties loadPropertiesFile(String fullFile) {
		if (null == fullFile || fullFile.equals("")) {
			throw new IllegalArgumentException("Properties file path can not be null" + fullFile);
		}
		InputStream inputStream = null;
		Properties p = null;
		try {
			ClassLoader cl = DBPoolConnection.class.getClassLoader();
			inputStream = cl.getResourceAsStream(fullFile);
			p = new Properties();
			p.load(inputStream);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				if (null != inputStream) {
					inputStream.close();
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return p;
	}

	/**
	 * 数据库连接池单例
	 * 
	 * @return
	 */
	public static synchronized DBPoolConnection getInstance() {
		if (null == dbPoolConnection) {
			dbPoolConnection = new DBPoolConnection();
		}
		return dbPoolConnection;
	}

	/**
	 * 返回druid数据库连接
	 * 
	 * @return
	 * @throws SQLException
	 */
	public DruidPooledConnection getConnection() throws SQLException {
		return druidDataSource.getConnection();
	}
}

5、建立JDBCUtil工具类

import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

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

/**
 * 对jdbc的完整封装
 *
 */
public class JDBCUtil {

	public static Logger log = LoggerFactory.getLogger(JDBCUtil.class);

	/**
	 * insert update delete SQL语句的执行的统一方法
	 * 
	 * @param sql SQL语句
	 * @param params 参数数组，若没有参数则为null
	 * @return 受影响的行数
	 */
	public int executeUpdate(String sql, Object... params) {
		// 受影响的行数
		int affectedLine = 0;
		// 创建ResultSetMetaData对象
		Connection conn = null;
		PreparedStatement pst = null;
		try {
			// 获得连接
			conn = DBPoolConnection.getInstance().getConnection();
			// 调用SQL
			pst = conn.prepareStatement(sql);

			// 参数赋值
			if (params != null) {
				for (int i = 0; i < params.length; i++) {
					pst.setObject(i + 1, params[i]);
				}
			}
			/*
			 * 在此 PreparedStatement 对象中执行 SQL 语句， 该语句必须是一个 SQL 数据操作语言（Data
			 * Manipulation Language，DML）语句，比如 INSERT、UPDATE 或 DELETE
			 * 语句；或者是无返回内容的 SQL 语句，比如 DDL 语句。
			 */
			// 执行
			affectedLine = pst.executeUpdate();

		} catch (SQLException e) {
			System.out.println(e.getMessage());
		} finally {
			// 释放资源
			closeAll(conn, pst, null);
		}
		return affectedLine;
	}

	/**
	 * insert update delete SQL语句的执行的统一方法
	 * 
	 * @param sql SQL语句
	 * @param params 参数数组，若没有参数则为null
	 * @return 受影响的行数
	 */
	public int executeUpdate(Connection conn, String sql, Object... params) {
		// 受影响的行数
		int affectedLine = 0;
		// 创建ResultSetMetaData对象
		PreparedStatement pst = null;
		try {
			// 获得连接
			// 调用SQL
			pst = conn.prepareStatement(sql);

			// 参数赋值
			if (params != null) {
				for (int i = 0; i < params.length; i++) {
					pst.setObject(i + 1, params[i]);
				}
			}
			/*
			 * 在此 PreparedStatement 对象中执行 SQL 语句， 该语句必须是一个 SQL 数据操作语言（Data
			 * Manipulation Language，DML）语句，比如 INSERT、UPDATE 或 DELETE
			 * 语句；或者是无返回内容的 SQL 语句，比如 DDL 语句。
			 */
			// 执行
			affectedLine = pst.executeUpdate();

		} catch (SQLException e) {
			System.out.println(e.getMessage());
		} finally {
			// 释放资源
			 close(pst);
		}
		return affectedLine;
	}

	/**
	 * 获取结果集，并将结果放在List中
	 * 
	 * @param sql SQL语句 params 参数，没有则为null
	 * @return List 结果集
	 */
	public List<Map<String, Object>> excuteQuery(String sql, Object... params) {
		// 创建ResultSetMetaData对象
		ResultSetMetaData rsmd = null;
		Connection conn = null;
		PreparedStatement pst = null;
		ResultSet rst = null;
		// 创建List
		List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
		try {
			conn = DBPoolConnection.getInstance().getConnection();
			// 调用SQL
			pst = conn.prepareStatement(sql);
			// 参数赋值
			if (params != null) {
				for (int i = 0; i < params.length; i++) {
					pst.setObject(i + 1, params[i]);
				}
			}
			// 执行
			rst = pst.executeQuery();
			rsmd = rst.getMetaData();
			// 获得结果集列数
			int columnCount = rsmd.getColumnCount();
			// 将ResultSet的结果保存到List中
			while (rst.next()) {
				Map<String, Object> map = new HashMap<String, Object>();
				for (int i = 1; i <= columnCount; i++) {
					map.put(rsmd.getColumnLabel(i), rst.getObject(i));
				}
				list.add(map);// 每一个map代表一条记录，把所有记录存在list中
			}

		} catch (SQLException e1) {
			System.out.println(e1.getMessage());
		} finally {
			// 关闭所有资源
			closeAll(conn, pst, rst);
		}
		return list;
	}

	/**
	 * 关闭所有资源
	 */
	private void closeAll(Connection conn, PreparedStatement pst, ResultSet rst) {
		// 关闭结果集对象
		if (rst != null) {
			try {
				rst.close();
			} catch (SQLException e) {
				System.out.println(e.getMessage());
			}
		}

		// 关闭PreparedStatement对象
		if (pst != null) {
			try {
				pst.close();
			} catch (SQLException e) {
				System.out.println(e.getMessage());
			}
		}

		// 关闭Connection 对象
		if (conn != null) {
			try {
				conn.close();
			} catch (SQLException e) {
				System.out.println(e.getMessage());
			}
		}
	}

	/**
	 * 关闭所有资源
	 */
	public void close(AutoCloseable autoCloseable) {
		if (autoCloseable != null) {
			try {
				autoCloseable.close();
			} catch (Exception e) {
				System.out.println(e.getMessage());
			}
		}
	}

	/**
	 * 通过反射机制查询单条记录
	 * 
	 * @param sql
	 * @param params
	 * @param cls
	 * @return
	 * @throws Exception
	 */
	public <T> T findSimpleRefResult(String sql, Class<T> cls, Object... params) {
		T resultObject = null;
		int index = 1;
		Connection conn = null;
		PreparedStatement pst = null;
		ResultSet rst = null;
		try {
			conn = DBPoolConnection.getInstance().getConnection();
			pst = conn.prepareStatement(sql);
			if (params != null) {
				for (int i = 0; i < params.length; i++) {
					pst.setObject(index++, params[i]);
				}
			}
			rst = pst.executeQuery();
			ResultSetMetaData metaData = rst.getMetaData();
			int cols_len = metaData.getColumnCount();
			while (rst.next()) {
				// 通过反射机制创建一个实例
				resultObject = cls.newInstance();
				for (int i = 0; i < cols_len; i++) {
					String cols_name = metaData.getColumnName(i + 1);
					Object cols_value = rst.getObject(cols_name);
					if (cols_value == null) {
						cols_value = "";
					}
					try {
						Field field = cls.getDeclaredField(cols_name.toLowerCase());
						field.setAccessible(true); // 打开javabean的访问权限
						field.set(resultObject, cols_value);
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			closeAll(conn, pst, rst);
		}
		return resultObject;

	}

	/**
	 * 通过反射机制查询多条记录
	 * 
	 * @param sql
	 * @param params
	 * @param cls
	 * @return
	 * @throws Exception
	 */
	public <T> List<T> findMoreRefResult(String sql, Class<T> cls, Object... params) {
		List<T> list = new ArrayList<T>();
		int index = 1;
		Connection connection = null;
		PreparedStatement pstmt = null;
		ResultSet resultSet = null;
		try {
			connection = DBPoolConnection.getInstance().getConnection();
			pstmt = connection.prepareStatement(sql);
			if (params != null) {
				for (int i = 0; i < params.length; i++) {
					pstmt.setObject(index++, params[i]);
				}
			}
			resultSet = pstmt.executeQuery();
			ResultSetMetaData metaData = resultSet.getMetaData();
			int cols_len = metaData.getColumnCount();
			while (resultSet.next()) {
				// 通过反射机制创建一个实例
				T resultObject = cls.newInstance();
				for (int i = 0; i < cols_len; i++) {
					String cols_name = metaData.getColumnName(i + 1);
					Object cols_value = resultSet.getObject(cols_name);
					if (cols_value == null) {
						cols_value = "";
					}
					try {
						Field field = cls.getDeclaredField(cols_name.toLowerCase());
						field.setAccessible(true); // 打开javabean的访问权限
						field.set(resultObject, cols_value);
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
				list.add(resultObject);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			closeAll(connection, pstmt, resultSet);
		}
		return list;
	}

	/**
	 * 通过反射机制查询多条记录
	 * 
	 * @param sql
	 * @param params
	 * @param cls
	 * @return
	 * @throws Exception
	 */
	public List<String> findMoreRefResult(String sql, Object... params) {
		List<String> list = new ArrayList<String>();
		int index = 1;
		Connection connection = null;
		PreparedStatement pstmt = null;
		ResultSet resultSet = null;
		try {
			connection = DBPoolConnection.getInstance().getConnection();
			pstmt = connection.prepareStatement(sql);
			if (params != null) {
				for (int i = 0; i < params.length; i++) {
					pstmt.setObject(index++, params[i]);
				}
			}
			resultSet = pstmt.executeQuery();
			while (resultSet.next()) {
				// 通过反射机制创建一个实例
				String cols_value = resultSet.getString(1);
				list.add(cols_value);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			closeAll(connection, pstmt, resultSet);
		}
		return list;
	}

	/**
	 * SQL 查询将查询结果：一行一列
	 * 
	 * @param sql SQL语句
	 * @param params 参数数组，若没有参数则为null
	 * @return 结果集
	 */
	public Object executeQuerySingle(String sql, Object... params) {
		Connection conn = null;
		PreparedStatement pst = null;
		ResultSet rst = null;
		Object object = null;
		try {
			// 获得连接
			conn = DBPoolConnection.getInstance().getConnection();
			// 调用SQL
			pst = conn.prepareStatement(sql);
			// 参数赋值
			if (params != null) {
				for (int i = 0; i < params.length; i++) {
					pst.setObject(i + 1, params[i]);
				}
			}
			// 执行
			rst = pst.executeQuery();
			if (rst.next()) {
				object = rst.getObject(1);
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			closeAll(conn, pst, rst);
		}

		return object;
	}

}

5、进行测试：

正常情况下：

public class JDBCTest {
	public static void main(String[] args) {
		JDBCUtil jdbcUtil = new JDBCUtil();
		Connection conn = null;
		try {
			conn = DBPoolConnection.getInstance().getConnection();
			conn.setAutoCommit(false);
			String sql_1 = "update account set accountbalance = accountbalance + ? where userid = ?";
			String sql_2 = "update account set accountbalance = accountbalance - ? where userid = ?";
			int line_1 = jdbcUtil.executeUpdate(conn, sql_1, 10, "1001");
			int line_2 = jdbcUtil.executeUpdate(conn, sql_2, 10, "1002");
			conn.commit();
		} catch (SQLException e) {
			try {
				conn.rollback();
			} catch (SQLException e1) {
				e1.printStackTrace();
			}
			e.printStackTrace();
		} finally {
			jdbcUtil.close(conn);
		}
	}
}

运行前：
在这里插入图片描述
运行后：
在这里插入图片描述

异常情况下：

public class JDBCTest {
	public static void main(String[] args) {
		JDBCUtil jdbcUtil = new JDBCUtil();
		Connection conn = null;
		try {
			conn = DBPoolConnection.getInstance().getConnection();
			conn.setAutoCommit(false);
			String sql_1 = "update account set accountbalance = accountbalance + ? where userid = ?";
			String sql_2 = "update account set accountbalance = accountbalance - ? where userid = ?";
			int line_1 = jdbcUtil.executeUpdate(conn, sql_1, 10, "1001");
			if (line_1 == 1) {
				throw new RuntimeException();
			}
			int line_2 = jdbcUtil.executeUpdate(conn, sql_2, 10, "1002");
			conn.commit();
		} catch (SQLException e) {
			try {
				conn.rollback();
			} catch (SQLException e1) {
				e1.printStackTrace();
			}
			e.printStackTrace();
		} finally {
			jdbcUtil.close(conn);
		}
	}
}

运行前：
在这里插入图片描述

运行后：
在这里插入图片描述

haodong1024
关注
专栏目录
事务的特性
Ajaxtxdy的博客
08-15 490
1.事务的四大特性（ACID） 原子性(Atomicity):事务是一个不可分割的单位，事务中的每一个单元都必须同时成功或失败。 一致性(Consistency):事务修改数据前后，数据库中的数据完整性仍然保持一致。 隔离性(Isolation):数据库中的一个事务，可能被其他事务的影响，为了避免这种影响，数据提供一些隔离级别的选项，让用户自行选择隔离别。 持久性(Durability):一旦数据库的事务提交，数据就会发生永久性的改变，任何操作都无法撤销这个过程，即使数据库损毁也不能恢复到原有数据内容。 a
理解事务——原子性、一致性、隔离性和持久性
热门推荐
架构师专栏
08-17 6万+
介绍事务的ACID特性
事务的4大特性、事务隔离级别、事务传播行为
weixin_54401017的博客
03-16 1420
另一方面, PROPAGATION_NESTED 开始一个 “嵌套的” 事务, 它是已经存在事务的一个真正的子事务. 潜套事务开始执行时, 它将取得一个 savepoint. 如果这个嵌套事务失败, 我们将回滚到此 savepoint. 潜套事务是外部事务的一部分, 只有外部事务结束后它才会被提交。（一事务写时禁止其他事务读写、一事务读时禁止其他事务读写）使用 PROPAGATION_REQUIRES_NEW时，内层事务与外层事务就像两个独立的事务一样，一旦内层事务进行了提交后，外层事务不能对其进行回滚。
数据库事务，全局锁、表锁、行锁详解
最新发布
精神小牛马
08-21 893
数据库事务（Database Transaction）是数据库管理系统执行过程中的一个逻辑单位，由一系列对数据的操作组成。事务是数据库维护数据一致性、完整性和原子性的重要机制。以下是数据库事务的几个关键特性，通常被称为ACID属性原子性（Atomicity）： 事务中的所有操作要么全部完成，要么全部不完成，不会结束在中间某个点。如果事务中的某个操作失败，整个事务将被回滚到开始状态，就像这个事务从未发生过一样。一致性（Consistency）： 事务必须保证数据库从一个一致的状态转移到另一个一致的状态。在事务
事务的ACID
lbx1314ybfq的专栏
08-31 923
事务具有4个特征，分别是原子性、一致性、隔离性和持久性，简称事务的ACID特性； 一、原子性（atomicity) 一个事务要么全部提交成功，要么全部失败回滚，不能只执行其中的一部分操作，这就是事务的原子性 二、一致性（consistency) 事务的执行不能破坏数据库数据的完整性和一致性，一个事务在执行之前和执行之后，数据库都必须处于一致性状态。 如果数据库系统在运行过程中发生故障，有...
事务的特征
qq_45754346的博客
05-05 1037
事务有四大特征： 1.原子性： 事务被当成一个最小的执行单位，运行事务中的某些sql语句单独执行，要么事务中的sql语句全部执行成功，要么全部失败，也就是事务失败。 2.一致性： 事务的执行不能破坏数据库的完整性和一致性 3.持久性：事务一旦提交或者rollback，数据就无法返回，已经被持久的存储在数据库中了 4.隔离性：不同事务之间有隔离性，根据隔离级别的不同，事务与事务之间执行过程中所造成的数据的影响也不同 ps：补充隔离级别的不同，因数据的变化造成事务与事务之间的影响： （read
记：事务的四个特性
*~~~~~向日葵、的眼里只有【太阳】
09-25 808
今天在3G班上课老师提问了，事务的特性 。可是都不会。！   加强记忆一下吧！   1、一致性：将事务中所做的操作捆绑成一个原子单元，即对于事务所进行的数据修改等操作，要么全部执行，要么全部不执行。 2、原子性：事务在完成时，必须使所有的数据都保持一致状态，而且在相关数
浅谈数据库事务四大特性
09-09
下面将详细阐述这四个特性。 **原子性** 原子性是指事务中的每个操作要么全部成功，要么全部失败，不允许部分完成。如果在事务执行过程中发生错误，系统将回滚事务，使得数据库状态保持不变。例如，一个转账操作...
【数据库】— 事务的四个特性
12-14
事务的四个特性，也被称为ACID（Atomicity, Consistency, Isolation, Durability），是数据库管理系统设计的基础。 一、原子性（Atomicity） 原子性是指事务中的操作被视为一个不可分割的整体，这些操作要么全部...
关系型数据库的事务之四大特性
wuyangcc的博客
03-11 5788
数据库系统必须维护事务的以下特性(简称ACID)：   原子性(Atomicity)   一致性(Consistency)   隔离性(Isolation)   持久性(Durability) ⑴ 原子性（Atomicity） 　　原子性是指事务包含的所有操作要么全部成功，要么全部失败回滚，因此事务的操作如果...
深入学习MySQL事务：ACID特性的实现原理
02-24
本文将首先介绍MySQL事务相关的基础概念，然后介绍事务的ACID特性，并分析其实现原理。MySQL博大精深，文章疏漏之处在所难免，欢迎批评指正。事务（Transaction）是访问和更新数据库的程序执行单元；事务中可能包含...
【MySQL —— 事务】四大特性、隔离级别
AlinaQ05的博客
08-06 1119
事务诞生的目的就是为了把若干个独立的操作打包成一个整体，这样的一组操作，要么全都执行，要么都不执行。事务是一个不可分割的数据库操作序列，也是数据库并发控制的基本单位。
什么是事务,事务的四个特性是什么
像风一样自由
10-11 2万+
一．什么是事务事务是应用程序中一系列严密的操作，所有操作必须成功完成，否则在每个操作中所作的所有更改都会被撤消。也就是事务具有原子性，一个事务中的一系列的操作要么全部成功，要么一个都不做。事务的结束有两种，当事务中的所以步骤全部成功执行时，事务提交。如果其中一个步骤失败，将发生回滚操作，撤消撤消之前到事务开始时的所以操作。 二．事务的 ACID事务具有四个特征：原子性（ Atomicity ）、一
事务的四个特征
m0_51649818的博客
08-28 359
文章目录一、什么是事务二、事务的特征1、原子性（Atomicity）2、一致性（Consistency）3、隔离性（Isolation）4、持续性（Durability） 一、什么是事务 事务（Transaction）是并发控制单位，是用户定义的一个操作序列，这些操作要么都做，要么都不做，是一个不可分割的工作单位。 二、事务的特征 1、原子性（Atomicity） 2、一致性（Consistency） 3、隔离性（Isolation） 4、持续性（Durability） ...
事务的特性是什么？、什么叫视图？游标是什么？
weixin_51051149的博客
10-28 292
事务的特性是什么？ 原子性 事务必须是原子工作单元；对于其数据修改，要么全都执行，要么全都不执行 一致性 事务在完成时，必须使所有的数据都保持一致状态。在相关数据库中，所有规则都必须应用于事务的修改，以保持所有数据的完整性。事务结束时，所有的内部数据结构（如B 树索引或双向链表）都必须是正确的。 隔离性 由并发事务所作的修改必须与任何其它并发事务所作的修改隔离。事务查看数据时数据所处的状态，要么是另一并发事务修改它...
【无标题】
木子
12-15 1049
1. 事务的四大特性 事务具有4个基本特征，分别是：原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）、持久性（Duration），简称ACID ① 原子性 事务的原子性是指事务必须是一个原子的操作序列单元。事务中包含的各项操作在一次执行...
事务的四大特性
Javaer`s blog
02-29 5万+
1. 事务的四大特性 事务具有4个基本特征，分别是：原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）、持久性（Duration），简称ACID ① 原子性 事务的原子性是指事务必须是一个原子的操作序列单元。事务中包含的各项操作在一次执行过程中，只允许出现两种状态之一，要么都成功，要么都失败 任何一项操作都会导致整个事务的失败，同时其它已经被执行的操作都将...
数据库事务的四大特性
09-06
数据库事务的四大特性是： 1. 原子性（Atomicity）...这四个特性确保了数据库事务的可靠性、一致性和持久性。数据库管理系统通过实现这些特性来保证并发执行的多个事务之间不会互相干扰，并保证数据库的稳定和可靠性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值