您现在的位置是:主页 > Web前端技术 > Web前端技术

Spring事务处理Transactional和并发线程的方法是什么开发技术

IDCBT2021-12-31服务器技术人已围观

简介本篇内容介绍了“Spring事务处理Transactional和并发线程的方法是什么”的有关知识,在实际案例的操作过程中,不少人都会遇到这样的困境,接下来就让小编带领大家学习一下如何处理这

本篇内容介绍了“Spring事务处理Transactional和并发线程的方法是什么”的有关知识,在实际案例的操作过程中,不少人都会遇到这样的困境,接下来就让小编带领大家学习一下如何处理这些情况吧!希望大家仔细阅读,能够学有所成!

Spring事务传播机制和数据库隔离级别

在标准SQL规范中定义了4个事务隔离级别,不同隔离级别对事务处理不同 。

    未授权读取(Read Uncommitted): 也称 未提交读。允许脏读取但不允许更新丢失,如果一个事务已经开始写数据则另外一个数据则不允许同时进行写操作但允许其他事务读此行数据。该隔离级别可以通过 “排他写锁”实现。事务隔离的最低级别,仅可保证不读取物理损坏的数据。与READ COMMITTED 隔离级相反,它允许读取已经被其它用户修改但尚未提交确定的数据。

    授权读取(Read Committed): 也称提交 读。允许不可重复读取但不允许脏读取。这可以通过“瞬间共享读锁”和“排他写锁”实现,读取数据的事务允许其他事务继续访问该行数据,但是未提交写事务将 会禁止其他事务访问该行。SQL Server 默认的级别。在此隔离级下,SELECT 命令不会返回尚未提交(Committed) 的数据,也不能返回脏数据。

    可重复读取(Repeatable Read): 禁止 不可重复读取和脏读取。但是有时可能出现幻影数据,这可以通过“共享读锁”和“排他写锁”实现,读取数据事务将会禁止写事务(但允许读事务),写事务则禁 止任何其他事务。在此隔离级下,用SELECT 命令读取的数据在整个命令执行过程中不会被更改。此选项会影响系统的效能,非必要情况最好不用此隔离级。

    串行(Serializable): 也称可串行读。提 供严格的事务隔离,它要求事务序列化执行,事务只能一个接着一个地执行,但不能并发执行。如果仅仅通过“行级锁”是无法实现事务序列化的,必须通过其他机 制保证新插入的数据不会被刚执行查询操作事务访问到。事务隔离的最高级别,事务之间完全隔离。如果事务在可串行读隔离级别上运行,则可以保证任何并发重叠 事务均是串行的。

    隔离级别更新丢失脏读取重复读取幻读未授权读取NYYY授权读取NNYY可重复读取NNNY串行NNNN

    Spring在TransactionDefinition接口中规定了7种类型的事务传播行为,它们规定了事务方法和事务方法发生嵌套调用时事务如何进行传播:

    package org.springframework.transaction.annotation;
    import org.springframework.transaction.TransactionDefinition;
     
    /**
     * Enumeration that represents transaction propagation behaviors for use
     * with the {@link Transactional} annotation, corresponding to the
     * {@link TransactionDefinition} interface.
     *
     * @author Colin Sampaleanu
     * @author Juergen Hoeller
     * @since 1.2
     */
    public enum Propagation {
     
        /**
         * Support a current transaction, create a new one if none exists.
         * Analogous to EJB transaction attribute of the same name.
         * <p>This is the default setting of a transaction annotation.
         */
        REQUIRED(TransactionDefinition.PROPAGATION_REQUIRED),
     
        /**
         * Support a current transaction, execute non-transactionally if none exists.
         * Analogous to EJB transaction attribute of the same name.
         * <p>Note: For transaction managers with transaction synchronization,
         * PROPAGATION_SUPPORTS is slightly different from no transaction at all,
         * as it defines a transaction scope that synchronization will apply for.
         * As a consequence, the same resources (JDBC Connection, Hibernate Session, etc)
         * will be shared for the entire specified scope. Note that this depends on
         * the actual synchronization configuration of the transaction manager.
         * @see org.springframework.transaction.support.AbstractPlatformTransactionManager#setTransactionSynchronization
         */
        SUPPORTS(TransactionDefinition.PROPAGATION_SUPPORTS),
     
        /**
         * Support a current transaction, throw an exception if none exists.
         * Analogous to EJB transaction attribute of the same name.
         */
        MANDATORY(TransactionDefinition.PROPAGATION_MANDATORY),
     
        /**
         * Create a new transaction, and suspend the current transaction if one exists.
         * Analogous to the EJB transaction attribute of the same name.
         * <p>Note: Actual transaction suspension will not work out-of-the-box on
         * all transaction managers. This in particular applies to JtaTransactionManager,
         * which requires the {@code javax.transaction.TransactionManager} to be
         * made available it to it (which is server-specific in standard J2EE).
         * @see org.springframework.transaction.jta.JtaTransactionManager#setTransactionManager
         */
        REQUIRES_NEW(TransactionDefinition.PROPAGATION_REQUIRES_NEW),
     
        /**
         * Execute non-transactionally, suspend the current transaction if one exists.
         * Analogous to EJB transaction attribute of the same name.
         * <p>Note: Actual transaction suspension will not work on out-of-the-box
         * on all transaction managers. This in particular applies to JtaTransactionManager,
         * which requires the {@code javax.transaction.TransactionManager} to be
         * made available it to it (which is server-specific in standard J2EE).
         * @see org.springframework.transaction.jta.JtaTransactionManager#setTransactionManager
         */
        NOT_SUPPORTED(TransactionDefinition.PROPAGATION_NOT_SUPPORTED),
     
        /**
         * Execute non-transactionally, throw an exception if a transaction exists.
         * Analogous to EJB transaction attribute of the same name.
         */
        NEVER(TransactionDefinition.PROPAGATION_NEVER),
     
        /**
         * Execute within a nested transaction if a current transaction exists,
         * behave like PROPAGATION_REQUIRED else. There is no analogous feature in EJB.
         * <p>Note: Actual creation of a nested transaction will only work on specific
         * transaction managers. Out of the box, this only applies to the JDBC
         * DataSourceTransactionManager when working on a JDBC 3.0 driver.
         * Some JTA providers might support nested transactions as well.
         * @see org.springframework.jdbc.datasource.DataSourceTransactionManager
            通过创建Savepoint实现嵌套事务,达到内层事务若抛出异常(unchecked exception)则回滚到savepoint处,但不影响外层事务;外层事务的回滚会一起回滚内层事务; 
         */
        NESTED(TransactionDefinition.PROPAGATION_NESTED);
     
     
        private final int value;
     
     
        Propagation(int value) { this.value = value; }
     
        public int value() { return this.value; }
     
    }

    标签:

    很赞哦! ()

本栏推荐