【无标题】

为什么是伪命题多线程实现事务

根据事务的特性
Atomicity（原子性）：是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。
Consistency（一致性）：事务前后数据的完整性必须保持一致。
Isolation(隔离性)：事务的隔离性是多个用户并发访问数据库时，数据库为每一个用户开启的事务，不能被其他事务的操作数据所干扰，多个并发事务之间要相互隔离。
Durability(持久性)：持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响
多线程情况下违背了事务的特性，但是在实际工作中，比如我们导入一个execl，为了提高效率使用countDownLatch开启多个子线程，分别去读不同的sheet，如果其中一个sheet报错，那么其他数据库是不能写入数据的，要全部回滚，但是多线程情况下报错只会中止当前线程，对其他线程没有影响，想做到事务怎么办呢？

package com.ecarxgroup.base.sys.service.impl;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;


public class Maintest {

        //是否可以提交
        public static volatile boolean IS_OK = true;

        public static void main(String[] args) {
            //子线程等待主线程通知
            CountDownLatch mainMonitor = new CountDownLatch(1);
            int threadCount = 5;
            CountDownLatch childMonitor = new CountDownLatch(threadCount);
            //子线程运行结果
            List childResponse = new ArrayList();
            ExecutorService executor = Executors.newCachedThreadPool();
            for (int i = 0; i < threadCount; i++) {
                int finalI = i;
                executor.execute(() -> {
                    try {
                        System.out.println(Thread.currentThread().getName() + "：开始执行");
//                         if (finalI == 4) {
//                         throw new Exception("出现异常");
//                         }
                        TimeUnit.MILLISECONDS.sleep(ThreadLocalRandom.current().nextInt(1000));
                        childResponse.add(Boolean.TRUE);
                        childMonitor.countDown();
                        System.out.println(Thread.currentThread().getName() + "：准备就绪,等待其他线程结果,判断是否事务提交");
                        mainMonitor.await();
                        if (IS_OK) {
                            System.out.println(Thread.currentThread().getName() + "：事务提交");
                        } else {
                            System.out.println(Thread.currentThread().getName() + "：事务回滚");
                        }
                    } catch (Exception e) {
                        childResponse.add(Boolean.FALSE);
                        childMonitor.countDown();
                        System.out.println(Thread.currentThread().getName() + "：出现异常,开始事务回滚");
                    }
                });
            }
            //主线程等待所有子线程执行response
            try {
                childMonitor.await();
                for (Boolean resp : childResponse) {
                    if (!resp) {
                        //如果有一个子线程执行失败了，则改变mainResult，让所有子线程回滚
                        System.out.println(Thread.currentThread().getName()+":有线程执行失败，标志位设置为false");
                        IS_OK = false;
                        break;
                    }
                }
                //主线程获取结果成功，让子线程开始根据主线程的结果执行（提交或回滚）
                mainMonitor.countDown();
                //为了让主线程阻塞，让子线程执行。
                Thread.currentThread().join();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }


}