转自：https://www.cnblogs.com/acelin/p/15003247.html 今天要讨论的是“Java实现多线程单条数据事务管理”，在此之前，顺便回顾一下实现多线程的几种方式

实现多线程的三种方式

一、继承Thread类

第一种方法是继承Thread类，重写run()方法

  1. public class TestThread extends Thread {
  2. 　　public void run() {
  3. 　　 System.out.println("继承Thread类，重写run方法");
  4. 　　}
  5. }

使用时，new一个实例，执行start()方法

  1. TestThread testThread1 = new TestThread(); // 新建状态
  2. TestThread testThread2 = new TestThread(); // 新建状态
  3. testThread1.start(); // 就绪状态
  4. testThread2.start(); // 就绪状态

何时执行取决于cpu调度

二、实现Runnable接口

因为Java“单继承、多实现”的特性，当我们已经继承了一个类的时候，则无法再继承Thread类，此时可以通过实现Runnable接口的方式，实现run()方法

  1. public class TestThread extends FatherClass implements Runnable {
  2. 　　public void run() {
  3. 　　 System.out.println("实现Runnable接口的方式，实现run方法");
  4. 　　}
  5. }

Thread类也是实现Runnable接口

使用时，需要首先实例化一个Thread，并传入自己的TestThread实例

  1. TestThread testThread = new TestThread();
  2. Thread thread = new Thread(testThread);
  3. thread.start();

三、实现Callable和Future接口

该方法区别于前两种的特点是：能够获得线程处理的结果。因此该方式适用于需要对线程的结果进行处理的场景

  1. class TestCallable implements Callable<Integer> {
  3.     @Override
  4.     public Integer call() {
  5.         int sum = 0;
  6.         for (int i = 0; i < 100; i++) {
  7.             System.out.println(Thread.currentThread().getName() + " " + i);
  8.             sum += i;
  9.         }
  10.         return sum;
  11.     }
  13. }

使用时，先创建TestCallable对象，然后使用FutureTask来包装MyCallable对象，再将FutureTask对象作为Thread对象的target创建新的线程，最后thread执行start()方法，线程进入就绪状态

  1. Callable<Integer> testCallable = new TestCallable();                    // 创建TestCallable对象
  2. FutureTask<Integer> futureTask = new FutureTask<Integer>(testCallable); // 使用FutureTask来包装MyCallable对象
  3. Thread thread = new Thread(futureTask);                                 // FutureTask对象作为Thread对象的target创建新的线程
  4. thread.start();

多线程单条数据事务管理

关于事务，可以看看另外一篇文章谈谈Java事务

我们有时会遇到这样的场景：要对大批量的数据进行更新或插入操作，需要开启多线程来提高效率，又希望每个线程在的处理一批数据时，能够对其中每条数据进行处理的时，做到出错时实现单条数据回滚，而不是所有数回滚（所有数据回滚后续讨论）。先看代码：

根据以上多线程知识，我们先定义一个业务线程类如下：

  1. public class TestTranstionalThread extends Thread {
  3.     private List<BalBankDictEntity> balBankDictEntities;
  5.     public TestTranstionalThread( List<BalBankDictEntity> balBankDictEntities){
  6.         this.balBankDictEntities = balBankDictEntities;
  8.     }
  10.     @Override
  11.     public void run() {
  13.         log.info("线程{}开始",Thread.currentThread().getName());
  15.         for (BalBankDictEntity balBankDictEntity : balBankDictEntities) {
  17.             try{
  18.                 collBillDao.insOneBank(balBankDictEntity);
  19.             }catch (BusiException e){
  20.                 log.error("{}回滚",balBankDictEntity.getBankId());
  21.             }
  23.         }
  25.         log.info("线程{}结束",Thread.currentThread().getName());
  26.     }
  27. }

insOneBank()方法如下，注意的@Transactional注解的事务隔离等级为：REQUIRES_NEW，创建一个新的事务。

  1. @Transactional(propagation = Propagation.REQUIRES_NEW)
  2. public void insOneBank(BalBankDictEntity balBankDictEntity){
  4.     balBankDictMapper.insert(balBankDictEntity);
  6.     /* 模拟发生异常，抛出异常，实现将已插入数据回滚 */
  7.     if (Integer.parseInt(balBankDictEntity.getBankId().substring(2)) % 100 == 0){
  8.         throw new BusiException("test");
  9.     }
  11. }

开启多线程进行业务处理，注意加上@Transactional注解

  1. @Transactional
  2. public void testTransactional(){
  4.     /* 模拟测试数据 */
  5.     List<BalBankDictEntity> balBankDictEntities = new ArrayList<>();
  6.     for (int i = 0 ; i < 100000 ; i ++){
  7.         BalBankDictEntity balBankDictEntity = new BalBankDictEntity();
  8.         balBankDictEntity.setBankCode("BK" + i);
  9.         balBankDictEntity.setBankId("ID" + i + "");
  10.         balBankDictEntity.setBankName("N" + i + "N");
  11.         balBankDictEntities.add(balBankDictEntity);
  12.     }
  14.     int totalNum = balBankDictEntities.size();
  15.     log.info("totalNum" + totalNum);
  17.     /* 分10个线程处理 */
  18.     ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);
  19.     int dealNum = totalNum % 10 == 0 ? totalNum / 10 : totalNum / 10 + 1; // 计算每个线程处理的数量
  21.     for (int i = 1; i <= 10 ; i++ ){
  22.         List<BalBankDictEntity> balBankDictEntityList = splitDataList(balBankDictEntities,dealNum,10,i);  // 切割数据集实现数据隔离
  24.         TestTranstionalThread testTranstional = new TestTranstionalThread(balBankDictEntityList);
  25.         fixedThreadPool.execute(testTranstional);
  27.     }
  29. }

最终实现多个线程并发插入数据，有异常的数据的单独回滚，不影响整体