lifallen
lifallen

揭秘Netty高性能线程本地存储机制：FastThreadLocal

InternalThreadLocalMap

InternalThreadLocalMap 是 Netty 中一个非常核心的内部工具类，是一个最终类，用于存储 Netty 和所有 FastThreadLocal 的线程本地变量。

它为 Netty 自身的组件以及用户定义的 FastThreadLocal 变量提供了一个高性能的线程本地存储机制。它的设计目标是优化标准 java.lang.ThreadLocal 在高并发和大量线程本地变量场景下的性能。

核心设计思想

  1. 数组替代 ThreadLocalMap: JDK 的 ThreadLocal 内部使用一个 ThreadLocalMap (基于哈希表) 来存储每个线程的本地变量。当 ThreadLocal 实例很多时，哈希冲突和查找开销可能会增加。InternalThreadLocalMap 则主要使用一个对象数组Object[ ] (indexedVariables) 来存储这些变量。每个 FastThreadLocal 实例在创建时都会获得一个唯一的、全局递增的索引 (index)，这个索引直接对应到 indexedVariables 数组的下标。这样，获取线程本地变量就变成了简单的数组访问操作，速度非常快。

  2. FastThreadLocalThread 优化: Netty 引入了 FastThreadLocalThread。如果当前线程是 FastThreadLocalThread 的实例，那么 InternalThreadLocalMap 实例会直接作为该线程的一个成员变量存在，访问速度更快，避免了 ThreadLocal.get() 的开销。

  3. 兼容普通线程: 对于非 FastThreadLocalThread 的普通线程，InternalThreadLocalMap 会退化为使用一个标准的 ThreadLocal (slowThreadLocalMap) 来存储其实例，保证了兼容性。

  4. 预定义和缓存常用对象: InternalThreadLocalMap 内部还预定义了一些 Netty 核心组件会频繁使用的线程本地对象，例如 StringBuilder、CharsetEncoder/CharsetDecoder 缓存、ArrayList 等。通过复用这些对象，可以减少对象创建和垃圾回收的开销。

静态成员

private static final ThreadLocal slowThreadLocalMap = new ThreadLocal<>();
private static final AtomicInteger nextIndex = new AtomicInteger();
public static final int VARIABLES_TO_REMOVE_INDEX = nextVariableIndex();
private static final int DEFAULT_ARRAY_LIST_INITIAL_CAPACITY = 8;
private static final int ARRAY_LIST_CAPACITY_EXPAND_THRESHOLD = 1 << 30;
private static final int ARRAY_LIST_CAPACITY_MAX_SIZE = Integer.MAX_VALUE - 8;
private static final int HANDLER_SHARABLE_CACHE_INITIAL_CAPACITY = 4;
private static final int INDEXED_VARIABLE_TABLE_INITIAL_SIZE = 32;
private static final int STRING_BUILDER_INITIAL_SIZE;
private static final int STRING_BUILDER_MAX_SIZE;
private static final InternalLogger logger;
public static final Object UNSET = new Object();
  • slowThreadLocalMap：普通线程使用的 ThreadLocal，用于存储 InternalThreadLocalMap 实例。
  • nextIndex：原子整数，用于生成下一个变量索引。
  • VARIABLES_TO_REMOVE_INDEX：需要移除的变量的索引。
  • 各种常量：定义了数组列表初始容量、扩展阈值、最大容量等配置。
  • STRING_BUILDER_INITIAL_SIZE 和 STRING_BUILDER_MAX_SIZE：StringBuilder 的初始大小和最大大小，从系统属性获取。
  • logger：日志记录器。
  • UNSET：表示变量未设置的特殊对象。

实例成员

InternalThreadLocalMap.java

private Object[] indexedVariables;
private int futureListenerStackDepth;
private int localChannelReaderStackDepth;
private Map, Boolean> handlerSharableCache;
private Map, TypeParameterMatcher> typeParameterMatcherGetCache;
private Map, Map> typeParameterMatcherFindCache;
private StringBuilder stringBuilder;
private Map charsetEncoderCache;
private Map charsetDecoderCache;
private ArrayList arrayList;
private BitSet cleanerFlags;
 
  
     
   
  • indexedVariables：用于存储线程本地变量的数组。
    •  
   
  • futureListenerStackDepth 和 localChannelReaderStackDepth：分别表示未来监听器栈深度和本地通道读取器栈深度。
    •  
   
  • 各种缓存：用于存储处理器共享信息、类型参数匹配器等。
    •  
   
  • stringBuilder：线程本地的 StringBuilder。
    •  
   
  • charsetEncoderCache 和 charsetDecoderCache：字符集编码和解码器缓存。
    •  
   
  • arrayList：线程本地的 ArrayList。
    •  
   
  • cleanerFlags：用于标记清理标志的 BitSet。
    •  
  
 
  
getIfSet() 和 get()
 
  
InternalThreadLocalMap.java
 
  
public static InternalThreadLocalMap getIfSet() {
    Thread thread = Thread.currentThread();
    if (thread instanceof FastThreadLocalThread) {
        return ((FastThreadLocalThread) thread).threadLocalMap();
    }
    return slowThreadLocalMap.get();
}

public static InternalThreadLocalMap get() {
    Thread thread = Thread.currentThread();
    if (thread instanceof FastThreadLocalThread) {
        return fastGet((FastThreadLocalThread) thread);
    } else {
        return slowGet();
    }
}

 
  
     
   
  • getIfSet()：获取当前线程的 InternalThreadLocalMap 实例，如果不存在则返回 null。
    •  
   
  • get()：获取当前线程的 InternalThreadLocalMap 实例，如果不存在则创建一个新的实例。
    •  
  
 
  
fastGet() 和 slowGet()
 
  
InternalThreadLocalMap.java
 
  
private static InternalThreadLocalMap fastGet(FastThreadLocalThread thread) {
    InternalThreadLocalMap threadLocalMap = thread.threadLocalMap();
    if (threadLocalMap == null) {
        thread.setThreadLocalMap(threadLocalMap = new InternalThreadLocalMap());
    }
    return threadLocalMap;
}

private static InternalThreadLocalMap slowGet() {
    InternalThreadLocalMap ret = slowThreadLocalMap.get();
    if (ret == null) {
        ret = new InternalThreadLocalMap();
        slowThreadLocalMap.set(ret);
    }
    return ret;
}

 
  
     
   
  • fastGet()：为 FastThreadLocalThread 快速获取或创建 InternalThreadLocalMap 实例。
    •  
   
  • slowGet()：为普通线程获取或创建 InternalThreadLocalMap 实例。
    •  
  
 
  
setIndexedVariable() 和 getAndSetIndexedVariable()
 
  
InternalThreadLocalMap.java
 
  
public boolean setIndexedVariable(int index, Object value) {
    return getAndSetIndexedVariable(index, value) == UNSET;
}

public Object getAndSetIndexedVariable(int index, Object value) {
    Object[] lookup = indexedVariables;
    if (index < lookup.length) {
        Object oldValue = lookup[index];
        lookup[index] = value;
        return oldValue;
    }
    expandIndexedVariableTableAndSet(index, value);
    return UNSET;
}

 
  
     
   
  • setIndexedVariable()：设置指定索引的线程本地变量，如果是新变量则返回 true。
    •  
   
  • getAndSetIndexedVariable()：设置指定索引的线程本地变量，并返回旧值。如果是新变量则返回 UNSET。
    •  
  
 
  
expandIndexedVariableTableAndSet()
 
  
InternalThreadLocalMap.java
 
  
 
  
private void expandIndexedVariableTableAndSet(int index, Object value) {
    Object[] oldArray = indexedVariables;
    final int oldCapacity = oldArray.length;
    int newCapacity;
    if (index < ARRAY_LIST_CAPACITY_EXPAND_THRESHOLD) {
        newCapacity = index;
        newCapacity |= newCapacity >>>  1;
        newCapacity |= newCapacity >>>  2;
        newCapacity |= newCapacity >>>  4;
        newCapacity |= newCapacity >>>  8;
        newCapacity |= newCapacity >>> 16;
        newCapacity ++;
    } else {
        newCapacity = ARRAY_LIST_CAPACITY_MAX_SIZE;
    }

    Object[] newArray = Arrays.copyOf(oldArray, newCapacity);
    Arrays.fill(newArray, oldCapacity, newArray.length, UNSET);
    newArray[index] = value;
    indexedVariables = newArray;
}

 
  
该方法用于扩展 indexedVariables 数组的容量，并设置指定索引的变量值。
 
  
 
  
 
  
 
  
 
  
 
  
关键实现细节
 
  
     
   
  1.  
    UNSET 对象: 这是一个特殊的静态对象，用于表示 indexedVariables 数组中某个索引位置尚未被设置，或者已被移除。这比使用 null 更好，因为 null 本身可能是一个合法的线程本地变量值。
     
    2.  
   
  2.  
    nextVariableIndex() 和 index: 每个 FastThreadLocal 实例在构造时都会调用 InternalThreadLocalMap.nextVariableIndex() 来获取一个全局唯一的整数索引。这个索引直接用于在 InternalThreadLocalMap 的 indexedVariables 数组中定位该 FastThreadLocal 变量的值。
     
    3.  
   
  3.  
    数组扩容 (expandIndexedVariableTableAndSet): 当一个 FastThreadLocal 的索引超出了当前 indexedVariables 数组的长度时，会触发数组扩容。扩容策略是找到一个大于等于当前索引的最小的2的幂次方作为新容量（有一个上限 ARRAY_LIST_CAPACITY_MAX_SIZE）。新数组会复制旧数组的内容，并将新增的部分用 UNSET 对象填充。
     
    4.  
   
  4.  
    VARIABLES_TO_REMOVE_INDEX: 这是一个特殊的索引，其对应的值是一个 Set>。这个集合用于存储那些需要被清理的 FastThreadLocal 实例。当调用 FastThreadLocal.removeAll() 或 FastThreadLocalThread 结束时，会遍历这个集合并移除相应的线程本地变量，防止内存泄漏。
     
    5.  
   
  5.  
    预定义对象的复用:
     
    
       
     
    • stringBuilder(): 提供一个可复用的 StringBuilder。每次获取时，如果已存在，会清空其内容并检查容量是否过大。
      •  
     
    • charsetEncoderCache() / charsetDecoderCache(): 提供 CharsetEncoder 和 CharsetDecoder 的缓存，使用 IdentityHashMap 是因为 Charset 对象通常是单例的，可以安全地用作键。
      •  
     
    • arrayList(): 提供一个可复用的 ArrayList。
      •  
     
    • handlerSharableCache(): 使用 WeakHashMap 缓存 ChannelHandler 是否标记为 @Sharable。WeakHashMap 的键是弱引用，当 Class 对象不再被其他地方强引用时，可以被垃圾回收，从而避免内存泄漏。
      •  
    
     
    6.  
  
 
  
继承 UnpaddedInternalThreadLocalMap:
 
  
UnpaddedInternalThreadLocalMap.java
 
  
// ... existing code ...
/**
 * @deprecated This class will be removed in the future.
 */
class UnpaddedInternalThreadLocalMap {
    // We cannot remove this in 4.1 because it could break compatibility.
}

 
  
这个父类目前是空的，并且被标记为 @deprecated。它的存在主要是为了向后兼容。在早期版本中，InternalThreadLocalMap 可能包含一些用于避免伪共享 (false sharing) 的填充字段 (padding fields)。这些字段后来被移到了 UnpaddedInternalThreadLocalMap 中，然后 InternalThreadLocalMap 再继承它。
 
  
现在这些填充字段 (rp1 到 rp8) 也被标记为 @deprecated，并直接放在 InternalThreadLocalMap 中，说明 Netty 团队可能认为现代 JVM 和硬件对伪共享的处理已经足够好，或者有其他更有效的避免方式。
 
  
总结
 
  
InternalThreadLocalMap 通过使用基于索引的数组存储、针对 FastThreadLocalThread 的优化以及预定义对象的复用，为 Netty 提供了一个比标准 ThreadLocal 更高效的线程本地存储方案。它的设计精巧，充分考虑了性能、内存使用和兼容性。理解其内部机制对于深入理解 Netty 的高性能特性非常有帮助。
 
  
 
  
FastThreadLocal
 
  
FastThreadLocal 是 Netty 中对 Java 标准 ThreadLocal 的一种特殊优化实现。当在 FastThreadLocalThread 类型的线程中使用时，它能提供比标准 ThreadLocal 更高的访问性能。
 
  
下面是对其类结构和核心源码实现的分析：
 
  
类结构与核心目的
 
  
     
   
  • 目的：提供高性能的线程局部变量访问。
    •  
   
  • 泛型参数 ：表示线程局部变量的类型。
    •  
   
  • 核心思想：与标准 ThreadLocal 使用哈希表定位变量不同，FastThreadLocal 为每个实例分配一个唯一的整数索引 (index)。在 FastThreadLocalThread 中，这些变量存储在一个数组 (InternalThreadLocalMap.indexedVariables) 中，通过索引直接访问，避免了哈希计算和潜在的哈希冲突，从而提高性能。
    •  
   
  • 降级兼容：如果在非 FastThreadLocalThread 线程中使用，FastThreadLocal 会回退到类似标准 ThreadLocal 的机制（通过 InternalThreadLocalMap 的慢速路径）。
    •  
  
 
  
核心成员变量
 
  
     
   
  • private final int index; 
    
       
     
    • 这是 FastThreadLocal 最关键的实例变量。
      •  
     
    • 在 FastThreadLocal 对象构造时，通过 InternalThreadLocalMap.nextVariableIndex() 分配一个全局唯一的、自增的整数。
      •  
     
    • 此 index 直接用作 InternalThreadLocalMap 内部数组的下标，用于存取该线程的此 FastThreadLocal 变量的值。
      •  
    
     
    •  
  
 
  
构造函数
 
  
     
   
  • public FastThreadLocal() 
    
       
     
    • 主要作用是初始化 index 字段：index = InternalThreadLocalMap.nextVariableIndex();
      •  
    
     
    •  
  
 
  
 
  
public final V get()
 
  
     
   
  • 获取当前线程中此 FastThreadLocal 变量的值。
    •  
   
  • 步骤： 
    
       
     
    1. InternalThreadLocalMap threadLocalMap = InternalThreadLocalMap.get();: 获取当前线程关联的 InternalThreadLocalMap。如果是 FastThreadLocalThread，直接返回其成员；否则，通过一个静态的 ThreadLocal 获取。
      2.  
     
    2. Object v = threadLocalMap.indexedVariable(index);: 使用 index 从 InternalThreadLocalMap 的内部数组中获取值。
      3.  
     
    3. 如果 v != InternalThreadLocalMap.UNSET ( UNSET 是一个特殊静态对象，表示未设置或已移除)，则直接转换并返回 v。
      4.  
     
    4. 如果 v == UNSET，则调用 initialize(threadLocalMap) 进行初始化。
      5.  
    
     
    •  
  
 
  
private V initialize(InternalThreadLocalMap threadLocalMap)
 
  
     
   
  • 当 get() 发现变量未初始化时调用。
    •  
   
  • 步骤： 
    
       
     
    1. v = initialValue();: 调用用户可覆盖的 protected V initialValue() throws Exception 方法获取初始值。默认返回 null。
      2.  
     
    2. 检查 v 不能是 InternalThreadLocalMap.UNSET。
      3.  
     
    3. threadLocalMap.setIndexedVariable(index, v);: 将初始值存入 InternalThreadLocalMap 的 index 位置。
      4.  
     
    4. addToVariablesToRemove(threadLocalMap, this);: 将当前 FastThreadLocal 实例添加到一个集合中，该集合由 InternalThreadLocalMap 维护，用于 removeAll() 操作。
      5.  
     
    5. 返回初始值 v。
      6.  
    
     
    •  
  
 
  
protected V initialValue() throws Exception
 
  
     
   
  • 返回此线程局部变量的初始值。子类可以覆盖此方法以提供非 null 的初始值。默认返回 null。
    •  
  
 
  
set
 
  
public final void set(V value)
 
  
     
   
  • 设置当前线程中此 FastThreadLocal 变量的值。
    •  
   
  • 实际调用 public V getAndSet(V value)。
    •  
  
 
  
public V getAndSet(V value)
 
  
     
   
  • 设置新值并返回旧值。
    •  
   
  • 步骤： 
    
       
     
    1. 如果 value == InternalThreadLocalMap.UNSET，则视为移除操作，调用 removeAndGet(InternalThreadLocalMap.getIfSet())。
      2.  
     
    2. 否则，获取 InternalThreadLocalMap，然后调用 setKnownNotUnset(threadLocalMap, value)。
      3.  
    
     
    •  
  
 
  
private V setKnownNotUnset(InternalThreadLocalMap threadLocalMap, V value):
 
  
     
   
  1. V old = (V) threadLocalMap.getAndSetIndexedVariable(index, value);: 在 InternalThreadLocalMap 中设置新值并获取旧值。
    2.  
   
  2. 如果 old == UNSET (表示之前未设置过)，则调用 addToVariablesToRemove(threadLocalMap, this); 并返回 null (因为逻辑上的旧值是“未设置”)。
    3.  
   
  3. 否则返回 old。
    4.  
  
 
  
public final void remove()
 
  
     
   
  • 移除当前线程中此 FastThreadLocal 变量。
    •  
   
  • 实际调用 remove(InternalThreadLocalMap.getIfSet())。
    •  
  
 
  
private V removeAndGet(InternalThreadLocalMap threadLocalMap):
 
  
     
   
  1. 如果 threadLocalMap 为 null，返回 null。
    2.  
   
  2. Object v = threadLocalMap.removeIndexedVariable(index);: 从 InternalThreadLocalMap 中移除 index 位置的变量，并将其标记为 UNSET。
    3.  
   
  3. 如果 v != UNSET (表示确实移除了一个有效值)： 
    
       
     
    • removeFromVariablesToRemove(threadLocalMap, this);: 从待移除集合中移除当前实例。
      •  
     
    • onRemoval((V) v);: 调用用户可覆盖的 protected void onRemoval(V value) throws Exception 方法，用于资源清理。
      •  
     
    • 返回被移除的旧值 v。
      •  
    
     
    4.  
   
  4. 如果 v == UNSET，返回 null。
    5.  
  
 
  
 
  
     
  
    protected void onRemoval(V value) throws Exception
     
  
       
   
    • 当变量通过 remove() 方法被移除时调用。子类可以覆盖此方法以执行必要的清理操作。默认无操作。
      •  
  
     
  
    核心静态方法
     
  
       
   
    1.  
      public static void removeAll()
       
    
         
     
      • 移除当前线程绑定的所有 FastThreadLocal 变量。
        •  
     
      • 获取当前线程的 InternalThreadLocalMap。
        •  
     
      • 从 map 中获取之前通过 addToVariablesToRemove 注册的 FastThreadLocal 实例集合 (存储在 VARIABLES_TO_REMOVE_INDEX 特殊索引处)。
        •  
     
      • 遍历这个集合，对每个 FastThreadLocal 实例调用其 remove(threadLocalMap) 方法。
        •  
     
      • 最后，调用 InternalThreadLocalMap.remove() 来清理 InternalThreadLocalMap 本身（如果是慢速路径，会移除 ThreadLocal 中的 InternalThreadLocalMap）。
        •  
    
       
      2.  
   
    2.  
      public static int size()
       
    
         
     
      • 返回当前线程绑定的 FastThreadLocal 变量的数量。通过 InternalThreadLocalMap.getIfSet().size() 实现。
        •  
    
       
      3.  
   
    3.  
      public static void destroy()
       
    
         
     
      • 销毁用于非 FastThreadLocalThread 的 InternalThreadLocalMap 存储机制（即清除静态 ThreadLocal）。主要用于容器环境下防止内存泄漏。
        •  
    
       
      4.  
   
    4.  
      private static void addToVariablesToRemove(InternalThreadLocalMap threadLocalMap, FastThreadLocal variable)
       
    
         
     
      • 将一个 FastThreadLocal 实例添加到一个由 InternalThreadLocalMap 管理的 Set 中。这个 Set 存储在 threadLocalMap 的 VARIABLES_TO_REMOVE_INDEX 位置。此 Set 用于 removeAll() 操作。
        •  
    
       
      5.  
   
    5.  
      private static void removeFromVariablesToRemove(InternalThreadLocalMap threadLocalMap, FastThreadLocal variable)
       
    
         
     
      • 从上述 Set 中移除一个 FastThreadLocal 实例。
        •  
    
       
      6.  
  
     
  
    与 InternalThreadLocalMap 和 FastThreadLocalThread 的关系
     
  
       
   
    • InternalThreadLocalMap: 是实际存储线程局部变量的容器。它内部有一个 Object[] indexedVariables 数组，FastThreadLocal 的 index 就是这个数组的下标。
      •  
   
    • FastThreadLocalThread: 这种类型的线程直接拥有一个 InternalThreadLocalMap 实例作为其成员变量。当 FastThreadLocal 在这种线程上操作时，可以直接访问这个 InternalThreadLocalMap，并通过索引快速读写，这是“快速路径”。
      •  
   
    • 普通 Thread: 对于非 FastThreadLocalThread，InternalThreadLocalMap 实例通过一个静态的 ThreadLocal (名为 slowThreadLocalMap 在 InternalThreadLocalMap 类中) 来存储和获取，这是“慢速路径”，但功能上等价。
      •  
  
     
  
    总结
     
  
    FastThreadLocal 通过为每个实例分配一个唯一的数组索引，并结合 FastThreadLocalThread 直接持有 InternalThreadLocalMap 的设计，实现了对线程局部变量的 O(1) 访问。这在频繁访问线程局部变量的场景下（如Netty的事件循环中）能带来显著的性能提升。同时，它也提供了与标准 ThreadLocal 类似的回调方法 (initialValue, onRemoval) 和管理方法 (removeAll, destroy)。
     
  
     
  
    FastThreadLocalThread
     
  
    我们来深入分析 FastThreadLocalThread 类的结构和实现源码。这个类是 Netty 高性能线程本地存储 (FastThreadLocal) 的核心组件之一。
     
  
    FastThreadLocalThread.java
     
  
    public class FastThreadLocalThread extends Thread {
    // 日志记录器
    private static final InternalLogger logger = ...;
    
    // 用于存储被当作 FastThreadLocalThread 处理的线程 ID 数组
    private static final AtomicReference fallbackThreads = new AtomicReference<>(null);
    
    // 标记是否会在 run() 完成后清理 FastThreadLocal
    private final boolean cleanupFastThreadLocals;
    
    // 存储线程本地变量的核心数据结构
    private InternalThreadLocalMap threadLocalMap;
    
    // 多个构造函数...
    
    // 核心方法...
}

     
  
    关键成员分析
     
  
       
   
    1.  
      threadLocalMap (核心成员)
       
    
         
     
      • 类型: InternalThreadLocalMap
        •  
     
      • 作用: 存储该线程的所有 FastThreadLocal 变量
        •  
     
      • 访问方式: 通过 threadLocalMap() 和 setThreadLocalMap() 方法
        •  
     
      • 线程安全: 这两个方法会检查当前线程是否是自身，如果不是会记录警告日志
        •  
    
       
      2.  
   
    2.  
      cleanupFastThreadLocals
       
    
         
     
      • 类型: boolean
        •  
     
      • 作用: 标记是否在 run() 方法完成后自动清理 FastThreadLocal 变量
        •  
     
      • 初始化: 在构造函数中根据是否包装了 Runnable 决定
        •  
    
       
      3.  
   
    3.  
      fallbackThreads
       
    
         
     
      • 类型: AtomicReference
        •  
     
      • 作用: 存储那些不能继承 FastThreadLocalThread 但希望获得类似性能优化的线程 ID (如虚拟线程)
        •  
    
       
      4.  
  
     
  
    构造函数
     
  
    java
     
  
    // 基本构造函数
public FastThreadLocalThread() {
    cleanupFastThreadLocals = false; // 不自动清理
}

// 带 Runnable 的构造函数
public FastThreadLocalThread(Runnable target) {
    super(FastThreadLocalRunnable.wrap(target)); // 包装 Runnable
    cleanupFastThreadLocals = true; // 会自动清理
}

// 其他构造函数类似...

     
  
    关键点:
     
  
       
   
    • 所有接受 Runnable 参数的构造函数都会用 FastThreadLocalRunnable.wrap() 进行包装
      •  
   
    • 包装后的 Runnable 会在执行完成后自动清理 FastThreadLocal 变量
      •  
  
     
  
    threadLocalMap() 和 setThreadLocalMap()
     
  
    java
     
  
    public final InternalThreadLocalMap threadLocalMap() {
    // 安全检查：只有当前线程才能访问自己的 threadLocalMap
    if (this != Thread.currentThread() && logger.isWarnEnabled()) {
        logger.warn(new RuntimeException("It's not thread-safe..."));
    }
    return threadLocalMap;
}

public final void setThreadLocalMap(InternalThreadLocalMap threadLocalMap) {
    // 同样的安全检查
    if (this != Thread.currentThread() && logger.isWarnEnabled()) {
        logger.warn(new RuntimeException("It's not thread-safe..."));
    }
    this.threadLocalMap = threadLocalMap;
}

     
  
    清理相关方法
     
  
    java
     
  
    // 判断当前线程是否会清理 FastThreadLocal
public static boolean currentThreadWillCleanupFastThreadLocals() {
    Thread currentThread = currentThread();
    if (currentThread instanceof FastThreadLocalThread) {
        return ((FastThreadLocalThread) currentThread).willCleanupFastThreadLocals();
    }
    return isFastThreadLocalVirtualThread(); // 检查是否是虚拟线程
}

// 判断线程是否支持 FastThreadLocal
public static boolean currentThreadHasFastThreadLocal() {
    return currentThread() instanceof FastThreadLocalThread || 
           isFastThreadLocalVirtualThread();
}

    private static boolean isFastThreadLocalVirtualThread() {
        long[] arr = fallbackThreads.get();
        if (arr == null) {
            return false;
        }
        return Arrays.binarySearch(arr, Thread.currentThread().getId()) >= 0;
    }

     
  
    runWithFastThreadLocal() (重要!)
     
  
    java
     
  
    public static void runWithFastThreadLocal(Runnable runnable) {
    Thread current = currentThread();
    if (current instanceof FastThreadLocalThread) {
        throw new IllegalStateException("Caller is a real FastThreadLocalThread");
    }
    
    // 1. 将当前线程ID添加到 fallbackThreads
    long id = current.getId();
    fallbackThreads.updateAndGet(arr -> {
        if (arr == null) return new long[]{id};
        
        // 检查是否已存在 (避免重入)
        int index = Arrays.binarySearch(arr, id);
        if (index >= 0) throw new IllegalStateException("Reentrant call to run()");
        
        // 插入到正确位置 (保持数组有序)
        index = ~index;
        long[] next = new long[arr.length + 1];
        System.arraycopy(arr, 0, next, 0, index);
        next[index] = id;
        System.arraycopy(arr, index, next, index + 1, arr.length - index);
        return next;
    });
    
    try {
        runnable.run();
    } finally {
        // 2. 从 fallbackThreads 中移除当前线程ID
        fallbackThreads.getAndUpdate(arr -> {
            if (arr == null || (arr.length == 1 && arr[0] == id)) {
                return null;
            }
            int index = Arrays.binarySearch(arr, id);
            if (index < 0) return arr;
            
            long[] next = new long[arr.length - 1];
            System.arraycopy(arr, 0, next, 0, index);
            System.arraycopy(arr, index + 1, next, index, arr.length - index - 1);
            return next;
        });
        
        // 3. 清理所有 FastThreadLocal 变量
        FastThreadLocal.removeAll();
    }
}

     
  
    这个方法允许普通线程(包括虚拟线程)临时获得 FastThreadLocal 支持，执行完成后会自动清理。
     
  
     
  
    permitBlockingCalls()
     
  
    java
     
  
    public boolean permitBlockingCalls() {
    return false; // 默认禁止阻塞调用
}

     
  
    这是一个钩子方法，子类可以覆盖。Netty 的事件循环线程会利用这个方法检查是否允许阻塞调用。
     
  
    设计要点
     
  
       
   
    1.  
      性能优化:
       
    
         
     
      • 直接继承 Thread 并添加 InternalThreadLocalMap 字段，避免了 ThreadLocal 的哈希表查找
        •  
     
      • 使用数组索引直接访问变量 (通过 InternalThreadLocalMap)
        •  
    
       
      2.  
   
    2.  
      资源管理:
       
    
         
     
      • 通过 FastThreadLocalRunnable 包装确保资源清理
        •  
     
      • 提供了 runWithFastThreadLocal() 支持非 FastThreadLocalThread 线程
        •  
    
       
      3.  
   
    3.  
      线程安全:
       
    
         
     
      • 严格限制只有当前线程能访问自己的 threadLocalMap
        •  
     
      • fallbackThreads 使用 AtomicReference 保证线程安全
        •  
    
       
      4.  
   
    4.  
      扩展性:
       
    
         
     
      • permitBlockingCalls() 方法允许子类自定义行为
        •  
     
      • 支持虚拟线程等新特性
        •  
    
       
      5.  
  
     
  
    与相关类的协作
     
  
       
   
    1.  
      FastThreadLocal:
       
    
         
     
      • 通过 InternalThreadLocalMap 存储变量
        •  
     
      • 依赖 FastThreadLocalThread 提供快速访问路径
        •  
    
       
      2.  
   
    2.  
      InternalThreadLocalMap:
       
    
         
     
      • 作为 FastThreadLocalThread 的成员存储所有线程本地变量
        •  
     
      • 使用数组索引而非哈希表提高访问速度
        •  
    
       
      3.  
   
    3.  
      FastThreadLocalRunnable:
       
    
         
     
      • 包装用户 Runnable 确保 FastThreadLocal 清理
        •  
    
       
      java
       
      final class FastThreadLocalRunnable implements Runnable {
    private final Runnable runnable;
    
    public void run() {
        try {
            runnable.run();
        } finally {
            FastThreadLocal.removeAll(); // 确保清理
        }
    }

static Runnable wrap(Runnable runnable) {
    return runnable instanceof FastThreadLocalRunnable ? runnable 
           : new FastThreadLocalRunnable(runnable); // 已包装则直接返回
}
}

       
      4.  
  
     
  
    这个类的设计充分体现了 Netty 对性能的极致追求，同时保持了良好的资源管理和线程安全性。
     
  
     
  
     
  
    为什么Recycler  使用 FastThreadLocal
     
  
    在 Netty 的 Recycler 中使用 FastThreadLocal 而不是普通 ThreadLocal 主要基于以下几个关键设计考量：
     
  
     
  
    1. 性能优化
     
  
    FastThreadLocal 相比标准 ThreadLocal 有以下性能优势：
     
  
       
   
    • 数组索引访问：FastThreadLocal 使用固定索引直接访问数组元素，而 ThreadLocal 需要哈希计算和可能的哈希冲突处理
      •  
   
    • 避免哈希表开销：标准 ThreadLocal 使用 ThreadLocalMap（基于哈希表），而 FastThreadLocal 直接使用 InternalThreadLocalMap 的数组结构
      •  
  
     
  
    在 Recycler 高频对象回收场景下，这种优化能显著减少线程本地存储的访问开销。
     
  
     
  
    2. 内存效率
     
  
       
   
    • 减少对象创建：FastThreadLocal 的数组存储方式比 ThreadLocalMap 的 Entry 对象更节省内存
      •  
   
    • 预分配空间：InternalThreadLocalMap 会预分配固定大小的数组，避免动态扩容带来的性能波动
      •  
  
     
  
    对于需要维护大量回收对象的 Recycler 来说，内存效率至关重要。
     
  
     
  
    3. 与 Netty 线程模型的深度集成
     
  
       
   
    • FastThreadLocalThread 优化：当线程是 FastThreadLocalThread 类型时，InternalThreadLocalMap 会直接存储在线程对象中，完全避免了 ThreadLocal.get() 的查找开销
      •  
   
    • 虚拟线程支持：通过 fallbackThreads 机制，Recycler 也能在虚拟线程中保持较好的性能
      •  
  
     
  
    Netty 的默认线程工厂 (DefaultThreadFactory) 创建的线程都是 FastThreadLocalThread，这使得 Recycler 能获得最佳性能。
     
  
     
  
    4. 资源清理的确定性
     
  
    FastThreadLocal 提供了更可靠的资源清理机制：
     
  
    java
     
  
    private final FastThreadLocal> threadLocal = new FastThreadLocal>() {
    @Override
    protected void onRemoval(LocalPool value) throws Exception {
        super.onRemoval(value);
        // 确保线程终止时清理所有资源
        value.pooledHandles = null;
        value.owner = null;
        handles.clear();
    }
};

     
  
    相比 ThreadLocal，FastThreadLocal 能更可靠地触发清理回调（通过 FastThreadLocalRunnable 包装）。
     
  
     
  
    5. 与 Recycler 设计的一致性
     
  
    Recycler 的核心设计理念是避免任何形式的同步开销，这与 FastThreadLocal 的设计目标完全吻合：
     
  
       
   
    • 对象获取 (get()) 和回收 (recycle()) 都依赖线程本地操作
      •  
   
    • LocalPool 的批量处理机制 (chunkSize) 需要高效访问线程本地队列
      •  
  
     
  
     
  
    为什么不直接用 ThreadLocal？
     
  
       
   
    1. 哈希计算开销：每次 get() 都需要计算哈希码，在对象池高频访问场景下影响显著
      2.  
   
    2. 内存占用高：ThreadLocalMap.Entry 是对象节点，比数组存储占用更多内存
      3.  
   
    3. 清理不可靠：标准 ThreadLocal 依赖 Thread.exit() 清理资源，而 Netty 需要更确定的清理时机
      4.  
   
    4. 无法利用 FastThreadLocalThread 优化：会失去直接访问线程字段的性能优势
      5.  
  
     
  
     
  
    性能对比场景
     
  
    在 Recycler.get() 方法中：
     
  
    public final T get() {
    if (maxCapacityPerThread == 0 || 
        (PlatformDependent.isVirtualThread(Thread.currentThread()) &&
         !FastThreadLocalThread.currentThreadHasFastThreadLocal())) {
        return newObject((Handle) NOOP_HANDLE); // 回退路径
    }
    LocalPool localPool = threadLocal.get(); // 快速路径
    // ...
}

     
  
    当线程是 FastThreadLocalThread 时，threadLocal.get() 实际上是：
     
  
       
   
    1. 直接从线程对象获取 InternalThreadLocalMap
      2.  
   
    2. 通过预计算的 index 直接数组访问
      3.  
  
     
  
    而标准 ThreadLocal 需要：
     
  
       
   
    1. 获取当前线程的 ThreadLocalMap
      2.  
   
    2. 计算哈希槽
      3.  
   
    3. 处理可能的哈希冲突
      4.  
  
     
  
     
  
    总结
     
  
    Recycler 使用 FastThreadLocal 的核心原因是其与 Netty 高性能架构的深度契合：
     
  
       
   
    1. 为高频访问的线程本地操作提供 O(1) 的稳定访问性能
      2.  
   
    2. 减少内存占用，这对维护大量回收对象的对象池至关重要
      3.  
   
    3. 与 Netty 的线程模型和资源管理机制无缝集成
      4.  
   
    4. 在保持 API 简洁的同时提供确定性的资源清理
      5.  
  
     
  
    这种设计使得 Netty 的对象回收机制能在高并发场景下保持极高的性能，同时避免传统 ThreadLocal 的内存泄漏风险。
     
  
     
  

                            
                        
                    
                    
                    
    
                    
                    
                    
    
                
                
    
                    
                
    
            
        
    
    
    
        
    你可能感兴趣的:(Netty,数据结构,并发/JUC,java,算法,数据结构,nio,开发语言,设计模式)
    
        
    
            
    
                
      
                    
    • 移动端城市区县二级联动选择功能实现包
                        good2know

                        
      本文还有配套的精品资源，点击获取简介：本项目是一套为移动端设计的jQuery实现方案，用于简化用户在选择城市和区县时的流程。它包括所有必需文件：HTML、JavaScript、CSS及图片资源。通过动态更新下拉菜单选项，实现城市到区县的联动效果，支持数据异步加载。开发者可以轻松集成此功能到移动网站或应用，并可基于需求进行扩展和优化。1.jQuery移动端解决方案概述jQuery技术简介jQuery
      
                    
      • 
                    
    • day15｜前端框架学习和算法
                        universe_01
前端算法笔记
                        
      T22括号生成先把所有情况都画出来，然后（在满足什么情况下）把不符合条件的删除。T78子集要画树状图，把思路清晰。可以用暴力法、回溯法和DFS做这个题DFS深度搜索：每个边都走完，再回溯应用：二叉树搜索，图搜索回溯算法=DFS+剪枝T200岛屿数量（非常经典BFS宽度把树状转化成队列形式，lambda匿名函数“一次性的小函数，没有名字”setup语法糖：让代码更简洁好写的语法ref创建：基本类型的
      
                    
      • 
                    
    • C++ 计数排序、归并排序、快速排序
                        每天搬一点点砖
c++数据结构算法
                        
      计数排序：是一种基于哈希的排序算法。他的基本思想是通过统计每个元素的出现次数，然后根据统计结果将元素依次放入排序后的序列中。这种排序算法适用于范围较小的情况，例如整数范围在0到k之间计数排序步骤：1初始化一个长度为最大元素值加1的计数数组，所有元素初始化为02遍历原始数组，将每个元素值作为索引，在计数数组中对应位置加13将数组清空4遍历计数器数组，按照数组中的元素个数放回到元数组中计数排序的优点和
      
                    
      • 
                    
    • 深入解析JVM工作原理：从字节码到机器指令的全过程
                        

                        
      一、JVM概述Java虚拟机(JVM)是Java平台的核心组件，它实现了Java"一次编写，到处运行"的理念。JVM是一个抽象的计算机器，它有自己的指令集和运行时内存管理机制。JVM的主要职责：加载：读取.class文件并验证其正确性存储：管理内存分配和垃圾回收执行：解释或编译字节码为机器指令安全：提供沙箱环境限制恶意代码二、JVM架构详解JVM由三个主要子系统组成：1.类加载子系统类加载过程分为
      
                    
      • 
                    
    • 【C++算法】76.优先级队列_前 K 个高频单词
                        流星白龙
优选算法C++c++算法开发语言
                        
      文章目录题目链接：题目描述：解法C++算法代码：题目链接：692.前K个高频单词题目描述：解法利用堆来解决TopK问题预处理一下原始的字符串数组，用一个哈希表统计一下每一个单词出现的频次。创建一个大小为k的堆频次：小根堆字典序（频次相同的时候）：大根堆循环让元素依次进堆判断提取结果C++算法代码：classSolution{//定义类型别名，PSI表示对typedefpairPSI;//自定义比较
      
                    
      • 
                    
    • JVM 内存模型深度解析：原子性、可见性与有序性的实现
                        练习时长两年半的程序员小胡
JVM深度剖析：从面试考点到生产实践jvmjava内存模型
                        
      在了解了JVM的基础架构和类加载机制后，我们需要进一步探索Java程序在多线程环境下的内存交互规则。JVM内存模型（JavaMemoryModel，JMM）定义了线程和主内存之间的抽象关系，它通过规范共享变量的访问方式，解决了多线程并发时的数据一致性问题。本文将从内存模型的核心目标出发，详解原子性、可见性、有序性的实现机制，以及volatile、synchronized等关键字在其中的作用。一、J
      
                    
      • 
                    
    • Flowable 高级扩展：自定义元素与性能优化实战
                        练习时长两年半的程序员小胡
Flowable流程引擎实战指南流程图flowableBPMN流程引擎java
                        
      在前五篇文章中，我们从基础概念、流程设计、API实战、SpringBoot集成，到外部系统协同，逐步构建了Flowable的应用体系。但企业级复杂场景中，原生功能往往难以满足定制化需求——比如需要特殊的审批规则网关、与决策引擎联动实现动态路由，或是在高并发场景下优化流程引擎性能。本文将聚焦Flowable的高级扩展能力，详解如何自定义流程元素、集成规则引擎，并掌握大型系统中的性能调优策略。一、自定
      
                    
      • 
                    
    • 什么是缓存雪崩？缓存击穿？缓存穿透？分别如何解决？什么是缓存预热？
                        daixin8848
缓存redisjava开发语言
                        
      缓存雪崩：在一个时间段内，有大量的key过期，或者Redis服务宕机，导致大量的请求到达数据库,带来巨大压力-给key设置不同的TTL、利用Redis集群提高服务的高可用性、添加多级缓存、添加降级流策略缓存击穿：给某一个key设置了过期时间，当key过期的时间，恰好这个时间点有大量的并发请求访问这个key，可能会瞬间把数据库压垮-互斥锁：缓存失败时，只允许一个请求去加载数据并更新缓存，其他请求阻塞
      
                    
      • 
                    
    • Java | 多线程经典问题 - 售票
                        Ada54

                        
      一、售票需求1）同一个票池2）多个窗口卖票，不能出售同一张票二、售票问题代码实现（线程与进程小总结，请戳：Java|线程和进程，创建线程）step1：定义SaleWindow类实现Runnable接口，覆盖run方法step2：实例化SaleWindow对象，创建Thread对象，将SaleWindow作为参数传给Thread类的构造函数，然后通过Thread.start()方法启动线程step3
      
                    
      • 
                    
    • SpringMVC的执行流程
                        

                        
      1、什么是MVCMVC是一种设计模式。MVC的原理图如下所示M-Model模型（完成业务逻辑：有javaBean构成，service+dao+entity）V-View视图（做界面的展示jsp，html……）C-Controller控制器（接收请求—>调用模型—>根据结果派发页面2、SpringMVC是什么SpringMVC是一个MVC的开源框架，SpringMVC=Struts2+Spring，
      
                    
      • 
                    
    • 力扣面试题07 - 旋转矩阵
                        茶猫_
leetcode矩阵算法c语言
                        
      题目：给你一幅由N×N矩阵表示的图像，其中每个像素的大小为4字节。请你设计一种算法，将图像旋转90度。不占用额外内存空间能否做到？示例1:给定matrix=[[1,2,3],[4,5,6],[7,8,9]],原地旋转输入矩阵，使其变为:[[7,4,1],[8,5,2],[9,6,3]]示例2:给定matrix=[[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,
      
                    
      • 
                    
    • JAVA接口机结构解析
                        秃狼
SpringBoot八股文Javajava学习
                        
      什么是接口机在Java项目中，接口机通常指用于与外部系统进行数据交互的中间层，负责处理请求和响应的转换、协议适配、数据格式转换等任务。接口机的结构我们的接口机的结构分为两个大部分，外部接口机和内部接口机，在业务的调度上也是通过mq来实现的，只要的目的就是为了解耦合和做差异化。在接口机中主要的方法就是定时任务，消息的发送和消费，其他平台调用接口机只能提供外部接口机的方法进行调用，外部接口机可以提供消
      
                    
      • 
                    
    • 最新阿里四面面试真题46道：面试技巧+核心问题+面试心得
                        风平浪静如码

                        
      前言做技术的有一种资历，叫做通过了阿里的面试。这些阿里Java相关问题，都是之前通过不断优秀人才的铺垫总结的，先自己弄懂了再去阿里面试，不然就是去丢脸，被虐。希望对大家帮助，祝面试成功，有个更好的职业规划。一，阿里常见技术面1、微信红包怎么实现。2、海量数据分析。3、测试职位问的线程安全和非线程安全。4、HTTP2.0、thrift。5、面试电话沟通可能先让自我介绍。6、分布式事务一致性。7、ni
      
                    
      • 
                    
    • 模拟退火(SA)：如何“故意走错路”，才能找到最优解？
                        小瑞瑞acd
小瑞瑞学数模模拟退火算法python启发式算法算法
                        
      模拟退火(SA)：如何“故意走错路”，才能找到最优解？图示模拟退火算法如何通过接受较差解（橙色虚线标注）从局部最优（绿色点）逃逸，最终找到全局最优解（紫色点），展示其跳出局部极小值的能力。大家好，我是小瑞瑞！欢迎回到我的专栏！想象一下，你站在一座连绵不绝的山脉中，目标是找到海拔最低的那个山谷。你手上只有一个高度计，视野被浓雾笼罩，只能看清脚下的一小片区域。如果你是一个“贪心”的登山者，你的策略会非
      
                    
      • 
                    
    • 编程算法：技术创新的引擎与业务增长的核心驱动力
                        

                        
      在数字经济时代，算法已成为推动技术创新与业务增长的隐形引擎。从存内计算突破冯·诺依曼瓶颈，到动态规划优化万亿级金融交易，编程算法正在重塑产业竞争格局。一、存内计算：突破冯·诺依曼瓶颈的算法革命1.1存内计算的基本原理传统计算架构中90%的能耗消耗在数据搬运上。存内计算（Processing-in-Memory）通过直接在存储单元执行计算，实现能效10-100倍提升：#传统计算vs存内计算能耗模型i
      
                    
      • 
                    
    • 图论算法经典题目解析：DFS、BFS与拓扑排序实战
                        周童學
数据结构与算法深度优先算法图论
                        
      图论算法经典题目解析：DFS、BFS与拓扑排序实战图论问题是算法面试中的高频考点，本博客将通过四道LeetCode经典题目（均来自"Top100Liked"题库），深入讲解图论的核心算法思想和实现技巧。涵盖DFS、BFS、拓扑排序和前缀树等知识点，每道题配有Java实现和易错点分析。1.岛屿数量(DFS遍历)问题描述给定一个由'1'(陆地)和'0'(水)组成的二维网格，计算岛屿的数量。岛屿由水平或
      
                    
      • 
                    
    • 【异常】使用 LiteFlow 框架时，提示错误ChainDuplicateException: [chain name duplicate] chainName=categoryChallenge
                        本本本添哥
002-进阶开发能力java
                        
      一、报错内容Causedby:com.yomahub.liteflow.exception.ChainDuplicateException:[chainnameduplicate]chainName=categoryChallengeatcom.yomahub.liteflow.parser.helper.ParserHelper.lambda$null$0(ParserHelper.java:1
      
                    
      • 
                    
    • Java并发核心：线程池使用技巧与最佳实践！ | 多线程篇(五)
                        bug菌¹
Java实战(进阶版)javaJava零基础入门Java并发线程池多线程篇
                        
      本文收录于「Java进阶实战」专栏，专业攻坚指数级提升，希望能够助你一臂之力，帮你早日登顶实现财富自由；同时，欢迎大家关注&&收藏&&订阅！持续更新中，up！up！up！！环境说明：Windows10+IntelliJIDEA2021.3.2+Jdk1.8本文目录前言摘要正文何为线程池？为什么需要线程池？线程池的好处线程池使用场景如何创建线程池？线程池的常见配置源码解析案例分享案例代码演示案例运行
      
                    
      • 
                    
    • Java 队列
                        tryxr
java开发语言队列
                        
      队列一般用什么哪种结构实现队列的特性数据入队列时一定是从尾部插入吗数据出队列时一定是从头部删除吗队列的基本运算有什么队列支持随机访问吗队列的英文表示什么是队列队列从哪进、从哪出队列的进出顺序队列是用哪种结构实现的Queue和Deque有什么区别Queue接口的方法Queue中的add与offer的区别offer、poll、peek的模拟实现如何利用链表实现队列如何利用顺序表实现队列什么叫做双端队列
      
                    
      • 
                    
    • 第二十二天（数据结构，无头节点的单项链表）
                        肉夹馍不加青椒
c语言数据结构
                        
      线性表：一个线性表里面可以是任意的数据元素，但是同一个线性表里面数据应该是同类型的1存在一个/唯一被称为第一个节点的节点2存在一个/唯一被称为最后一个节点的节点3除了第一个以外，每一个元素都有一个前驱节点4除了最后一个，每一个元素都有一个后继节点满足以上性质，这个表就被称为线性表数组就是一个线性表想实现线性表的保存，我们需要考虑下面的事情1元素要保存2元素与元素之间的序偶关系谁是前面的谁是后面的我
      
                    
      • 
                    
    • JVM 内存分配与回收策略：从对象创建到内存释放的全流程
                        

                        
      在JVM的运行机制中，内存分配与回收策略是连接对象生命周期与垃圾收集器的桥梁。它决定了对象在堆内存中的创建位置、存活过程中的区域迁移，以及最终被回收的时机。合理的内存分配策略能减少GC频率、降低停顿时间，是优化Java应用性能的核心环节。本文将系统解析JVM的内存分配规则、对象晋升机制，以及实战中的内存优化技巧。一、对象优先在Eden区分配：新生代的“临时缓冲区”大多数情况下，Java对象在新生代
      
                    
      • 
                    
    • 代码随想录算法训练营第三十五天
                        

                        
      01背包问题二维题目链接01背包问题二维题解importjava.util.Scanner;publicclassMain{publicstaticvoidmain(String[]args){Scannersc=newScanner(System.in);intM=sc.nextInt();intN=sc.nextInt();int[]space=newint[M];int[]value=new
      
                    
      • 
                    
    • Redis + Caffeine 实现高效的两级缓存架构
                        周童學
Java缓存redis架构
                        
      Redis+Caffeine实现高效的两级缓存架构引言在现代高并发系统中，缓存是提升系统性能的关键组件之一。传统的单一缓存方案往往难以同时满足高性能和高可用性的需求。本文将介绍如何结合Redis和Caffeine构建一个高效的两级缓存系统，并通过三个版本的演进展示如何逐步优化代码结构。项目源代码：github地址、gitee地址两级缓存架构概述两级缓存通常由本地缓存（如Caffeine）和分布式缓
      
                    
      • 
                    
    • 微信公众号回调java_处理微信公众号消息回调
                        weixin_39607620
微信公众号回调java
                        
      1、背景在上一节中，咱们知道如何接入微信公众号，可是以后公众号会与咱们进行交互，那么微信公众号如何通知到咱们本身的服务器呢？咱们知道咱们接入的时候提供的url是GET/mp/entry，那么公众号以后产生的事件将会以POST/mp/entry发送到咱们本身的服务器上。html2、代码实现，此处仍是使用weixin-java-mp这个框架实现一、引入weixin-java-mpcom.github.
      
                    
      • 
                    
    • 学C++的五大惊人好处
                        

                        
      为什么要学c++学c++有什么用学习c++的好处有1.中考可以加分2.高考可能直接录取3.就业广且工资高4.在未来30--50年c++一定是一个很受欢迎的职业5.c++成功的例子deepsick等AI智能C++语言兼备编程效率和编译运行效率的语言C++语言是C语言功能增强版,在c语言的基础上添加了面向对象编程和泛型编程的支持既继承了C语言高效，简洁，快速和可移植的传统,又具备类似Java、Go等其
      
                    
      • 
                    
    • 机器学习必备数学与编程指南：从入门到精通
                        a小胡哦
机器学习基础机器学习人工智能
                        
      一、机器学习核心数学基础1.线性代数（神经网络的基础）必须掌握：矩阵运算（乘法、转置、逆）向量空间与线性变换特征值分解与奇异值分解(SVD)为什么重要：神经网络本质就是矩阵运算学习技巧：用NumPy实际操作矩阵运算2.概率与统计（模型评估的关键）核心概念：条件概率与贝叶斯定理概率分布（正态、泊松、伯努利）假设检验与p值应用场景：朴素贝叶斯、A/B测试3.微积分（优化算法的基础）重点掌握：导数与偏导
      
                    
      • 
                    
    • Java8 Stream流的sorted()的排序【正序、倒序、多字段排序】
                        Tony666688888
javawindows开发语言
                        
      针对集合排序，java8可以用Stream流的sorted()进行排序。示例Bean以下我们会使用这个Bean来做示例。publicclassOrder{privateStringweight;privateDoubleprice;privateStringdateStr;//忽略getter、setter、构造方法、toString}字段排序首先是比较器Comparator，形式如下：Compa
      
                    
      • 
                    
    • 从振动信号到精准预警：AI 如何重塑工业设备健康管理？
                        缘华工业智维
人工智能计算机视觉边缘计算信息与通信
                        
      在智能制造浪潮席卷全球的当下，工业生产正经历着从传统模式向智能化、数字化转型的深刻变革。在这场变革中，AI驱动的振动分析技术犹如一颗璀璨新星，成为工业设备可靠运行的“健康卫士”。它通过在设备关键部位部署振动传感器，如同医生为患者听诊般实时采集设备运行时的振动信号，再借助强大的人工智能算法对这些“工业脉搏”进行深度解析，从而实现对工业设备从故障预警到寿命预测的全周期精准守护。一、AI振动分析：设备状
      
                    
      • 
                    
    • 基于DeepSeek的下一代大型游戏开发革命：架构、核心技术与项目管理实践
                        Liudef06小白
特殊专栏人工智能AIGC架构人工智能deepseek
                        
      基于DeepSeek的下一代大型游戏开发革命：架构、核心技术与项目管理实践DeepSeek大模型正重塑游戏开发范式，本文将深入解析如何利用这一革命性技术构建下一代大型游戏，涵盖从架构设计到项目管理的全流程实践。目录DeepSeek游戏引擎核心架构1.1神经符号系统融合架构1.2动态世界生成引擎智能NPC与剧情系统2.1角色人格建模技术2.2动态叙事生成算法大型项目管理体系3.1敏捷-AI混合开发流
      
                    
      • 
                    
    • 量子计算解决气候变化：科学家找到了新方法
                        大力出奇迹985
量子计算
                        
      气候变化已成为全球面临的严峻挑战，传统计算方法在应对与之相关的复杂问题时存在诸多局限。而量子计算作为新兴技术，为解决气候变化难题带来曙光。本文深入剖析科学家利用量子计算应对气候变化的新方法。量子计算凭借独特的量子比特与量子特性，在加速气候模型计算、优化模型参数、预测极端天气事件等方面展现出巨大优势。同时，在可再生能源整合、电网管理、碳捕获等实际应用场景中也发挥着重要作用。尽管目前面临硬件和算法等方
      
                    
      • 
                                
    • java封装继承多态等
                                    麦田的设计者
javaeclipsejvmcencapsulatopn
                                    
             最近一段时间看了很多的视频却忘记总结了，现在只能想到什么写什么了，希望能起到一个回忆巩固的作用。 
    1、final关键字 
      译为：最终的 
       &
      
                                
      • 
                                
    • F5与集群的区别
                                    bijian1013
weblogic集群F5
                                    
              http请求配置不是通过集群，而是F5；集群是weblogic容器的，如果是ejb接口是通过集群。 
        F5同集群的差别，主要还是会话复制的问题，F5一把是分发http请求用的，因为http都是无状态的服务，无需关注会话问题，类似
      
                                
      • 
                                
    • LeetCode[Math] - #7 Reverse Integer
                                    Cwind
java题解MathLeetCodeAlgorithm
                                    
      原题链接：#7 Reverse Integer 
  
要求： 
按位反转输入的数字 
例1： 输入 x = 123, 返回 321 
例2： 输入 x = -123, 返回 -321 
  
难度：简单 
  
分析： 
对于一般情况，首先保存输入数字的符号，然后每次取输入的末位（x%10）作为输出的高位（result = result*10 + x%10）即可。但
      
                                
      • 
                                
    • BufferedOutputStream
                                    周凡杨

                                    
           首先说一下这个大批量，是指有上千万的数据量。 
     例子： 
     有一张短信历史表，其数据有上千万条数据，要进行数据备份到文本文件，就是执行如下SQL然后将结果集写入到文件中！ 
     select t.msisd
      
                                
      • 
                                
    • linux下模拟按键输入和鼠标
                                    被触发
linux
                                    
      查看/dev/input/eventX是什么类型的事件， cat /proc/bus/input/devices 
设备有着自己特殊的按键键码，我需要将一些标准的按键，比如0－9，X－Z等模拟成标准按键，比如KEY_0,KEY-Z等，所以需要用到按键 模拟，具体方法就是操作/dev/input/event1文件，向它写入个input_event结构体就可以模拟按键的输入了。 
 
linux/in
      
                                
      • 
                                
    • ContentProvider初体验
                                    肆无忌惮_
ContentProvider
                                    
      ContentProvider在安卓开发中非常重要。与Activity，Service，BroadcastReceiver并称安卓组件四大天王。 
在android中的作用是用来对外共享数据。因为安卓程序的数据库文件存放在data/data/packagename里面，这里面的文件默认都是私有的，别的程序无法访问。 
如果QQ游戏想访问手机QQ的帐号信息一键登录，那么就需要使用内容提供者COnte
      
                                
      • 
                                
    • 关于Spring MVC项目（maven）中通过fileupload上传文件
                                    843977358
mybatisspring mvc修改头像上传文件upload
                                    
      Spring MVC 中通过fileupload上传文件，其中项目使用maven管理。 
  
1.上传文件首先需要的是导入相关支持jar包：commons-fileupload.jar,commons-io.jar 
因为我是用的maven管理项目，所以要在pom文件中配置（每个人的jar包位置根据实际情况定） 
<!-- 文件上传 start by zhangyd-c --&g
      
                                
      • 
                                
    • 使用svnkit api，纯java操作svn，实现svn提交，更新等操作
                                    aigo
svnkit
                                    
       原文：http://blog.csdn.net/hardwin/article/details/7963318 
  
import java.io.File;  
  
import org.apache.log4j.Logger;  
import org.tmatesoft.svn.core.SVNCommitInfo;  
import org.tmateso
      
                                
      • 
                                
    • 对比浏览器，casperjs，httpclient的Header信息
                                    alleni123
爬虫crawlerheader
                                    
      		@Override
		protected void doGet(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException
		{
			String type=req.getParameter("type");
			Enumeration es=re
      
                                
      • 
                                
    • java.io操作 DataInputStream和DataOutputStream基本数据流
                                    百合不是茶
java流
                                    
      1，java中如果不保存整个对象，只保存类中的属性，那么我们可以使用本篇文章中的方法，如果要保存整个对象  先将类实例化  后面的文章将详细写到 
  
  
2，DataInputStream 是java.io包中一个数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用数据输出流写入稍后由数据输入流读取的数据。
      
                                
      • 
                                
    • 车辆保险理赔案例
                                    bijian1013
车险
                                    
      理赔案例： 
一货运车，运输公司为车辆购买了机动车商业险和交强险，也买了安全生产责任险，运输一车烟花爆竹，在行驶途中发生爆炸，出现车毁、货损、司机亡、炸死一路人、炸毁一间民宅等惨剧，针对这几种情况，该如何赔付。 
赔付建议和方案： 
客户所买交强险在这里不起作用，因为交强险的赔付前提是：“机动车发生道路交通意外事故”； 
如果是交通意外事故引发的爆炸，则优先适用交强险条款进行赔付，不足的部分由商业
      
                                
      • 
                                
    • 学习Spring必学的Java基础知识(5)—注解
                                    bijian1013
javaspring
                                    
              文章来源：http://www.iteye.com/topic/1123823，整理在我的博客有两个目的：一个是原文确实很不错，通俗易懂，督促自已将博主的这一系列关于Spring文章都学完；另一个原因是为免原文被博主删除，在此记录，方便以后查找阅读。 
  
        有必要对
      
                                
      • 
                                
    • 【Struts2一】Struts2 Hello World
                                    bit1129
Hello world
                                    
      Struts2 Hello World应用的基本步骤 
创建Struts2的Hello World应用，包括如下几步： 
1.配置web.xml 
2.创建Action 
3.创建struts.xml，配置Action 
4.启动web server，通过浏览器访问 
  配置web.xml 
<?xml version="1.0" encoding="
      
                                
      • 
                                
    • 【Avro二】Avro RPC框架
                                    bit1129
rpc
                                    
      1. Avro RPC简介 1.1. RPC 
 
 RPC逻辑上分为二层，一是传输层，负责网络通信；二是协议层，将数据按照一定协议格式打包和解包 
 从序列化方式来看，Apache Thrift 和Google的Protocol Buffers和Avro应该是属于同一个级别的框架，都能跨语言，性能优秀，数据精简，但是Avro的动态模式（不用生成代码，而且性能很好）这个特点让人非常喜欢，比较适合R
      
                                
      • 
                                
    • lua　set get cookie
                                    ronin47
lua cookie
                                    
      lua:
local access_token = ngx.var.cookie_SGAccessToken
if access_token then
    ngx.header["Set-Cookie"] = "SGAccessToken="..access_token.."; path=/;Max-Age=3000"
end
      
                                
      • 
                                
    • java-打印不大于N的质数
                                    bylijinnan
java
                                    
      

public class PrimeNumber {

	/**
	 * 寻找不大于N的质数
	 */
	public static void main(String[] args) {
		int n=100;
		PrimeNumber pn=new PrimeNumber();
		pn.printPrimeNumber(n);
		System.out.print
      
                                
      • 
                                
    • Spring源码学习-PropertyPlaceholderHelper
                                    bylijinnan
javaspring
                                    
      今天在看Spring 3.0.0.RELEASE的源码，发现PropertyPlaceholderHelper的一个bug 
当时觉得奇怪，上网一搜，果然是个bug，不过早就有人发现了，且已经修复： 
详见： 
http://forum.spring.io/forum/spring-projects/container/88107-propertyplaceholderhelper-bug 
 

      
                                
      • 
                                
    • [逻辑与拓扑]布尔逻辑与拓扑结构的结合会产生什么?
                                    comsci
拓扑
                                    
       
   如果我们已经在一个工作流的节点中嵌入了可以进行逻辑推理的代码,那么成百上千个这样的节点如果组成一个拓扑网络,而这个网络是可以自动遍历的,非线性的拓扑计算模型和节点内部的布尔逻辑处理的结合,会产生什么样的结果呢? 
 
   是否可以形成一种新的模糊语言识别和处理模型呢?  大家有兴趣可以试试,用软件搞这些有个好处,就是花钱比较少,就算不成
      
                                
      • 
                                
    • ITEYE 都换百度推广了
                                    cuisuqiang
GoogleAdSense百度推广广告外快
                                    
      以前ITEYE的广告都是谷歌的Google AdSense，现在都换成百度推广了。 
  
为什么个人博客设置里面还是Google AdSense呢？ 
  
都知道Google AdSense不好申请，这在ITEYE上也不是讨论了一两天了，强烈建议ITEYE换掉Google AdSense。至少，用一个好申请的吧。 
  
什么时候能从ITEYE上来点外快，哪怕少点
      
                                
      • 
                                
    • 新浪微博技术架构分析
                                    dalan_123
新浪微博架构
                                    
      新浪微博在短短一年时间内从零发展到五千万用户，我们的基层架构也发展了几个版本。第一版就是是非常快的，我们可以非常快的实现我们的模块。我们看一下技术特点，微博这个产品从架构上来分析，它需要解决的是发表和订阅的问题。我们第一版采用的是推的消息模式，假如说我们一个明星用户他有10万个粉丝，那就是说用户发表一条微博的时候，我们把这个微博消息攒成10万份，这样就是很简单了，第一版的架构实际上就是这两行字。第
      
                                
      • 
                                
    • 玩转ARP攻击
                                    dcj3sjt126com
r
                                    
      我写这片文章只是想让你明白深刻理解某一协议的好处。高手免看。如果有人利用这片文章所做的一切事情，盖不负责。 网上关于ARP的资料已经很多了，就不用我都说了。 用某一位高手的话来说，“我们能做的事情很多，唯一受限制的是我们的创造力和想象力”。 ARP也是如此。 以下讨论的机子有 一个要攻击的机子：10.5.4.178 硬件地址：52:54:4C:98
      
                                
      • 
                                
    • PHP编码规范
                                    dcj3sjt126com
编码规范
                                    
      一、文件格式 
1. 对于只含有 php 代码的文件，我们将在文件结尾处忽略掉 "?>" 。这是为了防止多余的空格或者其它字符影响到代码。例如：<?php$foo = 'foo';2. 缩进应该能够反映出代码的逻辑结果，尽量使用四个空格，禁止使用制表符TAB，因为这样能够保证有跨客户端编程器软件的灵活性。例
      
                                
      • 
                                
    • linux 脱机管理（nohup）
                                    eksliang
linux nohupnohup
                                    
      脱机管理 nohup 
转载请出自出处：http://eksliang.iteye.com/blog/2166699 
nohup可以让你在脱机或者注销系统后，还能够让工作继续进行。他的语法如下 
nohup [命令与参数]   --在终端机前台工作
nohup [命令与参数] & --在终端机后台工作 
  
但是这个命令需要注意的是，nohup并不支持bash的内置命令，所
      
                                
      • 
                                
    • BusinessObjects Enterprise Java SDK
                                    greemranqq
javaBOSAPCrystal Reports
                                    
      最近项目用到oracle_ADF  从SAP/BO 上调用 水晶报表，资料比较少，我做一个简单的分享，给和我一样的新手 提供更多的便利。 
  
首先，我是尝试用JAVA JSP 去访问的。 
  
官方API：http://devlibrary.businessobjects.com/BusinessObjectsxi/en/en/BOE_SDK/boesdk_ja
      
                                
      • 
                                
    • 系统负载剧变下的管控策略
                                    iamzhongyong
高并发
                                    
      假如目前的系统有100台机器，能够支撑每天1亿的点击量（这个就简单比喻一下），然后系统流量剧变了要，我如何应对，系统有那些策略可以处理，这里总结了一下之前的一些做法。 
1、水平扩展 
这个最容易理解，加机器，这样的话对于系统刚刚开始的伸缩性设计要求比较高，能够非常灵活的添加机器，来应对流量的变化。 
2、系统分组 
假如系统服务的业务不同，有优先级高的，有优先级低的，那就让不同的业务调用提前分组
      
                                
      • 
                                
    • BitTorrent DHT 协议中文翻译
                                    justjavac
bit
                                    
      前言 
做了一个磁力链接和BT种子的搜索引擎 {Magnet & Torrent}，因此把 DHT 协议重新看了一遍。 
 
 BEP: 5Title: DHT ProtocolVersion: 3dec52cb3ae103ce22358e3894b31cad47a6f22bLast-Modified: Tue Apr 2 16:51:45 2013 -070
      
                                
      • 
                                
    • Ubuntu下Java环境的搭建
                                    macroli
java工作ubuntu
                                    
      配置命令： 
　　$sudo apt-get install ubuntu-restricted-extras 
　　再运行如下命令： 
　　$sudo apt-get install sun-java6-jdk 
　　待安装完毕后选择默认Java. 
　　$sudo update- alternatives --config java 
　　安装过程提示选择，输入“2”即可，然后按回车键确定。 
      
                                
      • 
                                
    • js字符串转日期（兼容IE所有版本）
                                    qiaolevip
TODateStringIE
                                    
      	/**
	 * 字符串转时间（yyyy-MM-dd HH:mm:ss）
	 * result （分钟）
	 */
	stringToDate : function(fDate){
		var fullDate = fDate.split(" ")[0].split("-");
		var fullTime = fDate.split("
      
                                
      • 
                                
    • 【数据挖掘学习】关联规则算法Apriori的学习与SQL简单实现购物篮分析
                                    superlxw1234
sql数据挖掘关联规则
                                    
      关联规则挖掘用于寻找给定数据集中项之间的有趣的关联或相关关系。 
关联规则揭示了数据项间的未知的依赖关系，根据所挖掘的关联关系，可以从一个数据对象的信息来推断另一个数据对象的信息。 
例如购物篮分析。牛奶 ⇒ 面包 [支持度：3%，置信度：40%]  支持度3%：意味3%顾客同时购买牛奶和面包。   置信度40%：意味购买牛奶的顾客40%也购买面包。   规则的支持度和置信度是两个规则兴
      
                                
      • 
                                
    • Spring 5.0 的系统需求，期待你的反馈
                                    wiselyman
spring
                                    
              
       Spring 5.0将在2016年发布。Spring5.0将支持JDK 9。 
  
       Spring 5.0的特性计划还在工作中，请保持关注，所以作者希望从使用者得到关于Spring 5.0系统需求方面的反馈。 
 
      
                                
      •