jpa-spring EntityManager.Find超时不工作

Question

我试图在我的spring boot应用程序中用jpa和db作为MySQL实现悲观锁。我的目标是让一个存储库首先从db获取一行，然后对其设置锁。当此事务运行时，任何人都不能读取同一行。以下是我实现的代码：

@Repository
@Transactional
public class UserRepo {

@PersistenceContext
private EntityManager entityManager;

/**
 *
 * @param token
 * @param data
 * @return
 */
public boolean lockUser(String token, int data) {
        Map<String, Object> props = new HashMap<String, Object>();
    props.put("javax.persistence.query.timeout", 0);
        User usr = entityManager.find(User.class, token, LockModeType.PESSIMISTIC_WRITE, props);
        System.out.println("BEFOREE LOCK = " + 
        Thread.currentThread().getId() + " user="+usr.getPlayerBalance());

        entityManager.lock(usr, LockModeType.PESSIMISTIC_WRITE, props);
        System.out.println("AFTER LOCK = " + Thread.currentThread().getId());
        if (data>2) {
            System.out.println("IN IF BEFORE SLEEP Thread = " + Thread.currentThread().getId());
            Thread.sleep(90000);
            System.out.println("IN IF AFTER SLEEP Thread = " + Thread.currentThread().getId());
        } else {
            System.out.println("IN ELSE Thread = " + Thread.currentThread().getId());
        }  return false;
      }
 }

现在，当我运行它时，当第一个请求come with data>3时，这个提取行，然后锁定行，线程Hibernate90秒。现在，当第二个请求带有data=1时，线程等待锁（em.find-具有超时为0毫秒的悲观锁）。现在，理想情况下，它应该抛出异常，因为我已经将timeout设置为0。但是第二个线程并没有立即抛出exprection，而且线程从db中读取行然后等待。

Answer 1

lockmodetype.pessimistic_write用于锁定行，这很容易测试。

我对UserRepo进行了一点调整，以：

@Repository
public class UserRepo {

    @PersistenceContext
    private EntityManager entityManager;

    @Transactional
    public void lockUser(final Long id, final boolean wait) throws InterruptedException {
        entityManager.clear(); // be sure there is nothing in the cache, actually the threads don't share first level cache

        final Map<String, Object> props = new HashMap<String, Object>();
        props.put("javax.persistence.query.timeout", 0);

        System.out.println("Thread " + Thread.currentThread().getId() + " EXECUTES SELECT FOR UPDATE");
        entityManager.find(User.class, id, LockModeType.PESSIMISTIC_WRITE, props);

        if (wait) {
            System.out.println("Thread " + Thread.currentThread().getId() + " started blocking!");
            Thread.sleep(10000);
            System.out.println("Thread " + Thread.currentThread().getId() + " finished blocking!");
        }

        System.out.println("Thread " + Thread.currentThread().getId() + " FINISHED QUERY");
    }
}

我为那次回购创建了一个（不漂亮但功能强大的）测试：

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.transaction.annotation.Transactional;

@RunWith(SpringRunner.class)
@Transactional
@SpringBootTest
public class UserRepoTests {

    @Autowired
    private UserRepo userRepo;

    @Test
    public void testSelectForUpdate() throws InterruptedException {

        final Runnable requestOne = () -> {
            try {
                userRepo.lockUser(1L, true); // this one should wait and block the others
            } catch (InterruptedException e) {
            }
        };

        final Runnable requestTwo = () -> {
            try {
                userRepo.lockUser(1L, false);
            } catch (InterruptedException e) {
            }
        };

        final Runnable requestThree = () -> {
            try {
                userRepo.lockUser(1L, false);
            } catch (InterruptedException e) {
            }
        };

        final Thread threadOne = new Thread(requestOne);
        threadOne.start();

        Thread.sleep(1000); // give the first one some time to start

        final Thread threadTwo = new Thread(requestTwo);
        threadTwo.start();
        final Thread threadThree = new Thread(requestThree);
        threadThree.start();

        Thread.sleep(20000); // wait before destroying context
    }

}

Thread 16 EXECUTES SELECT FOR UPDATE
Hibernate: select user0_.id as id1_31_0_, user0_.player_balance as player_b2_31_0_ from "user" user0_ where user0_.id=? for update
Thread 16 started blocking!
Thread 17 EXECUTES SELECT FOR UPDATE
Hibernate: select user0_.id as id1_31_0_, user0_.player_balance as player_b2_31_0_ from "user" user0_ where user0_.id=? for update
Thread 18 EXECUTES SELECT FOR UPDATE
Hibernate: select user0_.id as id1_31_0_, user0_.player_balance as player_b2_31_0_ from "user" user0_ where user0_.id=? for update
Thread 16 finished blocking!
Thread 16 FINISHED QUERY
Thread 17 FINISHED QUERY
Thread 18 FINISHED QUERY

QueryTimeoutException：查询花费的时间比指定的超时时间长（请参见javax.persistence.query.timeout-该属性是一个提示，可能不会被跟随）

或也在同一页上：

timeout查询以毫秒为单位的超时（整数或字符串），这是Hibernate使用的一个提示，但需要底层数据库的支持（TODO是100%为真，还是我们使用了一些其他技巧）。