A Guide to Java High Concurrency Programming

Name: A Guide to Java High Concurrency Programming
ISBN: 9787301289464

谢议尊Peking University Press · ChinaAug 2025

3.5

Word count: 167K words
Chapters: 77
ISBN: 9787301289464

Report an error Find this book

Summary

With the growth of the mobile internet, virtually every mainstream internet application must cope with high-concurrency scenarios. Whether you are new to Java or a seasoned Java developer, understanding and mastering Java high-concurrency programming is essential. Java High-Concurrency Programming Guide explains this subject in a progressive, hands-on way that combines theory with practice.

It first introduces the concept of high concurrency, Java multithreading fundamentals, and the use and design principles of classes in the Java concurrency package; it then expands into the principles, challenges, frameworks, and middleware involved in distributed system design. It analyzes the source-code design of popular Java open-source frameworks and, by building a simplified system, shows how to implement a high-concurrency system in Java—combining principles with practice to help readers better master Java high-concurrency programming.

Editor's review

This book is aimed at Java developers who need to handle high-concurrency scenarios, and it follows a progressive, theory-plus-practice approach. The first half begins with multithreading fundamentals and the use and design principles of the concurrency package, helping readers build a correct understanding of thread safety, synchronization mechanisms, and concurrency tools; the second half extends to the principles, challenges, common frameworks, and middleware of distributed system design, and through analysis of the source code of popular open-source frameworks guides readers to understand the design trade-offs behind high-concurrency systems. A distinctive feature is that it ties the knowledge together by building a simple system, so that readers do not stop at the level of API calls but can experience the complete line of thinking from requirements to architecture and from single-machine concurrency to distributed collaboration. For developers preparing for interviews, participating in high-concurrency projects, or hoping to fill gaps in their concurrency knowledge, this book can serve as a roadmap for systematic study. When reading, it is recommended to follow along and build the examples by hand and to run comparative experiments around the concurrency points in your own projects, which will make the results more solid.

Who it's for

A good fit for

Junior and mid-level developers with a Java foundation who want to systematically fill gaps in their high-concurrency knowledge
Job seekers preparing for back-end development interviews who need to organize their knowledge of concurrency and distributed systems
Engineers currently involved in high-concurrency projects who want to understand the design ideas behind framework source code
Upper-year students in computer-related majors who want to move from classroom learning to engineering practice

Not a good fit for

Readers starting from zero programming who have no Java syntax foundation at all
Readers focused only on front-end or mobile development and not yet involved in back-end concurrency scenarios
Readers expecting purely theoretical derivation or academic research on distributed systems

Reading tips

First read through the multithreading fundamentals and concurrency package sections, and write a small example to verify the behavior of each tool you learn.
When you reach the framework source code analysis, take notes against the usage scenarios in your own projects and record the design trade-offs.
When following along with the simple high-concurrency system, sketch the architecture before coding, and finally review the bottlenecks and improvement points.
Read the distributed chapters alongside the single-machine concurrency chapters, and sort out the evolution logic from threads to service decomposition.

About the publisher

Peking University Press China · Founded in 1979

Peking University Press is a comprehensive university press whose publishing areas cover classical literature, popular science, social culture, world history, Western philosophy, and culture. Its catalogue contains 6,031 titles, with representative books including A Dream of Red Mansions, Relativity: The Special and General Theory (15th Edition) (with Einstein's classic papers on unified field theory and other topics), Elements, Conics, The Aristocratic Families of the Eastern Jin, The Philosophy of Mythology (Volume I), The Philosophy of Mythology (Volume II), and The Origin of Continents and Oceans. Representative authors include Cao Xueqin, Zhou Ruchang, Albert Einstein, Euclid, Apollonius, Tian Yuqing, Schelling, and Xian Gang. The press has developed distinctive strengths in classical Chinese literature and in the translation of Western philosophical classics, while also covering scientific classics and social and cultural studies. As public information is limited, this description is based only on the books in the catalogue and offers no further extrapolation.

版权信息
前言
第一部分基础篇
第1章高并发的理解
1.1 何为高并发
1.2 高并发的应对策略
1.3 小结
第2章操作系统多线程基础
2.1 线程概念
2.2 多线程的挑战
2.3 小结
第3章 Java多线程基础
3.1 线程的使用
3.2 线程的状态与状态转换
3.3 线程安全
3.4 小结
第二部分基进础阶篇
第4章 Executor线程池框架
4.1 Executor线程池框架设计概述
4.2 Executor接口与ExecutorService接口
4.3 ThreadPoolExecutor线程池
4.4 Future任务的异步结果
4.5 ScheduledExecutorService任务周期性执行
4.6 Executors线程池创建工具
4.7 ForkJoin任务分解与并行执行框架
4.8 小结
第5章 Java线程安全字典
5.1 Hashtable全同步Map
5.2 SynchronizedMap同步器Map
5.3 ConcurrentHashMap并发Map
5.4 ConcurrentSkipListMap有序并发Map
5.5 小结
第6章 Java并发队列
6.1 BlockingQueue阻塞先入先出队列
6.2 BlockingDeque阻塞先入先出双端队列
6.3 ConcurrentLinkedQueue并发队列
6.4 CopyOnWriteArrayList写时拷贝列表
6.5 小结
第7章 AQS线程同步器
7.1 AQS线程同步器基础
7.2 ReentrantLock可重入锁
7.3 CountDownLatch倒计时同步器
7.4 CyclicBarrier循环栅栏同步器
7.5 Semaphore信号量同步器
7.6 小结
第三部分基拓展础篇
第8章分布式系统设计理论
8.1 系统架构演进
8.2 分布式理论
8.3 高并发
8.4 负载均衡
8.5 缓存机制
8.6 异步处理
8.7 高可用
8.8 可靠性与容错机制
8.9 小结
第9章 Java分布式应用设计核心技术
9.1 分布式服务调用RPC框架
9.2 分布式消息队列
9.3 AMQP协议实现：RabbitMQ
9.4 海量消息处理：Kafka
9.5 Redis消息队列与发布订阅
9.6 分布式缓存
9.7 分布式锁
9.8 小结
第四部分基实战础篇
第10章开源框架高并发源码分析
10.1 Dubbo高并发编程实战
10.2 Netty与Tomcat的线程模型
10.3 小结
第11章秒杀系统设计分析
11.1 秒杀系统设计概述
11.2 限流机制
11.3 缓存的使用
11.4 分布式锁的使用
11.5 队列削峰与异步处理
11.6 小结

FAQ

What background do I need to read this book?

It is recommended that you have a foundation in Java syntax and basic multithreading concepts, such as knowing the purpose of Thread, locks, and thread pools. The book starts from the basics, but its pace is aimed at readers with some development experience; if you have never been exposed to Java at all, it will be rather difficult to read, and it is best to build up the language foundation first.

What aspects of distributed systems does the book cover?

According to the introduction, the distributed part involves the principles of system design, common challenges, and related frameworks and middleware. It leans more toward design thinking and understanding of technology selection in engineering practice rather than purely theoretical derivation. Readers can use it to build a knowledge connection from single-machine concurrency to distributed collaboration.

Can I understand it without high-concurrency project experience?

Yes, but you need to combine it with hands-on practice. The book adopts an approach that combines theory with practice and includes content on building a simple system. Readers without project experience are advised to follow along with the examples and simulate scenarios themselves; when encountering the source code analysis sections, they can first grasp the overall design ideas and do not need to scrutinize every line of detail from the start.

Is this book suitable for interview preparation?

It can be used as material for organizing knowledge. The book covers commonly tested areas such as multithreading fundamentals, the concurrency package, distributed systems, and framework source code, which helps build a system. However, interviews also require practicing expression in connection with specific questions and project experience, so it is recommended to organize the knowledge points in the book into your own Q&A notes and combine them with actual coding to deepen your understanding.

Comments

Find this book

This site is an index: you start “Search all sources” in your browser, and the entries it lists all point to third-party sites; please judge their availability yourself.

About the author

谢议尊 Author · China

Xie Yizun is a Chinese author of programming books. Public information about him is currently limited, and little can be confirmed about his identity beyond his representative work, Java High-Concurrency Programming Guide, which is classified in the library under programming design. Judging from this subject, Xie's writing focuses on Java development practice in high-concurrency scenarios and is aimed at readers who need to understand concurrency principles and improve their engineering skills. High-concurrency programming involves specialized topics such as thread models, synchronization mechanisms, and performance tuning, and writing about them usually requires a systematic grasp of the Java technology stack. As the only work of his currently available, the book suggests that his technical writing tends toward the practical and topic-specific, developed around one focused and in-depth direction. Since biographical details have not been made public, readers mainly come to know Xie through this work, and his future writing remains to be seen. This profile is based solely on the available library facts and information about the work.