ThreadLocal-分析-总结

最新推荐文章于 2025-08-21 16:15:25 发布
最新推荐文章于 2025-08-21 16:15:25 发布
阅读量84 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 多线程 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/iteye_21015/article/details/82235261
本文详细解析了ThreadLocal的工作原理，包括其内部实现机制及如何避免内存泄漏等问题，并通过示例展示了ThreadLocal在Spring和Hibernate等框架中的实际应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

==============转载: 讨论帖 http://www.iteye.com/topic/777716==================

 

ThreadLocal<T>类在Spring，Hibernate等框架中起到了很大的作用，对于其工作原理，很多网上的文章分析的不够彻底，甚至有些误解。

 

首先，为了解释ThreadLocal类的工作原理，必须同时介绍与其工作甚密的其他几个类（内部类）

1.ThreadLocalMap

2.Thread

可能有人会觉得Thread与ThreadLocal有什么关系，其实真正的奥秘就在Thread类中的一行：

 

Java代码 复制代码   收藏代码
  1. ThreadLocal.ThreadLocalMap threadLocals =  null ;   
ThreadLocal.ThreadLocalMap threadLocals = null;

 

 其中ThreadLocalMap的定义是在ThreadLocal类中，真正的引用却是在Thread类中

 

那么ThreadLocalMap究竟是什么呢？

 

可以看到这个类应该是一个Map,JDK的解释是

 

 写道
ThreadLocalMap is a customized hash map suitable only for maintaining thread local values
 

 

接下来的重点是ThreadLocalMap中用于存储数据的entry

 

Java代码 复制代码   收藏代码
  1. static   class  Entry  extends  WeakReference<ThreadLocal> {   
  2.              /** The value associated with this ThreadLocal. */   
  3.             Object value;   
  4.   
  5.             Entry(ThreadLocal k, Object v) {   
  6.                  super (k);   
  7.                 value = v;   
  8.             }   
  9.         }   
static class Entry extends WeakReference<ThreadLocal> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal k, Object v) {
                super(k);
                value = v;
            }
        }

 

 从中我们可以发现这个Map的key是ThreadLocal变量，value为用户的值，并不是网上大多数的列子key是线程的名字或者标识

 

到这里，我们就可以理解ThreadLocal究竟是如何工作的了

 

1.Thread类中有一个成员变量叫做ThreadLocalMap，它是一个Map，他的Key是ThreadLocal类

2.每个线程拥有自己的申明为ThreadLocal类型的变量,所以这个类的名字叫'ThreadLocal'：线程自己的（变量）

3.此变量生命周期是由该线程决定的，开始于第一次初始（get或者set方法）

4.由ThreadLocal的工作原理决定了：每个线程独自拥有一个变量，并非共享或者拷贝

 

Java代码 复制代码   收藏代码
  1. /**  
  2.  * @author mxdba  
  3.  *  
  4.  */   
  5. public   class  ThreadLocalSample {   
  6.   
  7.      public   static   void  main(String[] args) {   
  8.         ThreadTest test1 =  new  ThreadTest( 10 );   
  9.         ThreadTest test2 =  new  ThreadTest( 20 );   
  10.         test1.start();   
  11.         test2.start();   
  12.     }   
  13.   
  14. }   
  15.   
  16. /**  
  17.  * 此线程有两个ThreadLocal变量，但是由于ThreadLocal是延迟初始的，  
  18.  * 所以在debug时可以看到线程名为“线程20”的线程的ThreadLocalMap中没有thLcal2这个entry  
  19.  * @author mxdba  
  20.  *   
  21.  */   
  22. class  ThreadTest  extends  Thread {   
  23.        
  24.      public   static  ThreadLocal<Integer> thLocal =  new  ThreadLocal<Integer>();   
  25.      public   static  ThreadLocal<String> thLocal2 =  new  ThreadLocal<String>();   
  26.        
  27.      public  Integer num;   
  28.        
  29.        
  30.        
  31.      public  ThreadTest(Integer num) {   
  32.          super ( "线程"  + num);   
  33.          this .num = num;   
  34.     }   
  35.   
  36.      @Override   
  37.      public   void  run() {   
  38.         Integer n = thLocal.get();   
  39.          if (num !=  20 ) {   
  40.             String s = thLocal2.get();   
  41.         }   
  42.                
  43.          if (n ==  null ) {   
  44.             thLocal.set(num);   
  45.         }   
  46.         System.out.println(thLocal.get());   
  47.     }   
  48.        
  49. }   
/**
 * @author mxdba
 *
 */
public class ThreadLocalSample {

	public static void main(String[] args) {
		ThreadTest test1 = new ThreadTest(10);
		ThreadTest test2 = new ThreadTest(20);
		test1.start();
		test2.start();
	}

}

/**
 * 此线程有两个ThreadLocal变量，但是由于ThreadLocal是延迟初始的，
 * 所以在debug时可以看到线程名为“线程20”的线程的ThreadLocalMap中没有thLcal2这个entry
 * @author mxdba
 * 
 */
class ThreadTest extends Thread {
	
	public static ThreadLocal<Integer> thLocal = new ThreadLocal<Integer>();
	public static ThreadLocal<String> thLocal2 = new ThreadLocal<String>();
	
	public Integer num;
	
	
	
	public ThreadTest(Integer num) {
		super("线程" + num);
		this.num = num;
	}

	@Override
	public void run() {
		Integer n = thLocal.get();
		if(num != 20) {
			String s = thLocal2.get();
		}
			
		if(n == null) {
			thLocal.set(num);
		}
		System.out.println(thLocal.get());
	}
	
}

 

 

接下来分析一下源码，就更加清楚了

 

关键方法代码 复制代码   收藏代码
  1. /**   
  2.  * 关键方法，返回当前Thread的ThreadLocalMap   
  3.  * [[[每个Thread返回各自的ThreadLocalMap，所以各个线程中的ThreadLocal均为独立的]]]   
  4.  */   
  5. ThreadLocalMap getMap(Thread t) {   
  6.         return t.threadLocals;   
  7.     }   
/**
 * 关键方法，返回当前Thread的ThreadLocalMap
 * [[[每个Thread返回各自的ThreadLocalMap，所以各个线程中的ThreadLocal均为独立的]]]
 */
ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }
 

 

 

 

Threadlocal的get方法代码 复制代码   收藏代码
  1. public T get() {   
  2.         Thread t = Thread.currentThread();   
  3.         /**   
  4.          * 得到当前线程的ThreadLocalMap   
  5.          */   
  6.         ThreadLocalMap map = getMap(t);   
  7.         if (map != null) {   
  8.             /**   
  9.              * 在此线程的ThreadLocalMap中查找key为当前ThreadLocal对象的entry   
  10.              */   
  11.             ThreadLocalMap.Entry e = map.getEntry(this);   
  12.             if (e != null)   
  13.                 return (T)e.value;   
  14.         }   
  15.         return setInitialValue();   
  16.     }   
public T get() {
        Thread t = Thread.currentThread();
        /**
         * 得到当前线程的ThreadLocalMap
         */
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            /**
             * 在此线程的ThreadLocalMap中查找key为当前ThreadLocal对象的entry
             */
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null)
                return (T)e.value;
        }
        return setInitialValue();
    }
 

 

 

 

初始化方法代码 复制代码   收藏代码
  1. private T setInitialValue() {   
  2.         /**   
  3.          * 默认返回null，这个方法为protected可以继承   
  4.          */   
  5.         T value = initialValue();   
  6.         Thread t = Thread.currentThread();   
  7.         ThreadLocalMap map = getMap(t);   
  8.         if (map != null)   
  9.             map.set(this, value);   
  10.         else   
  11.             /**   
  12.              * 初次创建   
  13.              */   
  14.             createMap(t, value);   
  15.         return value;   
  16.     }   
private T setInitialValue() {
        /**
         * 默认返回null，这个方法为protected可以继承
         */
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            /**
             * 初次创建
             */
            createMap(t, value);
        return value;
    }
 

 

 

Java代码 复制代码   收藏代码
  1. /**  
  2.  * 给当前thread初始ThreadlocalMap  
  3.  */   
  4. void  createMap(Thread t, T firstValue) {   
  5.         t.threadLocals =  new  ThreadLocalMap( this , firstValue);   
  6.     }   
/**
 * 给当前thread初始ThreadlocalMap
 */
void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }
 

 

 

通过上边的分析，我们发现，ThreadLocal类的使用虽然是用来解决多线程的问题的，但是还是有很明显的针对性

1.最明显的，ThreadLoacl变量的活动范围为某线程，并且我的理解是该线程“专有的，独自霸占”，对该变量的所有操作均有该线程完成！ 也就是说，ThreadLocal不是用来解决共享，竞争问题的。典型的应用莫过于Spring，Hibernate等框架中对于多线程的处理了。

下面来看一个 hibernate 中典型的 ThreadLocal 的应用：

 

Java代码 复制代码   收藏代码
  1. private   static   final  ThreadLocal threadSession =  new  ThreadLocal();     
  2.      
  3. public   static  Session getSession()  throws  InfrastructureException {     
  4.     Session s = (Session) threadSession.get();     
  5.      try  {     
  6.          if  (s ==  null ) {     
  7.             s = getSessionFactory().openSession();     
  8.             threadSession.set(s);     
  9.         }     
  10.     }  catch  (HibernateException ex) {     
  11.          throw   new  InfrastructureException(ex);     
  12.     }     
  13.      return  s;     
  14. }     
private static final ThreadLocal threadSession = new ThreadLocal();  
  
public static Session getSession() throws InfrastructureException {  
    Session s = (Session) threadSession.get();  
    try {  
        if (s == null) {  
            s = getSessionFactory().openSession();  
            threadSession.set(s);  
        }  
    } catch (HibernateException ex) {  
        throw new InfrastructureException(ex);  
    }  
    return s;  
}

 这段代码，每个线程有自己的ThreadLocalMap，每个ThreadLocalMap中根据需要初始加载threadSession,这样的好处就是介于singleton与prototype之间，应用singleton无法解决线程，应用prototype开销又太大，有了ThreadLocal之后就好了，对于需要线程“霸占”的变量用ThreadLocal，而该类实例的方法均可以共享。

 

2.关于内存泄漏：

虽然ThreadLocalMap已经使用了weakReference，但是还是建议能够显示的使用remove方法。

 

 

==============转载: 讨论帖 http://ari.iteye.com/blog/757478==================

 

一、ThreadLocal概述

       学习JDK中的类，首先看下JDK API对此类的描述，描述如下：

JDK API 写道
该类提供了线程局部 (thread-local) 变量。这些变量不同于它们的普通对应物，因为访问某个变量（通过其 get 或 set 方法）的每个线程都有自己的局部变量，它独立于变量的初始化副本。ThreadLocal 实例通常是类中的 private static 字段，它们希望将状态与某一个线程（例如，用户 ID 或事务 ID）相关联。

    API表达了下面几种观点：

1、ThreadLocal不是线程，是线程的一个变量，你可以先简单理解为线程类的属性变量。

2、ThreadLocal 在类中通常定义为静态类变量。

3、每个线程有自己的一个ThreadLocal，它是变量的一个‘拷贝’，修改它不影响其他线程。

 

    既然定义为类变量，为何为每个线程维护一个副本（姑且成为‘拷贝’容易理解），让每个线程独立访问？多线程编程的经验告诉我们，对于线程共享资源（你可以理解为属性），资源是否被所有线程共享，也就是说这个资源被一个线程修改是否影响另一个线程的运行，如果影响我们需要使用synchronized同步，让线程顺序访问。

 

   ThreadLocal适用于资源共享但不需要维护状态的情况，也就是一个线程对资源的修改，不影响另一个线程的运行；这种设计是‘空间换时间’ ，synchronized顺序执行是‘时间换取空间’ 。

 

二、ThreadLocal方法介绍

 

 

 T get ()
          返回此线程局部变量的当前线程副本中的值。
protected  T initialValue ()
          返回此线程局部变量的当前线程的“初始值”。
 void remove ()
          移除此线程局部变量当前线程的值。
 void set (T  value)
          将此线程局部变量的当前线程副本中的值设置为指定值。

 

三、深入源码

    ThreadLocal有一个ThreadLocalMap静态内部类，你可以简单理解为一个MAP，这个‘Map’为每个线程复制一个变量的‘拷贝’存储其中。

    当线程调用ThreadLocal.get()方法获取变量时,首先获取当前线程引用，以此为key去获取响应的ThreadLocalMap，如果此‘Map’不存在则初始化一个，否则返回其中的变量，代码如下：

 

Get方法代码 复制代码   收藏代码
  1. public T get() {   
  2.        Thread t = Thread.currentThread();   
  3.        ThreadLocalMap map = getMap(t);   
  4.        if (map != null) {   
  5.            ThreadLocalMap.Entry e = map.getEntry(this);   
  6.            if (e != null)   
  7.                return (T)e.value;   
  8.        }   
  9.        return setInitialValue();   
  10. }   
 public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null)
                return (T)e.value;
        }
        return setInitialValue();
 }

    调用get方法如果此Map不存在首先初始化，创建此map，将线程为key，初始化的vlaue存入其中，注意此处的initialValue，我们可以覆盖此方法，在首次调用时初始化一个适当的值。setInitialValue代码如下：

Java代码 复制代码   收藏代码
  1. private  T setInitialValue() {   
  2.     T value = initialValue();   
  3.     Thread t = Thread.currentThread();   
  4.     ThreadLocalMap map = getMap(t);   
  5.      if  (map !=  null )   
  6.         map.set( this , value);   
  7.      else   
  8.         createMap(t, value);   
  9.      return  value;   
  10. }   
    private T setInitialValue() {
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
        return value;
    }

 

    set方法相对比较简单如果理解以上俩个方法，获取当前线程的引用，从map中获取该线程对应的map，如果map存在更新缓存值，否则创建并存储，代码如下：

Java代码 复制代码   收藏代码
  1. public   void  set(T value) {   
  2.     Thread t = Thread.currentThread();   
  3.     ThreadLocalMap map = getMap(t);   
  4.      if  (map !=  null )   
  5.         map.set( this , value);   
  6.      else   
  7.         createMap(t, value);   
  8. }   
    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

 

    对于ThreadLocal在何处存储变量副本，我们看getMap方法：获取的是当前线程的ThreadLocal类型的threadLocals属性。显然变量副本存储在每一个线程中。

 

Java代码 复制代码   收藏代码
  1. /**  
  2.  * 获取线程的ThreadLocalMap 属性实例  
  3.  */   
  4. ThreadLocalMap getMap(Thread t) {   
  5.          return  t.threadLocals;   
  6.   }   
/**
 * 获取线程的ThreadLocalMap 属性实例
 */
ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
  }

 

    上面我们知道变量副本存放于何处，这里我们简单说下如何被java的垃圾收集机制收集，当我们不在使用是调用set(null)，此时不在将引用指向该‘map’，而线程退出时会执行资源回收操作，将申请的资源进行回收，其实就是将属性的引用设置为null。这时已经不在有任何引用指向该map，故而会被垃圾收集。

 

 四、ThreadLocal应用示例

 

      在我的另一篇文章，对ThreadLocal的使用做了一个实例，此示例也可以用作生产环境，请参见：http://ari.iteye.com/blog/757641

 

 

【转】ThreadLocal-分析-总结
aoci4631的博客
04-08 124
【转】ThreadLocal-分析-总结 ThreadLocal<T>类在Spring，Hibernate等框架中起到了很大的作用，对于其工作原理，很多网上的文章分析的不够彻底，甚至有些误解。 首先，为了解释ThreadLocal类的工作原理，必...
ThreadLocal-分析-总结以及使用场合
new03的专栏
05-26 184
首先，ThreadLocal 不是用来解决共享对象的多线程访问问题的，一般情况下，通过ThreadLocal.set() 到线程中的对象是该线程自己使用的对象，其他线程是不需要访问的，也访问不到的。各个线程中访问的是不同的对象。   Thread与ThreadLocal有什么关系？ 其实真正的奥秘就在Thread类中的一行： ThreadLocal.ThreadLocalMap thr...
threadlocal - 黑马程序员
白羊座的橙子
12-03 1292
}* }* . . .​ 从Java官方文档中的描述：ThreadLocal类用来提供线程内部的局部变量。这种变量在多线程环境下访问（通过get和set方法访问）时能保证各个线程的变量相对独立于其他线程内的变量。ThreadLocal实例通常来说都是private static类型的，用于关联线程和线程上下文。
ThreadLocal-分析-总结（转）
先相信你自己，然后别人才会相信你。
04-16 231
ThreadLocal&lt;T&gt;类在Spring，Hibernate等框架中起到了很大的作用，对于其工作原理，很多网上的文章分析的不够彻底，甚至有些误解。   首先，为了解释ThreadLocal类的工作原理，必须同时介绍与其工作甚密的其他几个类（内部类） 1.ThreadLocalMap 2.Thread 可能有人会觉得Thread与ThreadLocal有什么关系，其实真...
(转) ThreadLocal-分析-总结
【昆山人在上海】
10-06 494
ThreadLocal-分析-总结
ThreadLocal--ThreadLocal 竟可能导致内存泄漏？看看 ThreadLocalMap 的弱引用机制
你我约定有三的博客
07-26 1361
ThreadLocal通过为每个线程创建变量副本来实现线程隔离，底层使用ThreadLocalMap存储数据，其Entry的key采用弱引用防止内存泄漏。当ThreadLocal对象失去强引用时，GC会回收key，但value需依赖get/set/remove触发清理。最佳实践包括：1）使用static final修饰ThreadLocal保证单例；2）及时调用remove()避免内存泄漏；3）注意线程池场景下的数据残留问题。典型应用如Spring中的用户信息存储，需确保线程间正确访问同一ThreadLoc
ThreadLocal原理分析--结合Spring事务
okok__TXF的博客
05-12 846
ThreadLocal 是 Java 中用于实现线程局部变量的工具，它为每个线程提供独立的变量副本，确保线程间的数据隔离，从而避免多线程环境下的共享变量问题。通过 set()、get() 和 remove() 方法，线程可以操作自己的局部变量，而不会影响其他线程。ThreadLocal 的核心思想是通过 ThreadLocalMap 存储每个线程的变量副本，键为 ThreadLocal 对象，值为变量值。
【实时Linux实战系列】基于实时Linux的自适应控制系统
望获实时Linux系统
08-19 908
本文介绍了基于实时Linux的自适应控制系统开发技术，重点阐述了其在工业自动化、航空航天等领域的应用价值。文章详细说明了环境准备、案例实现步骤和调试方法，包括温度自适应控制系统的开发过程，涉及实时任务调度、传感器数据采集和PWM控制等关键技术。同时提供了常见问题的解决方案和性能优化建议，为开发者掌握这一技术提供了实用指导。该技术能显著提升系统响应速度和稳定性，适用于需要高精度实时控制的各类场景。
深入理解 Spring 的 @ControllerAdvice
Roc的博客
08-20 647
简单来说，是一个组件注解（被@Component元注解标注），它允许你将一个类声明为一个全局的、跨多个控制器的增强器（Advice）。你可以把它理解为 Spring MVC 版本的AOP（面向切面编程），但它不是基于代理，而是专门为控制器层设计的。全局异常处理全局数据绑定全局数据预处理命名清晰：类名如，明确其职责。区分使用场景开发，优先使用，专注于返回统一的 JSON 异常响应。开发传统多页应用，使用，可以混合处理异常、绑定模型等。避免过度使用。
08.常见文本处理工具
weixin_56408536的博客
08-18 786
查看二进制文件的不同。
java基础知识总结
yvya_的博客
08-19 1399
java 基础包含语法、面向对象，异常处理、文件操作等方面。
Java虚拟机故障处理工具全指南
qq_73993301的博客
08-20 893
JVM故障处理工具全景指南：从基础到高阶诊断 本文系统介绍了JVM提供的故障诊断工具链，包括命令行工具（jps、jstat、jinfo、jmap、jhat、jstack、jcmd）和可视化工具（jconsole、VisualVM）。详细解析了各工具的核心功能和使用场景：jps用于进程查看、jstat监控GC行为、jmap生成堆转储等。文章提供了实战建议，强调基线数据收集和工具组合使用的重要性，并指出生产环境的使用注意事项。最后还介绍了远程连接、自动化分析等高级技巧，推荐结合Arthas、MAT等专业工具进行
【MyBatis-Plus】二、核心功能
m0_72516377的博客
08-19 614
MyBatis-Plus条件构造器提供强大的SQL条件构建能力，支持复杂查询和更新操作。核心功能包括QueryWrapper和UpdateWrapper，提供eq/ne/gt/ge等条件拼接方法，支持链式调用和Lambda表达式。QueryWrapper用于构建查询条件，支持字段过滤和排序；UpdateWrapper支持特殊更新操作如字段自减。两种构造器都采用构建器模式，调用顺序不影响最终SQL结构。Lambda条件构造器能避免字符串硬编码，推荐使用。典型应用场景包括多条件组合查询、字段批量更新等，显著简化
我的SSM框架自学2
lrk__的博客
08-19 807
浏览器缓存也就是用户在访问浏览器的页面时，会把页面的资源保存在本地缓存中，下一次在访问相同的页面时，不会从服务器中重新获取，而是从本地缓存中获取；那MyBatis的缓存就是把MyBatis所查询的数据存储在缓存中，如果下一次查询还是相同的数据则从缓存中取；底层是代理模式，把非核心业务代码抽取出来交给切面类管理，并不是抽取出来就完了，而是要把它套在抽取出来的位置，也就是在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。
Mybatis批量插入，形式不同性能也不同
static_coder的博客
08-18 1000
批量插入面对小数据量的时，几乎没有任何区别，可以随意使用。一旦数据量比较大时，我们就需要斟酌，选择合适的插入方法，可以帮我们节省很多资源和时间。这样的脚本，适用于数据量不大的情况，基本满足业务需求，但是却存在安全隐患。上面的这种写法确实比一条条的数据入库的速度快太多，我们这里只横向对比不同的批量插入。从运行的结果来看，这种方式才是类似我们手搓的的脚本，效率杠杠的。所以呢，当一次插入的数据达到一定的数据就会出现异常。本节，我们将对比不同的写法以及响应的时间的消耗。接收和发送的最大数据包的大小，默认64M。
健康常识查询系统|基于java和小程序的健康常识查询系统设计与实现(源码+数据库+文档)
伟庭的博客
08-21 386
本文介绍了一款基于Java和微信小程序的健康常识查询系统设计与实现。系统采用B/S架构，使用MySQL数据库，包含用户端和管理端两大模块。用户可通过小程序查看健康资讯、进行论坛交流、在线咨询及管理健康档案；管理员通过Web端实现用户管理、公告发布等功能。系统设计包含详细的功能结构图、界面展示和ER图，并提供了核心代码示例。该系统旨在为用户提供便捷的健康管理工具，满足现代人对健康信息查询和管理的需求。
java-ArrayList的使用
最新发布
m0_52132903的博客
08-21 216
java-代码随想录第十四天| 二叉树层序遍历相关题目
qq_57465625的博客
08-20 846
本文介绍了二叉树的基本概念和常见算法题解。基本概念部分阐明了深度（从根节点到该节点的路径长度）和高度（从该节点到最远叶子节点的路径长度）的定义与计算方法。算法题解包括：1）226.翻转二叉树的递归解法；2）101.对称二叉树的递归判断方法；3）104.二叉树最大深度的递归计算；4）111.二叉树最小深度的递归解法，特别处理了单子树为空的情况。所有解法均采用分治思想，通过递归实现，并附有详细注释说明。
50.Seata-AT模式
卷土的博客
08-20 68
AT模式同样是分阶段提交的事务模型。优势是。没有代码入侵，框架自动完成快照生成、回滚和提交。实现非常简单。两阶段之间属于软状态，属于最终一致。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值