concurrent: a Chinese GitBook on Java concurrency, with a Dockerfile that patches its own toolchain

Three commands and a global npm install

Reading the book locally takes three steps, and the first one modifies your machine outside the project. Install the GitBook command line tool globally:

npm install gitbook-cli -g

Then install the plugins the book declares:

gitbook install

And serve the directory:

gitbook serve .

After that the content is reachable at http://localhost:4000. A short English reading note in the same file repeats the last step in one line: run `gitbook serve .` after installing dependencies to preview the content locally. Two consequences follow from the shape of this. First, the toolchain is not vendored, so the gitbook version you end up with is whatever npm resolves, and the project pins nothing about it in the README. Second, the global install is a real cost for a reader who only wants to read: the README also offers two hosted web versions and a PDF.

The Dockerfile patches gitbook 3.2.3 to skip a prompt

The container image is where the project's real engineering shows, and one line in it is unusual. The build starts from `node:10.23.1-alpine3.9`, copies the repository into `/app/portal`, installs gitbook-cli and the plugins, then rewrites a file inside the installed gitbook itself:

FROM node:10.23.1-alpine3.9

COPY . /app/portal
WORKDIR /app/portal
RUN npm i gitbook-cli -g \
  && gitbook install \
  && sed -i 's/confirm: true/confirm: false/g' ~/.gitbook/versions/3.2.3/lib/output/website/copyPluginAssets.js
CMD ["gitbook", "serve", "."]

EXPOSE 4000

The `sed` expression flips a confirmation flag from true to false in `copyPluginAssets.js`, which is gitbook's asset copying step, so the build stops asking and keeps going. The path names version 3.2.3 explicitly, which is the whole catch: that substitution only applies to that gitbook release, so anyone who changes the gitbook version has to update the path or lose the patch and get an interactive prompt inside a build. Note also the Node 10 base, and `EXPOSE 4000` matching the port the README tells you to open.

The PDF lags behind, by its own admission

Three ways to read the book are offered, and one of them comes with a warning. The first is a site hosted by the community at concurrent.redspider.group/RedSpider.html, marked with a strong recommendation in the README. The second is a GitBook edition at redspider.gitbook.io/concurrent/. The third is a PDF kept in the repository at `./book.pdf`, and next to that entry the README says PDF generation is troublesome, is not produced on every commit, and suggests reading the web version instead. That is an honest statement about a known failure mode rather than a promise, and it has a direct consequence for anyone citing or archiving the material: the PDF in a clone can be older than the chapters beside it. The English reading note at the end of the file points back to the local preview route, which is consistent with the web-first framing.

A community discussion written up as a book

The origin story explains the editorial method. After reading what was available on Java concurrent programming, the author found some points were not clear, so a discussion about Java concurrency principles was held inside the RedSpider community, and the outcome was organised into a book and shared in the spirit of open source. The sourcing rule is specific and worth quoting in substance: content comes mainly from blogs, books and papers; knowledge already explained clearly is quoted directly; knowledge that is not explained clearly is reworked with diagrams or with written demos; and for points that are ambiguous, the book gives the most reasonable interpretation after consulting a large amount of source writing. A synthesised answer to an ambiguous question is an interpretation rather than a settled fact. The book is written in Chinese, and a companion WeChat account publishes one original Java article a week.

SUMMARY.md decides what the book contains

The tree is a GitBook project, and its shape explains how the content is organised. `book.json` holds the book configuration, `SUMMARY.md` is the table of contents that GitBook renders, and `article/` holds the chapters as Markdown files listed in that summary. `imgs/` holds the diagrams the method above depends on, while `js/` and `styles/` sit alongside them. There are also `Author.md` for the author page, `RedSpider.md` for the community, `package-lock.json`, a `Dockerfile`, `LICENSE.txt` under the MIT licence, and a `.drone.yml` for Drone continuous integration. One file, `codex-flow-verification.txt`, sits at the root with no explanation anywhere in the README, and a `.DS_Store` was committed as well, which is the kind of noise that happens in a repository maintained by hand rather than by a pipeline.

No releases, and corrections go into issues

There are no GitHub releases for this repository, so there is nothing to pin and no artifact to download; the book is read from the web, cloned from git, or served from the image. The default branch is develop and the last push landed on 2026-07-10, which is recent enough that the branch is not abandoned, but with no tags a clone of develop is the only way to get the current text. Corrections are handled the same informal way. The README acknowledges that the author's level is limited and the writing time was short, so errors and imprecise passages are expected, and asks readers to open an issue on the GitHub repository, promising a reply, with the repository address printed in full. Sponsorship for the book or the community is handled by email to the RedSpider mailing list address or through a WeChat contact.

Editorial conclusion

Fit if you read Chinese and want a structured explanation of Java concurrency principles with demos, and you are willing to install a global npm CLI to read it. Skip it if you need English text, a versioned artifact, or a PDF that matches the latest commit. Before you rely on it, read the web version rather than the PDF, check that the gitbook version in your own environment matches the 3.2.3 path the container patches, and treat the maintainers' own invitation to open issues as the errata channel.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. README
4. RedSpider1/concurrent on GitHub