疑惑：有没有人真正用多线程工具（比如groboutils）测试过Spring的事务处理？

// import 省略...

/**
 * 测试类 AccountTransferMultiThreadTest，使用了 groboutils 以实现多线程测试。
 *
 * 每个测试线程从一定数量的测试户头中随机选取一对 转出/转入 户头，然后进行一次随机数额的转帐。
 *
 * 测试户头总数由常量 NUM_ACC 设定。
 *
 * 测试线程总数由常量 NUM_TRANSFER 设定。
 *
 */
public class AccountTransferMultiThreadTest extends TestCase {
	// 每个测试户头的初始余额为1000元
	private static final BigDecimal INIT_BALANCE = BigDecimal.valueOf(100000L, 2); 
	private static final int NUM_ACC = 10; // 测试户头的总数
	private static final int NUM_TRANSFER = 3000; // 测试线程总数（即转帐总次数）
	private ApplicationContext context;
	private AccountService accountService;
	private long[] accountIds;

	/* (non-Javadoc)
	 * @see junit.framework.TestCase#setUp()
	 *
	 * 在setUp方法中，生成测试所需的Spring Application Context, 并在数据库中创建
	 * 一定数量的户头（Account），供多线程测试使用。
	 *
	 */
	protected void setUp() throws Exception {
		super.setUp();
		context = new ClassPathXmlApplicationContext("xiao/test/spring/*Context.xml");
		accountService = (AccountService) context.getBean("accountService");

		Account[] accounts = new Account[NUM_ACC];
		accountIds = new long[accounts.length];
		for (int i = 0; i < accounts.length; i++) {
			accounts[i] = new Account();
			accounts[i].setBalance(INIT_BALANCE);

			// 将当前生成的户头写入数据库
			accountService.create(accounts[i]);

			// 重要步骤！将当前生成的户头主键记录下来，以供测试线程使用
			accountIds[i] = (Long)accounts[i].getId();
		}
	}

	/* (non-Javadoc)
	 * @see junit.framework.TestCase#tearDown()
	 */
	protected void tearDown() throws Exception {
		super.tearDown();
	}

	private Account[] getAccounts() {
		Account[] accounts = new Account[accountIds.length];
		for (int i = 0; i < accountIds.length; i++) {
			// 从数据库获取这个户头对象
			accounts[i] = accountService.findById(accountIds[i]);
		}
		// 返回户头数组
		return accounts;
	}

	public void testMultiThreadTransfer() throws Throwable {
		// 获取户头对象数组
		Account[] accounts = getAccounts();
		System.out.printf("Starting %s transfers...\n", NUM_TRANSFER);

		// 记录测试前的所有户头总余额
		BigDecimal total1 = accountService.getTotalBalance(accounts);

		// 生成所有测试线程
		TestRunnable[] tr = new TestRunnable[NUM_TRANSFER];
		long start = System.currentTimeMillis();
		for (int i = 0; i < tr.length; i++) {
			tr[i] = new TransferThread(accountService, accounts);
		}

		// 生成测试线程运行器
		MultiThreadedTestRunner mttr = new MultiThreadedTestRunner(tr);

		// 运行测试线程
		mttr.runTestRunnables();

		// 显示转帐消耗时间
		long used = System.currentTimeMillis() - start;
		System.out.printf("%s transfers used %s milli-seconds.\n", NUM_TRANSFER, used);

		// 获取测试后所有户头总余额
		Account[] accounts2 = getAccounts();
		BigDecimal total2 = accountService.getTotalBalance(accounts2);

		// 确认测试前后，所有户头总余额还是一致的。
		assertEquals(total1, total2);
	}

	/*
	 * 测试线程类定义
	 */
	private static class TransferThread extends TestRunnable {
		private AccountService accountService;
		private Account[] accounts;
		public TransferThread(AccountService accountService, Account[] accounts) {
			super();
			this.accountService = accountService;
			this.accounts = accounts;
		}
		@Override
		public void runTest() throws Throwable {
			Random randomGenerator = new Random();

			// 随机选取转出户头
			int from = randomGenerator.nextInt(accounts.length);

			// 随机选取转入户头
			int to = randomGenerator.nextInt(accounts.length);

			// 确保转出、转入户头不是同一个
			while (to == from) {
				to = randomGenerator.nextInt(accounts.length);
			}

			// 随机选取转帐数额（0 ~ 149元之间）
			BigDecimal amount = BigDecimal.valueOf(randomGenerator.nextInt(150));

			// 转帐！
			try {
				accountService.transfer(accounts[to], accounts[from], amount);
			} catch (AppException ae) {
				// 捕捉运行时间异常“AppException”，并打印
				System.out.println(ae.getMessage());
			}
		}
	}
}

// import 省略...

/**
 * AccountServiceImpl 是 AccountService 接口的实现类。
 *
 * AccountService 从父接口 EntityService 继承了一系列访问数据库所必需的基本方法的接口。
 *
 * AccountServiceImpl 从父类 EntityServiceDefaultImpl 继承了一系列访问数据库所必需的基本方法的实现。
 *
 * AccountService 定义了户头操作所特有的方法接口 (getTotalBalance 与 transfer。)
 *
 * AccountServiceImpl 定义了户头操作所特有的方法实现 (getTotalBalance 与 transfer。)
 *
 */
public final class AccountServiceImpl extends EntityServiceDefaultImpl<Account, Serializable>
		implements AccountService {

	/* (non-Javadoc)
	 * @see test.spring.service.AccountService#getTotalBalance(test.spring.entity.Account[])
	 */
	@Override
	public BigDecimal getTotalBalance(Account[] accounts) {
		BigDecimal total = BigDecimal.ZERO;
		if (null == accounts) {
			return total;
		}
		for (Account account : accounts) {
			if (null == account) {
				continue;
			}
			total = total.add(account.getBalance());
		}
		return total;
	}

	/* (non-Javadoc)
	 * @see test.spring.service.AccountService#transfer(test.spring.entity.Account, test.spring.entity.Account, java.math.BigDecimal)
	 */
	@Override
	public void transfer(Account to, Account from, BigDecimal amount) {
		if (null == to || null == from) {
			return;
		}
		if (null == amount || BigDecimal.ZERO.equals(amount)) {
			return;
		}
		
		// 如果转出户头的余额不足，抛出运行时间异常。
		if (from.getBalance().compareTo(amount) < 0) {
			String msg = String.format(
					"Account id [%s] has $%s left only, cannot transfer amount $%s out.",
					from.getId(), from.getBalance(), amount);
			//System.out.println(msg);
			throw new AppException(msg);
		}
		
		// 为转出户头设置新余额
		from.setBalance(from.getBalance().subtract(amount));
		
		// 为转入户头设置新余额
		to.setBalance(to.getBalance().add(amount));

		// 将转出户头写入数据库
		getDao().update(from);
		
		// 将转入户头写入数据库
		getDao().update(to);
	}

}

......
    <bean id="txManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="defaultDataSessionFactory" />
    </bean>
    <tx:advice id="generalServiceAdvice" transaction-manager="txManager">
        <tx:attributes>
            <tx:method name="create*" propagation="REQUIRED" />
            <tx:method name="save*" propagation="REQUIRED" />
            <tx:method name="update*" propagation="REQUIRED" />
            <tx:method name="transfer*" propagation="REQUIRED" isolation="SERIALIZABLE"
                rollback-for="Throwable"/>
            <tx:method name="*" propagation="SUPPORTS" read-only="true" />
        </tx:attributes>
    </tx:advice>

    <aop:config>
        <aop:pointcut id="serviceMethods"
            expression="execution(* test.spring.service.*Service.*(..))" />
        <aop:advisor advice-ref="generalServiceAdvice"
            pointcut-ref="serviceMethods" />
    </aop:config>
......

         for (int i = 0; i < tr.length; i++) {
             //这里的 accounts 在众多线程里共享，但是好像没有互斥访问  
             tr[i] = new TransferThread(accountService, accounts);  
         }

     //这里的from 和 to 都来自于内存中的 accounts
     public void transfer(Account to, Account from, BigDecimal amount) {  
         if (null == to || null == from) {  
             return;  
         }  
         if (null == amount || BigDecimal.ZERO.equals(amount)) {  
             return;  
         }  
           
         // 如果转出户头的余额不足，抛出运行时间异常。  
         if (from.getBalance().compareTo(amount) < 0) {  
             String msg = String.format(  
                     "Account id [%s] has $%s left only, cannot transfer amount $%s out.",  
                     from.getId(), from.getBalance(), amount);  
             //System.out.println(msg);  
             throw new AppException(msg);  
         }  
           
         // 为转出户头设置新余额  
         from.setBalance(from.getBalance().subtract(amount));  
           
         // 为转入户头设置新余额  
         to.setBalance(to.getBalance().add(amount));  
   
         // 将转出户头写入数据库  
         getDao().update(from);  
           
         // 将转入户头写入数据库  
         getDao().update(to);  
     } 

         for (int i = 0; i < tr.length; i++) {
             //这里的 accounts 在众多线程里共享，但是好像没有互斥访问  
             tr[i] = new TransferThread(accountService, accounts);  
         }

     //这里的from 和 to 都来自于内存中的 accounts
     public void transfer(Account to, Account from, BigDecimal amount) {  
......
     } 

		// 使用悲观锁，利用 DAO 中定义的 findById(PK, boolean) 方法重新获得转出/转入户头。
		// 目的：当 findById 的第二参数为“true”时，它将调用 HibernateTemplate.get(type, id, LockMode.UPGRAGE).
		// 这实际上等于 SQL 中的“select ... from .... for update”。
		to = getDao().findById(to.getId(), true);
		from = getDao().findById(from.getId(), true);