Question

我编写了一个唯一目的的小测试，以更好地理解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条记录（其中一条是默认记录）。但每次运行此测试时，输出为：

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

找不到默认条目。失败。

这段代码出了什么问题？

Answer 1

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

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

另一个例子：MySQL transaction with accounting application

Answer 2

如果您允许容器管理交易，您可以执行以下操作：

@Resource
private UserTransaction utx;

然后只需在代码中使用它：

utx.begin();

// atomic operation in here

utx.commit();

然后您不必担心事务管理的复杂性。

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

Answer 3

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

同时检查在MySql中使用'true'对布尔类型的数值1是否有效。

Answer 4

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

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

如果情况并非如此，那么删除器比阅读器慢，因此在读者查找记录时，is_default == true更新记录的可能性很小。 / p>

[编辑]现在你说测试开始时应该有一个is_default == true项。请添加一个测试，以确保在启动两个线程之前确实是这种情况。否则，你可能正在寻找错误的错误。

Answer 5

有几点值得一提：

在测试真正起作用之前，您的脚本是否填充数据库？尝试从Java代码中对表进行select count(*) ...检查（这可能听起来很愚蠢，但我之前犯了这个错误。）
不要在所有地方System.exit()，因为它会使代码难以测试 - 看看删除器的作用可能会很有趣，即使它看起来没有默认值== true记录。

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

5 个答案: