This easy-to-read, hands-on guide demystifies concurrency concepts like threading, asynchronous programming, and parallel processing in any language.
Perplexed by concurrency? Don’t be. This engaging, fully-illustrated beginner’s guide gets you writing the kind of high-performance code your apps deserve. Inside, you’ll find thorough explanations of concurrency’s core concepts—all explained with interesting illustrations, insightful examples, and detailed techniques you can apply to your own projects.
In Grokking Concurrency you will:
Get up to speed with the core concepts of concurrency, asynchrony, and parallel programming Learn the strengths and weaknesses of different hardware architectures Improve the sequential performance characteristics of your software Solve common problems for concurrent programming Compose patterns into a series of practices for writing scalable systems Write and implement concurrency systems that scale to any size
Discover effective concurrency practices that will help you leverage multiple cores, excel with high loads, handle terabytes of data, and continue working after hardware and software failures. The core concepts in this guide will remain eternally relevant, whether you’re building web apps, IoT systems, or handling big data.
About the technology:
Concurrency is an approach to running computer programs efficiently by separating them into tasks that can execute independently. This basic idea makes it possible to accelerate game graphics, train large AI models, rapidly scale web applications, streamline big data processing, and much more. Concurrency can get complicated, so this book gets you started gently with interesting examples, entertaining illustrations, and easy-to-follow Python code.
This is not your ordinary technical tome. No, it’s a book that will captivate and involve you, interweaving tales and cultural references into its pages. This book has evolved from a theoretical guide to a journey packed with stories, cultural references (count them all!), and hilarious illustrations. It’s a book that doesn’t shy away from humor—and a deep love for dumplings and pizza—because why should learning concurrency be a dull and dreary experience?
Together, we will conquer the complexities of concurrency and decipher the mystery of asynchrony. From the basics of concurrency to the fascinating world of async and await, we’ll use Python as our trusty companion and the language of choice. Don’t worry if Python isn’t your primary language—the concepts and techniques we’ll cover go beyond specific implementations.
“But why Python?” you may wonder. Well, dear reader, it strikes the perfect balance between simplicity and expressiveness, allowing us to focus on the essence of concurrency without unnecessary distractions. Besides, I simply enjoy it, and I won’t hide that fact.
About the book:
Grokking Concurrency is a perfectly paced introduction to the fundamentals of concurrent, parallel, and asynchronous programming. In it, you’ll learn the practices you’ll need to program multicore processors, GPUs, and other high-performance systems. Author Kirill Bobrov skips the math, jargon, and academic language and concentrates on clear, plain-English explanations.
Writing and running concurrent programs Patterns for performance, scalability, and resilience Choosing the right hardware Asynchronous communication
About the reader: Examples in Python. No prior experience with concurrency or high-performance computing required.
Part 1 The Octopus Orchestra: Introduction to a Symphony of Concurrency 1 Introducing concurrency 2 Serial and parallel execution 3 How computers work 4 Building blocks of concurrency 5 Interprocess communication Part 2 the Many Tentacles of Concurrency: Multitasking, Decomposition, and Synchronization 6 Multitasking 7 Decomposition 8 Solving concurrency problems: Race conditions and synchronization 9 Solving concurrency problems: Deadlocks and starvation Part 3 Asynchronous Octopuses: a Pizza-making Tale of Concurrency 10 Nonblocking I/O 11 Event-based concurrency 12 Asynchronous communication 13 Writing concurrent applications