awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
alibaba avatar

alibaba/transmittable-thread-local

0
View on GitHub↗
github.com/alibaba/transmittable-thread-local↗

Transmittable Thread Local

This project is a Java thread-local extension and context transmitter designed to preserve execution context across asynchronous boundaries. It provides the mechanisms necessary to pass thread-local variables from parent threads to child threads, ensuring data persists when using thread pool executors.

The library enables automatic context transmission through a Java agent that uses bytecode instrumentation to modify thread pool implementations without requiring source code changes. It also supports transparent instrumentation via executor service wrapping and task decoration for Runnable and Callable objects.

The system manages the capturing and restoration of thread-local state to prevent memory leaks and context pollution in reused pools. It includes support for custom value transmission logic to define how objects are copied between different thread contexts.

Features

  • Bytecode Instrumentation Agents - Provides a Java agent that instruments thread pool implementations to enable automatic context transmission.
  • Context-Capturing Task Wrappers - Decorates Runnable and Callable tasks to capture and restore thread-local state during execution.
  • Thread Pool Context Propagators - Transmits thread-local context from parent threads to tasks within thread pool executions.
  • Runtime Instrumentation Agents - Implements a Java agent that modifies bytecode at runtime to enable context transmission in thread pools.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI
8,304 stars·1,720 forks·Java·Apache-2.0·23 views
  • Thread-Local Extensions - Extends Java's ThreadLocal capabilities to allow variable transmission from parent to child threads in executors.
  • Background Task Decorators - Uses decorators to wrap Runnable and Callable tasks for capturing and restoring execution state.
  • Context-Aware Executor Wrappers - Wraps Java executor services to intercept task submission and automatically attach the current thread context.
  • Context-Propagating Executor Wrappers - Wraps executor services to handle automatic context transmission for all submitted tasks.
  • Thread-Local Context Management - Captures thread-local values in snapshots to propagate request-scoped state across asynchronous boundaries.
  • Context Transmission Logic - Provides a custom mechanism to handle deep or shallow object copies during cross-thread value transmission.
  • Task Execution Customizers - Implements custom task execution logic to capture and restore the current thread context.
  • Context Value Copying Strategies - Allows users to define custom copying logic for objects transferred between different thread contexts.
  • Request-Scoped State - Maintains request-scoped data and security contexts across complex thread boundaries in Java frameworks.
  • Star history

    Star history chart for alibaba/transmittable-thread-localStar history chart for alibaba/transmittable-thread-local

    How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

    Frequently asked questions

    What does alibaba/transmittable-thread-local do?

    This project is a Java thread-local extension and context transmitter designed to preserve execution context across asynchronous boundaries. It provides the mechanisms necessary to pass thread-local variables from parent threads to child threads, ensuring data persists when using thread pool executors.

    What are the main features of alibaba/transmittable-thread-local?

    The main features of alibaba/transmittable-thread-local are: Bytecode Instrumentation Agents, Context-Capturing Task Wrappers, Thread Pool Context Propagators, Runtime Instrumentation Agents, Thread-Local Extensions, Background Task Decorators, Context-Aware Executor Wrappers, Context-Propagating Executor Wrappers.

    Which projects share features with alibaba/transmittable-thread-local?

    Projects with overlapping indexed features include: powermock/powermock — Powermock is a Java mocking framework and unit testing tool that uses bytecode manipulation to mock static methods,… opengoofy/hippo4j — Hippo4j is a dynamic thread pool management toolkit for Java applications. It provides a centralized platform for… hujiangtechnology/gradle_plugin_android_aspectjx — This project is a Gradle plugin designed to facilitate aspect-oriented programming within Android applications. It… jacoco/jacoco — JaCoCo is a Java code coverage tool and bytecode instrumenter that measures which parts of source code are executed… alibaba/jvm-sandbox — jvm-sandbox is a bytecode instrumentation framework and plugin container for the Java Virtual Machine. It acts as a… btraceio/btrace — btrace is a JVM dynamic tracing tool and performance profiler used for injecting safe instrumentation scripts into a…

    Projects sharing features with Transmittable Thread Local

    These projects share indexed features with Transmittable Thread Local. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
    • powermock/powermockpowermock avatar

      powermock/powermock

      4,174View on GitHub↗

      Powermock is a Java mocking framework and unit testing tool that uses bytecode manipulation to mock static methods, final classes, and private constructors. It includes a Java agent instrumentation tool and a reflection-based testing utility to bypass encapsulation and modify class behavior at runtime. The project distinguishes itself by providing the ability to intercept the instantiation of objects via the new keyword and simulate the behavior of core Java system classes and native methods. It can override final modifiers on classes and methods and bypass signature restrictions for classes

      Java
      View on GitHub↗4,174
    • opengoofy/hippo4jopengoofy avatar

      opengoofy/hippo4j

      5,993View on GitHub↗

      Hippo4j is a dynamic thread pool management toolkit for Java applications. It provides a centralized platform for monitoring, adjusting, and extending thread pool behavior across distributed systems without requiring application restarts. The project distinguishes itself through runtime thread pool resizing, allowing live modification of core size, maximum size, queue capacity, and rejection policy. It includes an approval-based change workflow that requires administrative authorization before parameter modifications take effect in production. Hippo4j also exposes container thread pools for T

      Javablocking-queuedynamicdynamic-threadpool
      View on GitHub↗5,993
    • alibaba/jvm-sandboxalibaba avatar

      alibaba/jvm-sandbox

      6,954View on GitHub↗

      jvm-sandbox is a bytecode instrumentation framework and plugin container for the Java Virtual Machine. It acts as a runtime application modifier that enables the injection and modification of bytecode in a running process without requiring an application restart or changes to the original source code. The system provides a non-invasive aspect-oriented programming framework to intercept method execution and alter behavior in live processes. It functions as an isolated environment for functional modules, employing a custom class loader hierarchy to prevent dependency conflicts between plugins a

      Java
      View on GitHub↗6,954
    • btraceio/btracebtraceio avatar

      btraceio/btrace

      5,997View on GitHub↗

      btrace is a JVM dynamic tracing tool and performance profiler used for injecting safe instrumentation scripts into a running Java Virtual Machine without requiring a process restart. It functions as a Java agent framework and a Model Context Protocol server, exposing JVM diagnostic operations and tracing tools to large language models and AI assistants. The project distinguishes itself by enabling real-time code injection and bytecode-level instrumentation via a secure binary protocol. It ensures production stability through a static safety analysis engine that blocks unstable code patterns,

      Javabtracejavajava-application
      View on GitHub↗5,997
    Compare all 27 related projects→