# Java-Edge Java concurrency tutorial: a curriculum, not a library

> The Java-Concurrency-Progamming-Tutorial repository is a four year old curriculum of Java concurrency notes written in Chinese by a working engineer, organised as a syllabus that runs from atomicity and visibility through AQS and thread pools to caching, message queues, rate limiting and circuit breaking. There is no library to adopt, so the question is whether you want to work through somebody else's ordering of the subject.

**Java-Edge/Java-Concurrency-Progamming-Tutorial** — 大厂一线工程师四年磨一剑精心编排 Java 高并发编程教程。详细文档讲解请阅读本人的知识库仓：https://github.com/Wasabi1234/Java-Interview-Tutorial

- Repository: https://github.com/Java-Edge/Java-Concurrency-Progamming-Tutorial
- Stars: 1,232 · Forks: 268
- Language: Java
- License: Apache-2.0
- Published: 2026-10-19 · Updated: 2026-10-19 · Language: en
- Canonical page: https://hysenlabs.com/projects/java-edge-java-concurrency-progamming-tutorial

## A syllabus written by someone who ships code

The repository's stated goal is to build the most complete Java concurrency theory system available, so that programs become more reliable and interviews become easier, and the description credits a working engineer at a large company who spent four years compiling it. That framing matters for what the reader gets. There is no library, no framework and nothing to configure, because the repository is a documentation set with a small Maven project attached. The README itself is closer to a table of contents than to an introduction, and it points the reader onward: the detailed explanations live in the author's separate knowledge base repository, and this repository is the index. What the index does provide is an ordering, and that ordering is the content. The sequence moves from correctness inside one thread, to sharing between threads, to the tools the JDK provides, to the problems that appear once a system has more than one machine, and it finishes with the operational concerns, rate limiting, degradation, circuit breaking and sharding, that a concurrency curriculum in Chinese usually covers because Chinese internet service companies are where those problems get discussed.

## Thread safety, safe publication, and the strategies in between

The first block of the curriculum is the foundation. Thread safety is treated through three properties, atomicity, visibility and ordering, which is the standard decomposition and the right one to start from. Safe publication follows, and the README says it is taught through the various ways of writing a singleton class, which is a deliberate choice: the point is to put the keywords and the classes involved in thread safety back into a concrete scenario rather than leaving them abstract. The third block is thread safety strategy, covering the definition of immutable objects, thread confinement, synchronized containers and concurrent containers, which is where the JDK's concurrency package, J.U.C, is introduced as a natural consequence of the strategies rather than as a list of classes. The README also promises something practical that most textbooks skip, an inventory of thread unsafe classes and idioms that are common in day to day development, each paired with the alternative to use instead. For a reader who has been fixing production incidents rather than studying for an exam, that inventory is probably the most immediately useful part of the whole index, because the failure is rarely in the theory but in the habit.

## AQS first, then the components that are built on it

The curriculum treats the abstract queue synchroniser as the spine of the JDK concurrency package and calls it a must-ask interview topic, then derives the synchronisation components from it: CountDownLatch, Semaphore, CyclicBarrier, ReentrantLock and locks, and Condition. The stated goal for that section is not just usage, since the README says the components should be understood for their purposes and differences, and the reader should know what different method calls actually do, which is a fair description of the difference between knowing a CountDownLatch and knowing a CyclicBarrier. The next block extends the package with FutureTask, the Fork/Join framework and BlockingQueue, noting that these are used less often than the AQS family but are still part of the package and still need to be mastered. FutureTask gets a comparison with Callable, Runnable and Future, which is the right way to explain it, because FutureTask is the bridge between the two worlds and the comparison is what makes the bridge visible. The sequence from theory, to the synchroniser, to the components built on it, to the components beside it, is the order that makes the package teachable rather than a list of thirty classes.

## Thread pools, then the failures that concurrency causes

The scheduling section starts from the drawbacks of creating threads with `new Thread`, which is the right starting point for anyone who has done it in production, then covers the benefits of a pool, then goes deep on `ThreadPoolExecutor` itself, with its parameters, its states, its methods, its class diagram and the Executor framework interfaces. Thread pools are the part of concurrency that every Java service actually uses and the part that is most often configured by folklore, so the treatment of parameters and states is where the notes have the most value. After that the curriculum turns to the ways concurrency goes wrong, with a section on the conditions that produce deadlock and how to prevent it, on best practices for concurrent programming, on thread safety in Spring, and on the source details of HashMap and ConcurrentMap, which the README notes are favourite interview questions. The HashMap comparison is the one to read even if you are not interviewing, because the difference between a HashMap and a ConcurrentHashMap is where a lot of production concurrency bugs live.

## From the JVM outward: caching, queues, limits and degradation

The last third of the index leaves the language and covers the distributed systems problems that a concurrency curriculum has to address. Scaling comes first, with the difference between vertical and horizontal expansion and how database read and write operations are extended. Caching follows, with the characteristics of a cache such as hit rate, maximum elements and eviction policy, the factors that affect hit rate, the categories of cache and their scenarios, local against distributed, and the problems that appear under high concurrency, consistency, concurrent access, penetration and avalanche. Message queues come next, with the characteristics the README lists, being business independence, FIFO ordering, disaster tolerance and performance, and the reasons you need one, decoupling, eventual consistency, broadcast, and smoothing traffic with flow control. Then service decomposition, then rate limiting, where the README names four algorithms, counting, sliding window, leaky bucket and token bucket, then degradation and circuit breaking, split into automatic degradation triggered by timeouts, failure counts, faults and rate limiting, and manual degradation through a switch, with a summary of what degradation and circuit breaking have in common and where they differ. The scope of a single page of index, covering that much ground, tells you how dense the underlying notes are.

## How the material is delivered, and who it is for

The delivery details are modest and worth knowing. The diagrams, which the README credits to draw.io and to keynote, do much of the work in a curriculum about class diagrams and thread state machines, and the knowledge system image at the end of the README is itself a diagram of the whole map. The project publishes a mock interview analysis guide on a Chinese interview platform, which is the clearest signal of the intended audience: developers preparing for interviews as much as developers learning on the job. There is a QQ group and a WeChat group for discussion, and the author's personal WeChat contact is listed as well. In the repository itself, the `src/` directory and a `pom.xml` with a Maven wrapper suggest that the notes are accompanied by runnable example code, `assets/` holds the images used in the README, and the licence appears in two files, a `LICENSE` and a `license.txt`. The practical caveat for a non Chinese reader is the language, and the other caveat is the vintage. The repository's topic tags are written around Java 8, which is a reasonable base for a curriculum that has been assembled over four years, but the concurrency work added to later JDKs is not mentioned anywhere in the index.

## Conclusion

Adopt this repository as a reading track if you are a Java developer who knows the vocabulary of concurrency but has not built a systematic picture of it, and if you read Chinese. Do not adopt it as a dependency, because there is nothing to depend on, and do not treat it as a reference to quote in a design document, since it is a personal curriculum with a point of view and a Chinese audience. Before you start, check the age of the material, since the repository's own topic list is written around Java 8 and the newer concurrency work in the JDK is not mentioned, and expect to translate concepts rather than copy code, because the walkthroughs are explanations with diagrams. The licence is Apache 2.0, the repository publishes no GitHub releases, and the last push was on 2026-10-14.

## FAQ

### What does the Java concurrency tutorial repository actually contain?

It is a Chinese language curriculum of Java concurrency notes with a small Maven project attached, organised as a syllabus. The README is an index, and the detailed explanations are pointed at the author's separate knowledge base repository.

### Which concurrency topics does the Java-Edge tutorial cover?

Thread safety through atomicity, visibility and ordering, safe publication through singleton implementations, thread safety strategies such as immutable objects and thread confinement, AQS and the components built on it including CountDownLatch, Semaphore, CyclicBarrier, ReentrantLock and Condition, then FutureTask, Fork/Join and BlockingQueue, thread pools and ThreadPoolExecutor, deadlocks, and finally caching, message queues, rate limiting, degradation, circuit breaking and sharding.

### Is there code I can run in the Java-Concurrency-Progamming-Tutorial repository?

The repository contains a `src/` directory, a `pom.xml` and a Maven wrapper, alongside the notes and the `assets/` images used in the README, so the examples are set up as a Maven project. The README itself is an index of topics rather than instructions for running anything.

### What licence does the Java-Edge tutorial use?

The repository carries an Apache 2.0 licence, visible in the licence files at the root of the tree. The README also mentions a separate mock interview analysis guide published on a Chinese interview platform.

## Sources

- [Issues](https://github.com/Java-Edge/Java-Concurrency-Progamming-Tutorial/issues)
- [Java-Edge/Java-Concurrency-Progamming-Tutorial on GitHub](https://github.com/Java-Edge/Java-Concurrency-Progamming-Tutorial)
- [License: Apache-2.0](https://github.com/Java-Edge/Java-Concurrency-Progamming-Tutorial/blob/master/LICENSE)
- [README](https://github.com/Java-Edge/Java-Concurrency-Progamming-Tutorial/blob/master/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/java-edge-java-concurrency-progamming-tutorial