【Spring事务详解】--- 5.事务管理器TransactionSynchronizationManager分析

前言6个ThreadLocal事务资源

获取资源绑定资源解绑资源 事务同步

事务同步激活事务同步注册获取事务同步列表判断当前事务是否为活跃 currentTransactionReadOnly和currentTransactionIsolationLevelactualTransactionActive清除

Spring事务详解连载

【Spring事务详解】— 1.事务传播的案例演示
【Spring事务详解】— 2.事务应用的注意事项
【Spring事务详解】— 3.事务失效的八种场景
【Spring事务详解】— 4.事务管理器的架构分析
【Spring事务详解】— 5.事务管理器TransactionSynchronizationManager分析

TransactionSynchronizationManager主要作用就是管理每个线程的资源和事务同步，包括资源绑定，激活事务同步等。

TransactionSynchronizationManager中定义了6个ThreadLocal对象，单从名称就能分析出来，他们分别负责维护：事务资源、事务同步，事务名称、事务只读状态、事务隔离级别以及当前事务是否活跃。

private static final ThreadLocal> resources =
		new NamedThreadLocal<>("Transactional resources");
private static final ThreadLocal> synchronizations =
		new NamedThreadLocal<>("Transaction synchronizations");
private static final ThreadLocal currentTransactionName =
		new NamedThreadLocal<>("Current transaction name");
private static final ThreadLocal currentTransactionReadOnly =
		new NamedThreadLocal<>("Current transaction read-only status");
private static final ThreadLocal currentTransactionIsolationLevel =
		new NamedThreadLocal<>("Current transaction isolation level");
private static final ThreadLocal actualTransactionActive =
		new NamedThreadLocal<>("Actual transaction active");

对于事务资源，TransactionSynchronizationManager中负责提供资源获取、绑定、解绑等接口

@Nullable
public static Object getResource(Object key) {
	Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
	return doGetResource(actualKey);
}

@Nullable
private static Object doGetResource(Object actualKey) {
	Map map = resources.get();
	if (map == null) {
		return null;
	}
	Object value = map.get(actualKey);
	// Transparently remove ResourceHolder that was marked as void...
	if (value instanceof ResourceHolder && ((ResourceHolder) value).isVoid()) {
		map.remove(actualKey);
		// Remove entire ThreadLocal if empty...
		if (map.isEmpty()) {
			resources.remove();
		}
		value = null;
	}
	return value;
}

public static void bindResource(Object key, Object value) throws IllegalStateException {
	Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
	Assert.notNull(value, "Value must not be null");
	Map map = resources.get();
	// set ThreadLocal Map if none found
	if (map == null) {
		map = new HashMap<>();
		resources.set(map);
	}
	Object oldValue = map.put(actualKey, value);
	// Transparently suppress a ResourceHolder that was marked as void...
	if (oldValue instanceof ResourceHolder && ((ResourceHolder) oldValue).isVoid()) {
		oldValue = null;
	}
	if (oldValue != null) {
		throw new IllegalStateException(
				"Already value [" + oldValue + "] for key [" + actualKey + "] bound to thread");
	}
}

public static Object unbindResource(Object key) throws IllegalStateException {
	Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
	Object value = doUnbindResource(actualKey);
	if (value == null) {
		throw new IllegalStateException("No value for key [" + actualKey + "] bound to thread");
	}
	return value;
}

@Nullable
private static Object doUnbindResource(Object actualKey) {
	Map map = resources.get();
	if (map == null) {
		return null;
	}
	Object value = map.remove(actualKey);
	// Remove entire ThreadLocal if empty...
	if (map.isEmpty()) {
		resources.remove();
	}
	// Transparently suppress a ResourceHolder that was marked as void...
	if (value instanceof ResourceHolder && ((ResourceHolder) value).isVoid()) {
		value = null;
	}
	return value;
}

对于事务同步，TransactionSynchronizationManager中负责提供：事务同步激活、事务同步注册、获取事务同步列表、判断当前事务同步是否为活跃的等。

实际上就是给synchronizations放入一个linkedHashSet

public static void initSynchronization() throws IllegalStateException {
	if (isSynchronizationActive()) {
		throw new IllegalStateException("Cannot activate transaction synchronization - already active");
	}
	synchronizations.set(new linkedHashSet<>());
}

从当前线程中取出set集合，并为其添加一个TransactionSynchronization对象

public static void registerSynchronization(TransactionSynchronization synchronization)
		throws IllegalStateException {
	Assert.notNull(synchronization, "TransactionSynchronization must not be null");
	Set synchs = synchronizations.get();
	if (synchs == null) {
		throw new IllegalStateException("Transaction synchronization is not active");
	}
	synchs.add(synchronization);
}

public static List getSynchronizations() throws IllegalStateException {
	Set synchs = synchronizations.get();
	if (synchs == null) {
		throw new IllegalStateException("Transaction synchronization is not active");
	}
	// Return unmodifiable snapshot, to avoid ConcurrentModificationExceptions
	// while iterating and invoking synchronization callbacks that in turn
	// might register further synchronizations.
	if (synchs.isEmpty()) {
		return Collections.emptyList();
	}
	else {
		// Sort lazily here, not in registerSynchronization.
		List sortedSynchs = new ArrayList<>(synchs);
		OrderComparator.sort(sortedSynchs);
		return Collections.unmodifiableList(sortedSynchs);
	}
}

public static boolean isSynchronizationActive() {
	return (synchronizations.get() != null);
}

这两个属性分别记录当前线程事务是否只读状态和其隔离级别

public static void setCurrentTransactionReadOnly(boolean readOnly) {
	currentTransactionReadOnly.set(readonly ? Boolean.TRUE : null);
}

public static void setCurrentTransactionIsolationLevel(@Nullable Integer isolationLevel) {
	currentTransactionIsolationLevel.set(isolationLevel);
}

actualTransactionActive用于记录当前线程是否有实际活动的事务，

public static void setActualTransactionActive(boolean active) {
	actualTransactionActive.set(active ? Boolean.TRUE : null);
}

与isSynchronizationActive相比，线程可能存在活跃的事务，但如果当前线程的事务被挂起，那么就不是实际活跃的事务了，所以对于被挂起的线程调用isSynchronizationActive返回true，调用isActualTransactionActive则返回false

public static boolean isActualTransactionActive() {
	return (actualTransactionActive.get() != null);
}

最后，事务提交后，TransactionSynchronizationManager提供了清除当前线程事务同步数据的方法。

public static void clear() {
	synchronizations.remove();
	currentTransactionName.remove();
	currentTransactionReadOnly.remove();
	currentTransactionIsolationLevel.remove();
	actualTransactionActive.remove();
}