为什么我的查询陷入僵局？

Question

我正在尝试将一些文件插入到Postgres数据库中。 由于需要大量复制，我们将文件本身放入file表中，然后将它们链接到我们使用output_file表的数据库部分。 由于file表也​​由output_file以外的表引用（例如，类似的input_file表），其中一列是引用计数，当行插入到output_file时，它会被触发器更新（以及其他表也是如此） ，虽然他们有时没有使用问题）。

CREATE TABLE file
(
    file_id serial PRIMARY KEY,
    --other columns
    occurences integer NOT NULL DEFAULT 0
);

CREATE TABLE output_file
(
    output_file_id serial PRIMARY KEY,
    --other columns
    file_id integer REFERENCES file NOT NULL
);

CREATE OR REPLACE FUNCTION file_insert() RETURNS opaque AS '
    BEGIN
        UPDATE file
        SET occurences = occurences + 1
        WHERE file.file_id = NEW.file_id;

        RETURN NEW;
    END;
' LANGUAGE plpgsql;

CREATE TRIGGER output_file_insert AFTER INSERT
    ON output_file FOR EACH ROW
    EXECUTE PROCEDURE file_insert();

插入文件的代码如下所示，并且都是一个事务。

private void insertFiles(Set<File> files){
    SortedSet<Integer> outputFileIDs = new TreeSet<Integer>();
    PreparedStatement fileExistsStatement = getFileExistsStatement();
    for(File file : files) {
        try {
            int fileID = -1;

            ResultSet rs = /* Query to see if file already present in file table */

            if(rs.next()) {
                // File found
                fileID = rs.getInt(1);
            }

            if(fileID < 0) {
                /* File does not exist, upload it */

                rs = /* Query to get file ID */
                fileID = rs.getInt(1);
            }

            outputFileIDs.add(fileID);
        }
        catch(FileNotFoundException e){
            /* handle errors */
        }
    }

    Iterator<Integer> it = outputFileIDs.iterator();
    while(it.hasNext()){
        /* Insert reference in output file table */
        PreparedStatement outputFileStatement = "INSERT INTO output_file (file_id, /*...*/) VALUES (?, /*...*/);";
        outputFileStatement.setInt(1, it.next());
        outputFileStatement.executeUpdate();
    }
}

我的问题是代码死锁（下面显示的异常） 很多 。 它会在相当快乐的情况下暂停一段时间，然后死锁将在整个地方开始发生，当我们回滚并重试时，根本没有任何东西进入数据库。 不过，我对于为什么它首先陷入僵局感到困惑。 文件ID存储在有序集中，因此应按照Postgres手册中的建议，以所有事务的一致顺序获取file表上的锁，以防止任何死锁。 我究竟做错了什么？ Postgres是否以未定义的顺序运行其触发器？

org.postgresql.util.PSQLException: ERROR: deadlock detected
    Detail: Process 8949 waits for ShareLock on transaction 256629; blocked by process 8924.
Process 8924 waits for ExclusiveLock on tuple (4148,40) of relation 30265 of database 16384; blocked by process 8949.
    Hint: See server log for query details.
    Where: SQL statement "UPDATE file
            SET occurences = occurences + 1
            WHERE file.file_id = NEW.file_id"
PL/pgSQL function "file_insert" line 2 at SQL statement
    at org.postgresql.core.v3.QueryExecutorImpl.receiveErrorResponse(QueryExecutorImpl.java:2102)
    at org.postgresql.core.v3.QueryExecutorImpl.processResults(QueryExecutorImpl.java:1835)
    at org.postgresql.core.v3.QueryExecutorImpl.execute(QueryExecutorImpl.java:257)
    at org.postgresql.jdbc2.AbstractJdbc2Statement.execute(AbstractJdbc2Statement.java:500)
    at org.postgresql.jdbc2.AbstractJdbc2Statement.executeWithFlags(AbstractJdbc2Statement.java:388)
    at org.postgresql.jdbc2.AbstractJdbc2Statement.executeUpdate(AbstractJdbc2Statement.java:334)
    at com.mchange.v2.c3p0.impl.NewProxyPreparedStatement.executeUpdate(NewProxyPreparedStatement.java:105)
    at [outputFileStatement.executeUpdate(), above]

[edit]根据axtavt的要求，事务由调用所示方法的代码管理。

public void run(){
    /* connection.setAutoCommit(false) has already been called elsewhere */
    try{
        boolean committed = false;
        boolean deadlocked = false;

        synchronized(connection){
            do{
                deadlocked = false;
                try {
                    /* insert lots of other stuff */

                    if(!files.isEmpty()){
                        insertFiles(files);
                    }

                    /* insert some more stuff */

                    connection.commit();
                    committed = true;

                    closeStatements();
                }
                catch(PSQLException e){
                    if(e.getSQLState() != null){
                        if(e.getSQLState().equals("40P01")){
                            /* Log the fact that we're deadlocked */
                            deadlocked = true;
                        }
                        else{
                            throw e;
                        }
                    }
                    else{
                        throw e;
                    }
                }
                finally {
                    try {
                        if(!committed) {
                            connection.rollback();
                        }
                    }
                    catch (SQLException e) {
                        /* Log exceptions */
                    }
                }
            }while(deadlocked);
        }

    }
    catch(Exception e){
        /* Log exceptions */
    }
    finally{
        try {
            connection.close();
        }
        catch (SQLException e) {
            /* Log exceptions */
        }
    }
}

Answer 1

这是正在发生的事情（我怀疑）：

文件元组（假设file.file_id = 1）已经存在。

进程A使用output_file.file_id = 1插入新的output_file。 这将使用file.file_id = 1获取文件元组上的共享锁。

进程B使用output_file.file_id = 1插入新的output_file。 这将使用file.file_id = 1获取文件元组的aharelock（多个事务可以在单个元组上保存共享块）。

然后，进程A运行触发器，尝试使用file.file_id = 1更新文件元组。 它无法将其共享锁提升为独占锁，因为另一个事务（进程B）正在持有一个共享锁。 所以，它等待。

然后，进程B运行其触发器，该触发器尝试使用file.file_id = 1更新文件元组。 由于同样的原因，它无法促进其共享锁定，因此等待......然后，我们陷入僵局。

在插入新元组之前，修复将作为新父元素的文件元组的SELECT ... FOR UPDATE; 这将在该行上创建独占锁，因此其他事务将从一开始就排队。