What do you get with a Packt Subscription?

Free for first 7 days. $19.99 p/m after that. Cancel any time!

Unlimited ad-free access to the largest independent learning library in tech. Access this title and thousands more!

50+ new titles added per month, including many first-to-market concepts and exclusive early access to books as they are being written.

Innovative learning tools, including AI book assistants, code context explainers, and text-to-speech.

Thousands of reference materials covering every tech concept you need to stay up to date.

Subscribe now

View plans & pricing

Key benefits

Learn about the Go concurrency primitives, Go memory model, and common concurrency patterns

Develop the insights on how to model solutions to real-life problems using concurrency

Explore practical techniques to analyze how concurrent programs behave

Description

The Go language has been gaining momentum due to its treatment of concurrency as a core language feature, making concurrent programming more accessible than ever. However, concurrency is still an inherently difficult skill to master, since it requires the development of the right mindset to decompose problems into concurrent components correctly. This book will guide you in deepening your understanding of concurrency and show you how to make the most of its advantages. You’ll start by learning what guarantees are offered by the language when running concurrent programs. Through multiple examples, you will see how to use this information to develop concurrent algorithms that run without data races and complete successfully. You’ll also find out all you need to know about multiple common concurrency patterns, such as worker pools, asynchronous pipelines, fan-in/fan-out, scheduling periodic or future tasks, and error and panic handling in goroutines. The central theme of this book is to give you, the developer, an understanding of why concurrent programs behave the way they do, and how they can be used to build correct programs that work the same way in all platforms. By the time you finish the final chapter, you’ll be able to develop, analyze, and troubleshoot concurrent algorithms written in Go.

Who is this book for?

If you are a developer with basic knowledge of Go and are looking to gain expertise in highly concurrent backend application development, then this book is for you. Intermediate Go developers who want to make their backend systems more robust and scalable will also find plenty of useful information. Prior exposure Go is a prerequisite.

What you will learn

Understand basic concurrency concepts and problems

Learn about Go concurrency primitives and how they work

Learn about the Go memory model and why it is important

Understand how to use common concurrency patterns

See how you can deal with errors in a concurrent program

Discover useful techniques for troubleshooting

What do you get with a Packt Subscription?

Free for first 7 days. $19.99 p/m after that. Cancel any time!

Unlimited ad-free access to the largest independent learning library in tech. Access this title and thousands more!

50+ new titles added per month, including many first-to-market concepts and exclusive early access to books as they are being written.

Innovative learning tools, including AI book assistants, code context explainers, and text-to-speech.

Thousands of reference materials covering every tech concept you need to stay up to date.

Subscribe now

View plans & pricing

Frequently bought together

€29.99

€29.99

€37.99

Total € 97.97

Thanh Feb 10, 2024

This is one of the better book in Go concurrency, but it is hard to follow, starting chapter 2 and 3, there are many snippets of codes that demonstrate many concepts but it is hard to picture a complete program and hard to understand what the block of code does without a full code example on github.com or in the book. For a more experience Gopher, it might not be a problem, but for the new Gopher, it is a bit hard follow. So if one put and effort in writing a book to help other learn the language, please try to make chapter 2, 3 easier to understand. Starting chapter 5 to the end of the book the concepts of concurrency started to be more clear and the step by step instruction for the examples make it easier to understand and follow. To me the best way to teach programming is to follow a consistent format for example: 1. Provide a high level overview of problem we are about to learn, show some example program output and out put to show what the how the program work, but the key is help the student see the big picture before teach the details concept. 2. Start breaking the code in small bock and start explain the feature of this block of code and how each function works. 3. Putting it all together with the complete code base. For most people with some experience with the language, they should be able to read the code and explain what the program does providing a more complete code example. Thank for for reading my input, I am not sure I you can even understand my writing as I am new and still have a lot to learn. Best regards,

Subscriber review

Tans Jun 07, 2023

This is a well- written book which helps in strengthening your understanding of concurrency and will also teaches you how to make use of it. It teaches you how concurrent programs can be used to build correct programs that work the same way in all platforms. The author has provided valuable knowledge by using multiple examples in the book. It gives insights on how to model solutions to real life problems using concurrency. There is so much to learn from the book and I highly recommend it.

Amazon Verified review

opinionated reader Jun 01, 2023

Over the last decade of working with Go, I've read a lot of books. There are some good ones, classics even, but there's always been a hole waiting to be filled by one that truly displays the process of concurrency, and the patterns that are derived from it, in a fashion that is instantly accessible, understandable, and usable by the mass of programmers that long for it. The title, "Effective Concurrency in Go" does not even begin to express how possible this is.From the preface (highly recommended to read) to the index (extremely useful for reference), this book hits most of the right notes. Burak walks the user through real situations that we hit every day, in a cohesive fashion from start to finish. However, what really gets me is not the relevance of his source code, nor the conciseness of how he proceeds through each example towards a greater step, but the care he takes to make sure that even the beginner can understand the leaps that he is making (whilst not leaving the expert behind).I have posted a few examples of Mr. Serdar's care, but it is the tip of the iceberg. Even experts will find that there are things to be discovered.For example, in chapter 4 I've found the concurrency problems reasons to consider how I do things. The dining philosophers problem was an excellent pick. It details concurrency as a scaleable construct and demonstrates how restricted resources can be shared among the pool, whilst keeping memory access in mind. The pattern he puts forth can serve as a foundation for many problems we face today. It also leads into solutions like rate limiting that are readily a question for a Go architect on most greenfield projects.There are sections and things that hound us as well: error handling, race conditions, and even streaming, that have been covered in other fine books. Yet, not so engagingly; not with the sense of immediate application. The real strength of this book lies in the fine line that it plays between cookbook and theology. You can immediately use most of the material, but you learn so much about why you are using it, that you may never code the same way again - I know that I won't be.Of note, having read both the physical and the ebook, I do recommend the physical copy. Many of the code samples and architectural figures read better on a two page basis. The ebook is not deficient in any form, but that the book is formatted better for viewing the code and content together side by side. I have posted an example later in the book of debugging that takes advantage of this feature.This is a book that I will share with my friends widely. Burak Serdar has produced a shining star that I could only hope to put out there. It's as solid a foundation as many put out before, but more accessible by far! Maybe skip the other concurrency books and come straight here!

Amazon Verified review

Krishnan Raghavan Aug 31, 2023

This book is about understanding Concurrency and how to implement the same using Go. The author expects the reader to have a basic understanding of Go and is looking to gain expertise in highly concurrent backend application development.The book starts by explaining what is Concurrency and how it relates to parallelism as part of Chapter 1. Chapter 2 introduces the readers to Go language primitives for concurrent programming. Chapter 3 talks about visibility guarantees of memory operations and some of the standard library facilities while Chapter 4 talks about some of the well-known concurrency problems like the producer/consumer problem, the dining philosophers problem, and rate limiting. Chapter 5 helps the reader understand how to process large amounts of data with limited concurrency using worker pools and pipelines.Chapter 6 helps the reader understand about error handling in a concurrent program and how to pass errors around. Chapter 7 talks about Timers and Tickers that will help the reader understand how to do things periodically or later. Chapter 8 helps the reader understand better how to handle requests concurrently. This chapter mostly talks about server programming. Chapter 9 talks about Atomic Memory Operations and their practical uses. Chapter 10 talks about troubleshooting concurrency issues and helps the user understand some of the techniques that can be used for troubleshooting without using the debugger.This is quite a difficult topic to cover but the author Burak Serdar has done a wonderful job of simplifying the same for the readers. Kudos to Burak Serdar for writing this book.

Amazon Verified review

POE May 12, 2023

This book covers the specific topic of concurrency using Go. The author’s experience is evident, and the book’s organization and content are ideal. Topics covered include an overview of concurrency, the Go memory model, Goroutines, channels, and primitives. The common concurrency problems are addressed as are worker pools and pipelines. Error handling, timers, and tickers are also covered.Readers should already be familiar with the Go language. This is well worth the purchase and time to read it.

Amazon Verified review

Effective Concurrency in Go: Develop, analyze, and troubleshoot high performance concurrent applications with ease

What do you get with a Packt Subscription?