Question

我正在运行一项运作良好的导入工作，直到几天前实体数量急剧增加。

发生的事情是我超过了锁定等待时间。然后应用程序重试并抛出异常，因为我再次调用 em.getTransaction（）。begin（）; 。

为了解决这个问题，我将 innodb_lock_wait_timeout 更改为120并且将批次方面降低到50个实体。

我无法弄清楚如何在代码中正确处理所有这些问题。我不希望整个导入因锁定而失败。你会怎么处理这个？你有任何代码吗？例？也许其他一些想法？请坚持下去！

我的BatchPersister：

public class BatchPersister implements Persister {

    private final static Log log = getLog(BatchPersister.class);
    private WorkLogger workLog = WorkLogger.instance();

    private static final int BATCH_SIZE = 500;

    private int persistedObjects;
    private long startTime;
    private UpdateBatch batch;
    private String dataSource;


    public BatchPersister(String dataSource) {
        this.dataSource = dataSource;        
    }

    public void persist(Persistable obj) {

        persistedObjects++;
        logProgress(100);

        if (batch == null)
            batch = new UpdateBatch(BATCH_SIZE, dataSource);

        batch.add(obj);

        if (batch.isFull()) {
            batch.persist();
            batch = null;
        }
    }
}

的UpdateBatch

public class UpdateBatch {

    private final static Log log = LogFactory.getLog(UpdateBatch.class);
    private WorkLogger workLogger = WorkLogger.instance();

    private final Map<Object, Persistable> batch;
    private final EntityManager em;
    private int size;

    /**
     * Initializes the batch and specifies its size.
     */
    public UpdateBatch(int size, String dataSource) {
        this.size = size;
        batch = new LinkedHashMap<Object, Persistable>();
        em = EmFactory.getEm(dataSource);
    }    

    public void persist() {
        log.info("Persisting " + this);
        em.getTransaction().begin();    
        persistAllToDB();
        em.getTransaction().commit();

        WorkLog batchLog = new WorkLog(IMPORT_PERSIST, IN_PROGRESS);
        batchLog.setAffectedItems(batch.size());
        workLogger.log(batchLog);
        em.close();
   }

/**
  * Persists all data in this update batch
  */
    private void persistAllToDB() {
        for (Persistable persistable : batch.values())
            em.persist(persistable);
        }

        @Override
        public String toString() {
            final ArrayList<Persistable> values = new ArrayList<Persistable>(batch.values());
            Persistable first = values.get(0);
            Persistable last = values.get(values.size() - 1);
            return "UpdateBatch[" +
                first.getClass().getSimpleName() + "(" + first.getId() + ")" +
                " - " +
                last.getClass().getSimpleName() + "(" + last.getId() + ")" +
                "]";
         }
    }
}

Answer 1

解决方案1。 不要使用JPA，它不适用于大规模数据库操作。由于您可以访问DataSource并且手动管理事务，因此没有什么能阻止您使用普通的旧SQL。

解决方案2。 可能存在与持久性上下文第一级缓存相关的性能问题 - 每个持久化实体都保留在该缓存中，当此缓存变大时，可能会损害性能（主要是内存）

为了改善情境设置hibernate.jdbc.batch_size属性（或等效，如果你没有使用JPA的Hibernate实现）或多或少20 - 多亏了那些查询将被发送到20个查询包中的数据库。

其次，每20次操作清除持久性上下文，强制与数据库同步。

private void persistAllToDB() {
    int counter = 0;
    for (Persistable persistable : batch.values())
        em.persist(persistable);
        counter++;
        if(counter % 20 == 0){
           em.flush();
           em.clear();
        }
    }
}

解决方案3。 调整MySQL InnoDB引擎[http://dev.mysql.com/doc/refman/5.1/en/insert-speed.html,http://dev.mysql.com/doc/refman/5.0/en/innodb-tuning html的。如果您的表被严格索引，可能会影响插入性能。

这是我的猜测，希望有些东西可以帮助你。

Answer 2

Pitor已经提到了几个选项。我想指出他的“解决方案2”的变体是利用Hibernate StatelessSession api而不是使用Session和清除。

但是，您应该考虑的其他事项是，事务是一组预期会失败或总体成功的语句。如果你有一堆语句而中间的一个语句失败并且你希望所有前面的语句都是持久的，那么你不应该在一个事务中将它们组合在一起。在交易中正确分组您的报表。通常，最好在Hibernate中启用jdbc批处理;它通常会带来更有效的数据库通信。

如何以正确的方式处理超出锁定等待超时？

2 个答案: