Java sql事务。我做错了什么？

我编写这个小测试的唯一目的是更好地理解jdbc中的事务。虽然我是根据文档做的，但是测试不希望正常工作

以下是表格结构：

CREATE TABLE `default_values` (
   `id` INT UNSIGNED NOT auto_increment,
   `is_default` BOOL DEFAULT false,
   PRIMARY KEY(`id`)
);

测试包含3个类：

public class DefaultDeleter implements Runnable
{

    public synchronized void deleteDefault() throws SQLException
    {
        Connection conn = null;
        Statement deleteStmt = null;
        Statement selectStmt = null;
        PreparedStatement updateStmt = null;
        ResultSet selectSet = null;

        try
        {
            conn = DriverManager.getConnection("jdbc:mysql://localhost/xtest", "root", "");
            conn.setAutoCommit(false);
            conn.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);

            // Deleting current default entry
            deleteStmt = conn.createStatement();
            deleteStmt.executeUpdate("DELETE FROM `default_values` WHERE `is_default` = true");

            // Selecting first non default entry
            selectStmt = conn.createStatement();
            selectSet = selectStmt.executeQuery("SELECT `id` FROM `default_values` ORDER BY `id` LIMIT 1");

            if (selectSet.next())
            {
                int id = selectSet.getInt("id");

                // Updating found entry to set it default
                updateStmt = conn.prepareStatement("UPDATE `default_values` SET `is_default` = true WHERE `id` = ?");
                updateStmt.setInt(1, id);
                if (updateStmt.executeUpdate() == 0)
                {
                    System.err.println("Failed to set new default value.");
                    System.exit(-1);
                }
            }
            else
            {
                System.err.println("Ooops! I've deleted them all.");
                System.exit(-1);
            }

            conn.commit();
            conn.setAutoCommit(true);
        }
        catch (SQLException e)
        {
            try { conn.rollback(); } catch (SQLException ex)
            {
                ex.printStackTrace();
            }

            throw e;
        }
        finally
        {
            try { selectSet.close(); } catch (Exception e) {}
            try { deleteStmt.close(); } catch (Exception e) {}
            try { selectStmt.close(); } catch (Exception e) {}
            try { updateStmt.close(); } catch (Exception e) {}
            try { conn.close(); } catch (Exception e) {}
        }
    }

    public void run()
    {
        while (true)
        {
            try
            {
                deleteDefault();
            }
            catch (SQLException e)
            {
                e.printStackTrace();
                System.exit(-1);
            }

            try
            {
                Thread.sleep(20);
            }
            catch (InterruptedException e) {}
        }
    }

}

public class DefaultReader implements Runnable
{

    public synchronized void readDefault() throws SQLException
    {
        Connection conn = null;
        Statement stmt = null;
        ResultSet rset = null;

        try
        {
            conn = DriverManager.getConnection("jdbc:mysql://localhost/xtest", "root", "");

            conn.setAutoCommit(false);
            conn.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);

            stmt = conn.createStatement();
            rset = stmt.executeQuery("SELECT * FROM `default_values` WHERE `is_default` = true");

            int count = 0;
            while (rset.next()) { count++; }

            if (count == 0)
            {
                System.err.println("Default entry not found. Fail.");
                System.exit(-1);
            }
            else if (count > 1)
            {
                System.err.println("Count is " + count + "! Wtf?!");
            }

            conn.commit();
            conn.setAutoCommit(true);
        }
        catch (SQLException e)
        {
            try { conn.rollback(); } catch (Exception ex)
            {
                ex.printStackTrace();
            }

            throw e;
        }
        finally
        {
            try { rset.close(); } catch (Exception e) {}
            try { stmt.close(); } catch (Exception e) {}
            try { conn.close(); } catch (Exception e) {}
        }
    }

    public void run()
    {
        while (true)
        {
            try
            {
                readDefault();
            }
            catch (SQLException e)
            {
                e.printStackTrace();
                System.exit(-1);
            }

            try
            {
                Thread.sleep(20);
            }
            catch (InterruptedException e) {}
        }
    }

}

public class Main
{

    public static void main(String[] args)
    {
        try
        {
            Driver driver = (Driver) Class.forName("com.mysql.jdbc.Driver")
                    .newInstance();
            DriverManager.registerDriver(driver);

            Connection conn = null;
            try
            {
                conn = DriverManager.getConnection("jdbc:mysql://localhost/xtest", "root", "");
                System.out.println("Is transaction isolation supported by driver? " +
                        (conn.getMetaData()
                        .supportsTransactionIsolationLevel(
                        Connection.TRANSACTION_SERIALIZABLE) ? "yes" : "no"));
            }
            finally
            {
                try { conn.close(); } catch (Exception e) {}
            }

            (new Thread(new DefaultReader())).start();
            (new Thread(new DefaultDeleter())).start();

            System.in.read();
            System.exit(0);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }

}

我已经编写了脚本，它用100k条记录填充表，其中一条记录是每次运行的默认记录。但每次我运行此测试时，输出是：

驱动程序是否支持事务隔离？对

未找到默认条目。失败

---

此代码有什么问题？

如果允许容器管理事务，可以执行以下操作：

@Resource
private UserTransaction utx;

然后在代码中使用它：

utx.begin();

// atomic operation in here

utx.commit();

那么您就不必担心事务管理的复杂性了

---

编辑：@Gris：是的，你说得对。我以为你在开发一个web应用程序。正如pjp所说，在这种情况下，spring是一个不错的选择。或者-取决于应用程序的大小和复杂性-您可以管理自己的事务。

我建议您添加一些断点，并逐步执行每个数据库操作，以检查它们是否按照您的预期执行。您可以在数据库服务器上打开会话，并设置事务隔离级别，以便读取未提交的数据

---

还要检查在MySql中对布尔类型的数值1使用“true”是否有效。

答案很简单：创建两个线程。它们完全独立运行。由于您没有以任何方式同步它们，因此无法确定哪一个先访问数据库。如果读卡器是第一个，那么删除器还没有开始，也不会有is_default==true的项，因为删除器还没有到达那么远

接下来，您已经完全隔离了两个事务Connection.TRANSACTION_SERIALIZABLE。这意味着，即使删除程序有机会更新数据库，读者也只能在关闭连接并打开新连接后才能看到它

如果不是这样，删除程序比读取器慢，因此在读取器查找记录时，记录更新为is_default==true的可能性很小

---

[编辑]现在您说，当测试开始时，应该有一个is_default==true的项目。在启动两个线程之前，请添加一个测试以确保情况确实如此。否则，您可能会发现错误的错误。

请确保您正在创建InnoDB表，MyISAM默认不支持事务。您可以将db create更改为：

CREATE TABLE `default_values` (
   `id` INT UNSIGNED NOT auto_increment,
   `is_default` BOOL DEFAULT false,
   PRIMARY KEY(`id`)
) Engine=InnoDB;

---

另一个例子：

有几点值得一提：

在测试之前填充数据库的脚本真的有效吗？尝试进行选择计数*。。。从Java代码内部检查这个可能听起来很愚蠢，但我以前犯过这个错误

不要到处执行System.exit，因为这会使代码很难测试-尽管看起来您没有默认==true记录，但查看删除程序的操作可能会很有趣

---

但若我理解正确，那个么它只有在应用程序在j2ee容器中运行时才可用。但我的目标是独立的j2se应用程序，而不是Web应用程序。作为成熟的j2ee的替代方案，您可以使用Spring实现DataSource TransactionManager。2 pjp：您可能是对的。我将查看文档，但我不确定从其他角度来看是否可以接受使用这样的框架。所有操作本身都是正确的。使用“true”也可以，它不是括号中的文本，而是内置常量。我首先检查了MySQL控制台中的所有查询。我感谢上面的所有评论对您的帮助——但我建议您从确保使用符合事务的表开始——然后Aaron Digulla提出了一个问题：哪个线程首先访问数据库。一旦使用了事务表，就可以在writer线程中设置睡眠，一次写入100行，然后确保delete在writer线程的中间事务中启动。你应该看到交易在做他们在那一点上做的事情。看起来我真的犯了这样一个愚蠢的错误。将引擎更改为InnoDB后，应用程序似乎运行良好。谢谢。关于线程-这是一个要求。测试作为一个可靠的应用程序工作，但最终的应用程序可能由几个完全独立的过程组成。关于事务——据我所知，完全隔离的事务应该提供封闭操作的原子性，以便内部的所有操作都作为一个实体操作进行处理—在我的例子中，删除、选择、更新。我错了吗？我使用脚本在每次运行之前清除并填充表。我也手动检查了启动条件。我看到一些答案开始谈论声明性事务和使用Spring，我很喜欢Spring，但它们只会混淆情况。这个问题是可以解决的，你会

---

更好地理解如何使用原始JDBC，如果您开始将其包装到更高级别的框架（如JEE或Spring）中，它就会变得模糊。我建议长期不要使用原始JDBC，除非您处于一个非常受限的环境中。它容易出错，而且是一个PITA。为什么您认为DefaultReader会成功？仅仅因为线程在删除程序之前启动，并不意味着它将在删除发生之前实际运行？请记住，MyISAM表不支持事务，InnoDB表支持事务。可序列化隔离级别可能会失败，如果有2个并发可序列化事务正在进行，dbs通常会使事务失败。