{"id":15044329,"url":"https://github.com/traneio/future","last_synced_at":"2025-10-23T23:14:42.619Z","repository":{"id":57736357,"uuid":"77859095","full_name":"traneio/future","owner":"traneio","description":"High-performance Future implementation for the JVM","archived":false,"fork":false,"pushed_at":"2020-10-12T22:56:25.000Z","size":935,"stargazers_count":230,"open_issues_count":1,"forks_count":15,"subscribers_count":15,"default_branch":"master","last_synced_at":"2025-07-18T08:35:33.155Z","etag":null,"topics":["asynchronous","futures","java8","jvm","non-blocking"],"latest_commit_sha":null,"homepage":"http://trane.io","language":"Java","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/traneio.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":"CONTRIBUTING.md","funding":null,"license":"LICENSE.txt","code_of_conduct":"CODE_OF_CONDUCT.md","threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null}},"created_at":"2017-01-02T20:12:24.000Z","updated_at":"2025-06-30T06:12:38.000Z","dependencies_parsed_at":"2022-08-24T11:20:48.244Z","dependency_job_id":null,"html_url":"https://github.com/traneio/future","commit_stats":null,"previous_names":[],"tags_count":18,"template":false,"template_full_name":null,"purl":"pkg:github/traneio/future","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/traneio%2Ffuture","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/traneio%2Ffuture/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/traneio%2Ffuture/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/traneio%2Ffuture/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/traneio","download_url":"https://codeload.github.com/traneio/future/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/traneio%2Ffuture/sbom","scorecard":{"id":896839,"data":{"date":"2025-08-11","repo":{"name":"github.com/traneio/future","commit":"8368a841d623c0896db6297767208a6c42b58f27"},"scorecard":{"version":"v5.2.1-40-gf6ed084d","commit":"f6ed084d17c9236477efd66e5b258b9d4cc7b389"},"score":3.5,"checks":[{"name":"Packaging","score":-1,"reason":"packaging workflow not detected","details":["Warn: no GitHub/GitLab publishing workflow detected."],"documentation":{"short":"Determines if the project is published as a package that others can easily download, install, easily update, and uninstall.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#packaging"}},{"name":"Maintained","score":0,"reason":"0 commit(s) and 0 issue activity found in the last 90 days -- score normalized to 0","details":null,"documentation":{"short":"Determines if the project is \"actively maintained\".","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#maintained"}},{"name":"Code-Review","score":0,"reason":"Found 0/30 approved changesets -- score normalized to 0","details":null,"documentation":{"short":"Determines if the project requires human code review before pull requests (aka merge requests) are merged.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#code-review"}},{"name":"Dangerous-Workflow","score":-1,"reason":"no workflows found","details":null,"documentation":{"short":"Determines if the project's GitHub Action workflows avoid dangerous patterns.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#dangerous-workflow"}},{"name":"Token-Permissions","score":-1,"reason":"No tokens found","details":null,"documentation":{"short":"Determines if the project's workflows follow the principle of least privilege.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#token-permissions"}},{"name":"Binary-Artifacts","score":10,"reason":"no binaries found in the repo","details":null,"documentation":{"short":"Determines if the project has generated executable (binary) artifacts in the source repository.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#binary-artifacts"}},{"name":"SAST","score":0,"reason":"no SAST tool detected","details":["Warn: no pull requests merged into dev branch"],"documentation":{"short":"Determines if the project uses static code analysis.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#sast"}},{"name":"Pinned-Dependencies","score":-1,"reason":"no dependencies found","details":null,"documentation":{"short":"Determines if the project has declared and pinned the dependencies of its build process.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#pinned-dependencies"}},{"name":"CII-Best-Practices","score":0,"reason":"no effort to earn an OpenSSF best practices badge detected","details":null,"documentation":{"short":"Determines if the project has an OpenSSF (formerly CII) Best Practices Badge.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#cii-best-practices"}},{"name":"Security-Policy","score":0,"reason":"security policy file not detected","details":["Warn: no security policy file detected","Warn: no security file to analyze","Warn: no security file to analyze","Warn: no security file to analyze"],"documentation":{"short":"Determines if the project has published a security policy.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#security-policy"}},{"name":"Fuzzing","score":0,"reason":"project is not fuzzed","details":["Warn: no fuzzer integrations found"],"documentation":{"short":"Determines if the project uses fuzzing.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#fuzzing"}},{"name":"Signed-Releases","score":-1,"reason":"no releases found","details":null,"documentation":{"short":"Determines if the project cryptographically signs release artifacts.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#signed-releases"}},{"name":"License","score":10,"reason":"license file detected","details":["Info: project has a license file: LICENSE.txt:0","Info: FSF or OSI recognized license: Apache License 2.0: LICENSE.txt:0"],"documentation":{"short":"Determines if the project has defined a license.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#license"}},{"name":"Branch-Protection","score":-1,"reason":"internal error: error during branchesHandler.setup: internal error: githubv4.Query: Resource not accessible by integration","details":null,"documentation":{"short":"Determines if the default and release branches are protected with GitHub's branch protection settings.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#branch-protection"}},{"name":"Vulnerabilities","score":10,"reason":"0 existing vulnerabilities detected","details":null,"documentation":{"short":"Determines if the project has open, known unfixed vulnerabilities.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#vulnerabilities"}}]},"last_synced_at":"2025-08-24T14:02:52.903Z","repository_id":57736357,"created_at":"2025-08-24T14:02:52.903Z","updated_at":"2025-08-24T14:02:52.903Z"},"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":280706865,"owners_count":26376999,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","status":"online","status_checked_at":"2025-10-23T02:00:06.710Z","response_time":142,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["asynchronous","futures","java8","jvm","non-blocking"],"created_at":"2024-09-24T20:50:27.241Z","updated_at":"2025-10-23T23:14:42.561Z","avatar_url":"https://github.com/traneio.png","language":"Java","readme":"\n# Trane.io Future\n\n[![Build Status](https://travis-ci.org/traneio/future.svg?branch=master)](https://travis-ci.org/traneio/future)\n[![Code Coverage](https://sonarqube.com/api/badges/measure?key=io.trane:future\u0026metric=coverage)](https://sonarqube.com/dashboard?id=io.trane%3Afuture)\n[![Tech Debt](https://sonarqube.com/api/badges/measure?key=io.trane:future\u0026metric=sqale_debt_ratio)](https://sonarqube.com/dashboard?id=io.trane%3Afuture)\n[![Maven Central](https://maven-badges.herokuapp.com/maven-central/io.trane/future-java/badge.svg)](https://maven-badges.herokuapp.com/maven-central/io.trane/future-java)\n[![Javadocs](https://www.javadoc.io/badge/io.trane/future-java.svg)](https://www.javadoc.io/doc/io.trane/future-java)\n[![Join the chat at https://gitter.im/traneio/future](https://img.shields.io/badge/gitter-join%20chat-green.svg)](https://gitter.im/traneio/future?utm_source=badge\u0026utm_medium=badge\u0026utm_campaign=pr-badge\u0026utm_content=badge)\n\nThis project is a high-performance implementation of the `Future` abstraction. The library was designed from scratch with a focus on reducing CPU usage and memory footprint, and having the [Twitter `Future`](https://github.com/twitter/util) as its main inspiration.\n\nIt allows the user to express complex asynchronous code in a composable and type-safe manner. It also supports more advanced features that are currently only available for Twitter's Future and are essential to developing non-trivial systems. Namely, it provides `Local`s, that are similar to `ThreadLocal`s but for asynchronous code, and `interrupt`s, also known as cancellations.\n \nThe current version has only one implementation in Java, but the intent is to create modules for other JVM languages to make the API idiomatic in each language.\n\n## Getting started\n\nThe library binaries are distributed through maven central. Click on the maven central badge for information on how to add the library dependency to your project:\n\n[![Maven Central](https://maven-badges.herokuapp.com/maven-central/io.trane/future-java/badge.svg)](https://maven-badges.herokuapp.com/maven-central/io.trane/future-java)\n\nThis project does not have a mailing list; please use our gitter channel:\n\n[![Join the chat at https://gitter.im/traneio/future](https://img.shields.io/badge/gitter-join%20chat-green.svg)](https://gitter.im/traneio/future?utm_source=badge\u0026utm_medium=badge\u0026utm_campaign=pr-badge\u0026utm_content=badge)\n\nPlease refer to the Javadoc for detailed information about the library and its features:\n\n[![Javadoc](https://img.shields.io/badge/api-javadoc-green.svg)](http://trane.io/apidocs/future-java/current/)\n\n## The Future abstraction\n\n`Future` is an abstraction to deal with asynchronicity without having to use callbacks directly or blocking threads. The primary usage for `Futures` on the JVM is to perform IO operations, which are asynchronous by nature. \n\nAlthough most IO APIs return synchronously, they do that by blocking the current `Thread`. For instance, the thread issues a request to a remote system and then waits until a response comes back. Considering that the JVM uses native threads, it is wasteful to block them since it leads to potential thread starvation and higher garbage collection pressure. It is hard to scale a JVM system vertically if the IO throughput is bounded by the number of threads.\n\nFrom the user perspective, a `Future` can be in three states:\n\n1. Uncompleted\n2. Completed with a value\n3. Completed with an exception\n\nInstead of exposing this state, `Future` provides combinators to express computations that run once the `Future` completes. The results of these combinators are `Future` instances that can be used to perform other transformations, giving the user a powerful tool to express complex chains of asynchronous transformations.\n\nLet's say that we need to call a remote service to get the username given an id:\n\n```java\nFuture\u003cUser\u003e user = userService.get(userId);\n```\n\nIt's possible to apply the `map` transformation that produces a `Future` for the username string:\n\n```java\nFuture\u003cString\u003e username = user.map(user -\u003e user.username);\n```\n\nNote that we are using a lambda expression (`user -\u003e user.username`) that takes a user and returns its username.\n\nLet's say that now we need to call a service to validate the username string. This is the result if we use the `map` combinator for it:\n\n```java\nFuture\u003cFuture\u003cBoolean\u003e\u003e isValid = \n  username.map(username -\u003e usernameService.isValid(username));\n```\n\nGiven that the lambda expression calls another service and returns a `Future`, the produced result is a nested future (`Future\u003cFuture\u003cBoolean\u003e\u003e`). One alternative to flatten this nested result is using `Future.flatten`:\n\n```java\nFuture\u003cBoolean\u003e isValidFlat = Future.flatten(isValid);\n```\n\nThere's a convenient combinator called `flatMap` that applies both `map` and `Future.flatten` at once:\n\n```java\nFuture\u003cBoolean\u003e isValid = \n  username.flatMap(username -\u003e usernameService.isValid(username));\n```\n\nThe `flatMap` combinator is very flexible and comes from the monad abstraction. Although useful, learning monads and category theory is not a requirement to use `Future`s.\n\nThere are many other useful operators to deal with exceptions, collections of futures, and others. For a complete reference, please see the [javadocs](http://trane.io/apidocs/future-java/current/).\n\n## Execution model\n\n`Future`s are eager by nature. Once a future is created, the asynchronous computation is triggered. For instance, even though these two futures are composed sequentially through the `flatMap` combinator, they are already running in parallel:\n\n```java\nFuture\u003cUser\u003e user = userService.get(userId);\nFuture\u003cList\u003cTweet\u003e\u003e tweets = timelineService.getUserTweets(userId);\n\nFuture\u003cProfile\u003e profile = \n  user.flatMap(u -\u003e\n    tweets.map(t -\u003e\n      new Profile(u, t);\n    )\n  )\n```\n\nBoth calls are issued to the remote service when the futures are created, and the `flatMap` combinator only uses the `Future` instances that are already running. If the call to `tweetService` is inlined within the `flatMap` lambda body, the `tweetService` is called only after  the `userService` returns:\n\n```java\nFuture\u003cUser\u003e user = userService.get(userId);\n\nFuture\u003cProfile\u003e profile = \n  user.flatMap(u -\u003e\n    timelineService.getUserTweets(userId).map(t -\u003e\n      new Profile(u, t);\n    )\n  )\n```\n\nThis implementation of `Future` leverages this behavior to avoid context thread switches. The execution of the asynchronous computation reuses the current thread until it reaches an asynchronous boundary, where it cannot continue executing since it needs to wait for the completion of an asynchronous operation like a remote system call. For instance, this computation runs entirely on the current thread synchronously:\n\n```java\nFuture.value(1).map(i -\u003e i + 1);\n```\n\nIf there's an asynchronous boundary, the future composition is executed until it reaches the boundary:\n\n```java\nFuture.value(1)\n  .map(i -\u003e i + 1) // Runs on the current thread\n  .flatMap(i -\u003e callAService(i)); // Issues the request on the current thread\n```\n\nThis composition is executed by the current thread and stops at the point where the remote call is issued to the network layer. Once the remote service returns the response, the network layer thread continues the execution of the remaining steps:\n\n```java\nFuture.value(1)\n  .map(i -\u003e i + 1) // Runs on the current thread\n  .flatMap(i -\u003e callAService(i)) // Issues the request on the current thread\n  .map(i -\u003e i == 10); // Runs on the network thread that satisfies the async boundary\n```\n\nAsynchronous boundaries are defined using `Promise`s:\n\n```java\npublic Future\u003cInteger\u003e callAService(Integer i) {\n  Promise\u003cInteger\u003e p = Promise.apply();\n  networkLayer.issueRequest(i).onComplete(i -\u003e p.setValue(i));\n  return p;\n}\n```\n\nNote that `Promise` is a `Future` that provides methods to set its result. They are useful to interact with callback-based APIs like the ones that are typically provided by network libraries. The promise is created and returned synchronously to the caller, but it is pending until the `onComplete` callback is executed by the network layer.\n\nUsing `Promise`s, it is possible to create fully asynchronous code throughout the application stack and never block threads. It is a common misconception that blocking must happen at some layer of the application. For instance, it is possible to satisfy a request to a server and avoid blocking to write the result back to the client using a lambda that captures a reference to the network connection/session. Example:\n\n```java\npublic void processRequest(Request request, Connection conn) {\n  callEndpointMethod(request)\n    .onSuccess(result-\u003e conn.writeSuccess(result))\n    .onFailure(ex -\u003e conn.writeFailure(ex));\n}\n```\n\n## Recursive Futures\n\nGiven the optimization that this library implements to avoid thread context switch, compositions are not stack-safe by default. It is necessary to wrap recursive computations with a `Tailrec` call:\n\n```java\npublic Future\u003cInteger\u003e factorial(Integer i) {\n  Tailrec.apply(() -\u003e\n    if (i ==0) return Future.value(1);\n    else factorial(i - 1).map(j -\u003e i * j);\n  )\n}\n```\n\nThis is just an example, there's no reason to use `Future`s to implement a factorial function. Requiring the `Tailrec` call for recursive computations is a reasonable compromise since recursive futures are uncommon.\n\nEven though the computation is wrapped by `Tailrec`, the execution still leverages the synchronous execution optimizations in batches. It executes the composition synchronously until it reaches the batch size and then uses a `Promise` to unwind the stack and then run the next batch.\n\nThe default batch size is defined by the system property \"io.trane.future.defaultBatchSize\", which is `512` by default. Alternatively, it is possible to set the batch size when calling `Tailrec.apply`:\n\n```java\npublic Future\u003cInteger\u003e factorial(Integer i) {\n  Tailrec.apply(1024, () -\u003e\n    if (i ==0) return Future.value(1);\n    else factorial(i - 1).map(j -\u003e i * j);\n  )\n}\n```\n\nNote that the first parameter defines the batch size as `1024`. Typically, the users do not need to tune this parameter unless a `StackOverflowException` is thrown or the user wants to increase the batch size for performance reasons. Larger batches tend to improve performance but increase the risk of a `StackOverflowException`.\n\n## Isolating thread pools\n\nIt is possible to isolate portions of a `Future` composition on a separate thread pool:\n\n```java\nFuturePool futurePool = FuturePool.apply(Executors.newCachedThreadPool());\n\nFuture\u003cList\u003cToken\u003e\u003e user = \n  documentService.get(docId)\n    .flatMap(doc -\u003e futurePool.async(tokenize(doc)))\n```\n\nThis feature useful to isolate cpu-intensive tasks and blocking operations. Please refer to the Java documentation to decide which type of executor is the best for the kind of task that needs to be performed. For instance, a `ForkJoinPool` is useful for cpu-intensive tasks, but can't be used for blocking operations.\n\nThe `FuturePool` also has the method `isolate` that isolates the execution of a `Future`:\n\n```java\nFuturePool futurePool = FuturePool.apply(Executors.newCachedThreadPool());\n\nFuture\u003cUser\u003e user = futurePool.isolate(userRepo.get(userId));\n```\n\n`isolate` is just a shortcut for `async` + `Future.flatten`.\n\n## Locals\n\nIt is not possible to use `ThreadLocal`s with `Future` because the data it holds become invalid when the computation reaches an asynchronous boundary. The thread returns to its thread pool to execute other computations, and the continuations are performed by the thread that sets the result of the `Promise`.\n\n`Local`s are a mechanism similar to `ThreadLocal`, but it has a more flexible scope. For example, this code sets the `UserSession` local when a request is processed:\n\n```java\npublic class UserSession {\n  public static final Local\u003cUserSession\u003e local= Local.apply();\n  // UserSession impl\n}\n\npublic class MyService {\n  public Future\u003cList\u003cTweet\u003e\u003e getTweetsEndpoint(Request request) {\n    UserSession.local.let(\n      request.getSession(), \n      () -\u003e tweetRepo.get(request.getUserId())\n    );\n  }\n}\n```\n\nNote that the `let` method is used to define the local value, execute the function defined by the second parameter, and then set the local to its previous value. It is a convenient method to avoid having to set and clear the value manually:\n\n```java\npublic class MyService {\n  public Future\u003cList\u003cTweet\u003e\u003e getTweetsEndpoint(Request request) {\n    final Optional\u003cUserSessuib\u003e saved = UserSession.local.get();\n    UserSession.local.set(Optional.of(request.getSession()));\n    try {\n      return tweetRepo.get(request.getUserId());\n    } finally {\n      UserSession.local.set(saved);\n    }\n  }\n}\n```\n\nAt any point of the of the request processing, even after asynchronous boundaries, the user session can be accessed. For instance, let's say that `tweetRepo` uses a `TweetStorage` that routes the query to a specific database shard based on the user that is requesting the tweet:\n\n```java\npublic class TweetStorage {\n  public Future\u003cRawTweet\u003e getTweet(long tweetId) {\n    databaseFor(UserSession.local.get().getUserId()).getTweet(tweetId);\n  }\n}\n```\n\nThis feature is implemented with a `ThreadLocal` that is saved at the point of an asynchronous boundary as a `Promise` field and is restored when the `Promise` is satisfied, flushing its continuations with the original `ThreadLocal` contents.\n\nNote: This feature does not have the same behavior as Twitter's `Local`. The `ThreadLocal` state is captured when a `Promise` is created, whereas the Twitter's implementation captures the state only when a `Promise` continuation is created (for instance, `map` is called on a `Promise` instance). In practice, most `Promise` creations are followed by a continuation, so the behavior is usually the same.\n\n## Interrupts/cancellations\n\nThis feature provides a way to send signals to the current pending `Promise` given a `Future` composition. It is a mechanism that enables cancellations. For instance, given this composition that involves an async boundary (`userService.get`) and a continuation (`.map`):\n\n```java\nFuture\u003cString\u003e username = userService.get(userId).map(user -\u003e user.username);\n```\n\nIt is possible to raise an interrupt that is received by the `userService.get` `Promise`:\n\n```java\nusername.raise(new TimeoutException);\n```\n\nThe `Promise` created by `userService.get` can define a custom handler that performs an action in case an interrupt is received. \n\n`Promise.apply` has overloaded methods that allow the user to set the interrupt handler. This mechanism can be used to cancel requests to remote systems, as Finagle does.\n\nThe method `interruptible` is a shortcut to fail the `Promise` if it receives any interrupt signal:\n\n```java\nFuture\u003cString\u003e username = \n  userService.get(userId).interruptible().map(user -\u003e user.username);\n\nusername.raise(new TimeoutException);\n```\n\nIn this case, even if `userService.get` does not handle interrupts, the `Promise` is satisfied with the interrupt exception.\n\nThe interrupt propagation happens through pointers from each continuation to its parent that are created automatically by the library. In the previous example, the `map` continuation has a pointer to the `Promise` that is pending.\n\n## Benchmarks\n\nThis library scores better than the main `Future` implementations available on the JVM in multiple scenarios, both in terms of throughput and memory footprint.\n\nTo run the benchmarks, use the `run.sh` script under the `future-benchmark` folder. It also outputs results for Java's, Scala's, and Twitter's `Future` implementations for comparison.\n\n## FAQ\n\n**Why create a new Future implementation?**\n\nThis project aims to provide a `Future` implementation with the following characteristics:\n\n1. Pure Java implementation without dependencies\n2. Convenient API with combinators for common operations\n3. `Local` and interrupts support, essential for non-trivial systems\n4. Low CPU usage and memory footprint\n\nCurrently, there aren't other `Future` libraries with this feature set.\n\n**Why trane?**\n\nThe name is in honor of the great saxophonist [John Coltrane](http://www.johncoltrane.com/), also known as Trane (his nickname).\n\n\u003e “Invest yourself in everything you do. There's fun in being serious.” \n-- John Coltrane\n\n**Why is it high-performance?**\n\nSeveral techniques were used to optimize this library. For an overview, please refer to [CONTRIBUTING.md](https://github.com/traneio/future/blob/master/CONTRIBUTING.md#analyzing-performance).\n\n## Code of Conduct\n\nPlease note that this project is released with a Contributor Code of Conduct. By participating in this project you agree to abide by its terms. See [CODE_OF_CONDUCT.md](https://github.com/traneio/future/blob/master/CODE_OF_CONDUCT.md) for details.\n\n## License\n\nSee the [LICENSE](https://github.com/traneio/future/blob/master/LICENSE.txt) file for details.\n","funding_links":[],"categories":["并发编程"],"sub_categories":[],"project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Ftraneio%2Ffuture","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Ftraneio%2Ffuture","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Ftraneio%2Ffuture/lists"}