今天下午一位前辈给我出了两道要写代码的分析题，说的晚上要交过去，现在已经很晚了。
题目
10个线程计算1000000个数的和
自己手写Spring事务的处理逻辑，包含传播级别的处理
解
题目1
在打完电话之后就直接写了，比我想象中要简单一些.
思路：
10个线程，那么每个线程负责数据中的一部分。
所有的数据完成之后要能通知最后的求和线程，所有线程都完成的话需要一个临界条件
每个线程处理逻辑基本一样
求和运算操作继承自Runnable接口，在操作完之后将求和线程的个数加1，并且判断是否全部都运算完毕，如果全部都算完了，那么通知主线程计算。
假设运算不会溢出
public class NumberSum {
/**
* 要计算的数的数量，10000
*/
private static int CONST = 1000000; /**
* 总共的线程数量
*/
private static int THREAD_COUTN = 10;
/**
* 每个线程负责计算的数据块大小
*/
private static int SEGMENT_COUNT = CONST / THREAD_COUTN;
/**
* 要求和的所有数据存放位置
*/
private static Long[] nums = new Long[CONST];
/**
* 所有线程求出的总和存放位置
*/
private static Long[] result = new Long[THREAD_COUTN];
/**
* 完成求和的线程的个数
*/
private static AtomicInteger complete = new AtomicInteger(0); private static final Object lock = new Object(); public static void main(String[] args) { long startTime = System.nanoTime(); for (int i = 0; i < CONST; i++) {
nums[i] = Long.valueOf(i);
}
Compute compute = new Compute(); for (int i = 0; i < THREAD_COUTN; i++) { new Thread(compute, String.valueOf(i)).start();
}
Long sum = 0L;
synchronized (lock) { try {
System.out.println("等待计算结果"); // 可能其他线程已经计算完结果了，就无需等待
if (complete.get() < 10){
lock.wait();
}
System.out.println("计算完成"); for (int i = 0; i < THREAD_COUTN; i++) {
sum = sum + result[i];
}
System.out.println("最终求得的结果为：" + sum);
} catch (InterruptedException e) {
e.printStackTrace();
}
} long endTime = System.nanoTime(); double second = (endTime - startTime) / Math.pow(10,9);
System.out.println("总共运行时间：" + second + "秒");
} /**
* Runable可以为多个线程共享
*/
static class Compute implements Runnable {
@Override public void run() { int segment = Integer.parseInt(Thread.currentThread().getName()); int beginIndex = segment * SEGMENT_COUNT; int endIndex = (segment + 1) * SEGMENT_COUNT;
Long sum = 0L; for (int i = beginIndex; i < endIndex; i++) {
sum = sum + nums[i];
}
result[segment] = sum;
System.out.println("线程" + segment + "求得的结果为：" + sum);
synchronized (lock){ int completeNumber = complete.addAndGet(1); if (completeNumber == THREAD_COUTN){
lock.notifyAll();
}
}
}
}
}题目2
Spring事务处理代码阅读
这个题目，我想了下，事务中包含了不少要了解的东西，我在写事务的时候，走偏了一点，低估了手写事务的难度，对事务的理解程度不够深刻，没有能很好的剥离出事务处理的核心部分。
几个核心类：
TransactionInterceptor AOP的Advice，方法拦截器，配置的时候用的是它
TransactionAspectSupport，事务拦截器的父类，提供了一些模板方法，早先的Spring版本，方法在TransactionInterceptor内，新版的Spring把一些方法放到这个对象中了。
PlatformTransactionManager ，真正处理事务生命周期的东西，begin,commit,rollback都在PlatformTransactionManager内实现
TransactionAttributeSource，这个对指定具体事务执行的属性进行了封装。具体事务配置的属性都在里面
Spring事务处理基本结构
事务基本结构
else部分的逻辑暂时用不到
获取定义的attrbute，事务的配置部分，配置中是可以指定具体的事务管理器的。
根据事务的属性，判断是不是要创建事务，事务的传播级别处理都在里面，对应第277行
执行事务体内的方法。invocation.proceedWithInvocation()。我们的事务代码部分，一般就是我们队数据库的操作代码
如果有异常，处理异常的部分， 286行
不管有无异常执行完之后，清除事务信息。
如果正确执行的话，就commit结果，并且返回我们程序返回的值
Spring判断是否要创建事务
截图自TransactionAspectSupport.java
重点部分在461行，事务属性与事务管理器都不为空的话，那么事务管理器根据指定的事务属性获取事务。
最后的prepareTransaction知识把事务信息绑定到当前线程。
事务管理器内部都是有关事务的操作，这个知识抽象的事务管理器，作为模板方法，真正的事务处理需要其继承类来实现。
image.png
事务传播级别的处理
抽象事务管理器内部，getTransaction主要用来处理 事务的传播级别的逻辑，代理一些方法到doGetTransaction，isExistingTransaction，doBegin方法上
public final TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException {
Object transaction = doGetTransaction(); //缓存日志级别，避免重复检查
boolean debugEnabled = logger.isDebugEnabled(); if (definition == null) { // Use defaults if no transaction definition given.
definition = new DefaultTransactionDefinition();
} if (isExistingTransaction(transaction)) { // Existing transaction found -> check propagation behavior to find out how to behave.
return handleExistingTransaction(definition, transaction, debugEnabled);
} // Check definition settings for new transaction.
if (definition.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) { throw new InvalidTimeoutException("Invalid transaction timeout", definition.getTimeout());
} // No existing transaction found -> check propagation behavior to find out how to proceed.
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) { throw new IllegalTransactionStateException( "No existing transaction found for transaction marked with propagation 'mandatory'");
} else if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
SuspendedResourcesHolder suspendedResources = suspend(null); if (debugEnabled) {
logger.debug("Creating new transaction with name [" + definition.getName() + "]: " + definition);
} try { boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
DefaultTransactionStatus status = newTransactionStatus(
definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
doBegin(transaction, definition);
prepareSynchronization(status, definition); return status;
} catch (RuntimeException ex) {
resume(null, suspendedResources); throw ex;
} catch (Error err) {
resume(null, suspendedResources); throw err;
}
} else { // Create "empty" transaction: no actual transaction, but potentially synchronization.
if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT && logger.isWarnEnabled()) {
logger.warn("Custom isolation level specified but no actual transaction initiated; " + "isolation level will effectively be ignored: " + definition);
} boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS); return prepareTransactionStatus(definition, null, true, newSynchronization, debugEnabled, null);
}
}
传播级别处理的部分
如果存在了事务，那么处理已经存在的事务，在已经存在的事务内进行事务传播级别的处理。是否存在事务的代码交给其继承类来实现，自己默认返回false
没有事务的话，就直接根据事务传播级别的定义进行处理
常见传播级别
使用NESTED传播级别的时候，底层数据源必须基于JDBC3.0，并且实现者需要支持保存点事务机制。
NESTED事务传播级别
仿写的部分
代码内容：
基于AOP注解的方法拦截器，在进行方法拦截的时候，我们可以获取到方法上的注解值，通过注解的值，可以了解到事务的传播级别。
一个事务如何判断是否在其它事务内呢？
我用的是一个事务栈，使用LinkedList作为栈来处理，LinkedList是线程私有的，这样实现不同的线程也不会相互干扰，如果栈内已经存在事务标志了，那么就代表当前操作是一件在事务内的。
代码相对粗糙。
依赖：
<dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aop</artifactId> <version>4.3.16.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>4.3.16.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-tx</artifactId> <version>4.3.16.RELEASE</version> </dependency> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.8.13</version> </dependency> </dependencies>
事务拦截器：
/**
* @author aihe 2018/7/16
*/public class TransactionInterceptor implements MethodInterceptor { /**
* 事务栈，为每个线程设置独立的事务栈，如果栈内存在标志，代表当前操作依据在事务内
*/
private ThreadLocal<LinkedList<TransactionFlag>> tx = new ThreadLocal<LinkedList<TransactionFlag>>(); /**
* 事务方法上指定的回滚事务异常类型。
*/
private ThreadLocal<LinkedList<Class<? extends Throwable>[]>> excetionStack = new ThreadLocal<LinkedList<Class<? extends Throwable>[]>>(); /**
* 1. 创建事务，根据当前的情况，判断是否要创建
* 2. 执行事务内的实际的具体逻辑
* 3. 如果发生异常，判断是否要回滚
* @param methodInvocation
* @return
* @throws Throwable
*/
public Object invoke(MethodInvocation methodInvocation) throws Throwable {
createTransactionIfNecessary(methodInvocation);
Object result = null; try {
result = methodInvocation.proceed();
} catch (Exception e) {
completeTransactionAfterThrowing(e); throw e;
} return result;
} /**
* 处理事务回滚逻辑，如果不存在事务直接跳过，否则根据异常类型判断是否要进行事务回滚。
* @param e
* @throws Exception
*/
private void completeTransactionAfterThrowing(Exception e) throws Exception { if (tx.get() != null){
Class<? extends Throwable>[] first = excetionStack.get().getFirst(); for (Class<? extends Throwable> aClass : first) { if (e.getClass() == aClass) {
System.out.println("回滚事务"); throw e;
}
}
}
} private void createTransactionIfNecessary(MethodInvocation methodInvocation) {
LinkedList<TransactionFlag> transactionFlags = tx.get();
LinkedList<Class<? extends Throwable>[]> throwables = excetionStack.get();
Method method = methodInvocation.getMethod();
Transactional annotation = method.getAnnotation(Transactional.class); //获取传播属性与异常
Propagation propagation = annotation.propagation();
Class<? extends Throwable>[] rollbackFor = annotation.rollbackFor();
throwables.add(rollbackFor); if (propagation == Propagation.MANDATORY) { throw new IllegalTransactionStateException( "没有已经存在的事务");
} if (propagation == Propagation.REQUIRES_NEW ||
propagation == Propagation.REQUIRED ||
propagation == Propagation.NESTED
) { //不存在事务
if (transactionFlags == null ){
transactionFlags = new LinkedList<TransactionFlag>();
transactionFlags.add(new TransactionFlag());
tx.set(transactionFlags);
System.out.println("新建事务"); //已经存在事务
}else{ if (propagation == Propagation.REQUIRES_NEW ){
transactionFlags.add(new TransactionFlag());
tx.set(transactionFlags);
System.out.println("挂起当前事务");
}
}
}
} /**
* 事务标志
*/
private static class TransactionFlag {
}
}写不出那么厉害的代码... 有些像伪代码
最后
事务处理的代码这块自己写的确实不够好。
昨天挂完电话，前辈的意思是挂完电话，立刻写代码然后发给他吗，如果是这样，上面的算法计数题可以写的出来，
我事务的部分写的也是不会表现太好。
在思考事务如何写的时候，事务如果往大了写，那就是自己造一个精简版的事务轮子，我前两个小时是这么想的，但分析不到位，没有那么简单，也写不出来。
往小了写，事务的核心逻辑剥离出来，整体思路要明白。对于我，事务的原理要仔细研究啊。事务的代码表现的不够好。
随时随地看视频
