Let's learn about Concurrency via these 62 free blog posts. They are ordered by HackerNoon reader engagement data. Visit the Learn Repo or LearnRepo.com to find the most read blog posts about any technology.
The ability of different parts of a program or multiple programs to execute out-of-order or in partial order without affecting the final outcome, crucial for maximizing resource utilization and responsiveness in modern systems.
1. Async/Await in Golang: An Introductory Guide
Golang is a concurrent programming language. It has powerful features like Goroutines and Channels that can handle asynchronous tasks very well. Also, goroutines are not OS threads, and that's why you can spin up as many goroutines as you want without much overhead, it's stack size starts at 2KB only. So why async/await? Async/Await is a nice language feature that provides a simpler interface to asynchronous programming.
2. Optimistic and Pessimistic Locking in JPA
The article explains optimistic and pessimistic locking. We consider a Spring Data JPA application with concurrent transactional code as an example.
3. Concurrent Programming in Python is not what you think it is.
Originally published on melvinkoh.me
4. Mastering Synchronization Primitives in Go
Golang's Goroutines make it easy to run code concurrently. We can simply add the keyword “go” in front of a function call to make it run in a separate routine, or asynchronously.
5. Solve Database Concurrency Issues with TypeOrm
Solve concurrency issues with typeorm query to fix race-condition and deadlock bug.
6. Understanding Concurrent Collections in C#
A brief introduction to concurrent collections in c sharp.
7. Leveraging Multithreading To Read Large Files Faster In Go
The other day I was interviewing at one of the companies, and I was asked the following question, how can you count occurrences of a word in a 50gb file with 4gb of RAM. The trick is to not load the whole file into memory and keep processing each word as we keep on moving the pointer of the file. With this, we can easily process the whole file with a minimal amount of memory resources.
8. Comparing Optimistic and Pessimistic Locking With GO and PostgreSQL
Comparison between Optimistic and Pessimistic locking with Golang and PostgreSQL
9. Goroutines: How to Run Concurrency Code in Go
Try out concurrency in Go on a simple example. What are greenthreads and asynchronous preemtpion? Understanding channels by using worker-pool pattern.
10. Concurrency in Golang And WorkerPool [Part 1]
Project Link: https://github.com/Joker666/goworkerpool
11. How Does Node.js Achieve Concurrency?
Ever wondered how Node.js handles multiple requests despite being single threaded? Find out the secret to concurrency in Node.js and how the event loop works
12. Parallel Merge Sort with Fork/Join Framework
In this article, I show how to use the ForkJoinPool, which hasn’t received significant dissemination among Java developers.
13. Smoke Your Server Using Goroutines
We all want to test our servers and the latency induced by scale. There are different ways to do that one way would be to use postman to send multiple requests. But how do I send concurrent requests? Say I want to a million requests with different levels of concurrency. This can be easily achieved by leveraging the power of Goroutines.
14. Concurrent React Mode: Using Suspense and useTransition to Build A Better UX
15. How We Increased Database Query Concurrency by 20 Times
Learn 5 ways to accelerate point queries and 4 methods to further improve concurrency: row storage format, short circuit, prepared statement, and row storage ca
16. Understanding Concurrency and Multithreading in iOS Development
An introduction to concurrency and multithreading in iOS development
17. Why Rust Is So Popular?
If you are looking for some kind of metal panel business idea, allow me to be clear: the Rust I am referring to is a programming language.
18. Top 5 Concurrency Interview Questions for Software Engineers
(Some background: I’ve interviewed hundreds of candidates for software engineering jobs at Facebook and Microsoft. I’ve also failed several coding interviews myself when I wasn’t prepared.)
19. Interview with Anderson Queiroz: Golang is The Perfect Language for the 21st Century
Introduction
20. Rethinking Programming: Making Sequence Diagrams Cool Again
Introduction
21. Understanding Concurrency Patterns in Go
Explore Go’s concurrency patterns, including worker pools, fan-out/fan-in, and pipelines, to build efficient, robust, and scalable applications.
22. Inside BEAM: How Elixir and Erlang Leverage a Shared Runtime for Resilient Applications
Explore the origins and guiding principles behind Erlang and Elixir to understand their full potential and innovation.
23. A Guide to Improving Your Python Performance Speed
This guide aims to summarize popular methods for boosting the execution speed of your Python code.
24. Building AxonerAI: A Rust Framework for Agentic Systems
AxonerAI: Rust framework for building AI agents. Alternative to LangChain with memory safety, true concurrency and blazing fast executions.
25. Understanding Synchronized Collections in Java
Learn about Java's synchronized collections that helps you achieve thread-safety in the most easiest way!
26. JavaScript Concurrency Models: The Event Loop
JavaScript has a concurrency model based on an event loop, which is responsible for executing the code, collecting and processing events, and executing queued sub-tasks.
27. Here's How I Scaled A Cryptocurrency Exchange's Trading Engine to 1 Million TPS
Crypto exchange has been in great demand with the adaptability of cryptocurrencies surging and multiple new tokens/coins been put there attracting users by showcasing their great potential.
28. Is Kafka the Key? The Evolution of Highlight's Ingest
Building a distributed message processing queue using Apache Kafka requires some thought. We walk through how we process thousands of large messages per second.
29. Inteview with Frank Müller: One Decade of Go - the Power of Concurrency
Frank Müller, Solution Engineer at Loodse, is one of the co-organizers of the GoDays conference in Berlin, which took place in January of 2020. It has been an exciting moment when Google announced its Language Go in 2009. After some hype and early years of establishing the language, it was settled as a robust and scalable fundament for networked systems. We invite you to enjoy a travel through a decade of our beloved Go within the interview of Grigory Petrov, Dev Rel at Evrone.com with Frank Müller.
30. Solving Producer/Consumer Problem of Concurrent Programming in Python
In "Concurrent Programming in Python is not what you think it is", I wrote about the notorious GIL in Python and did a simple experiment on existing concurrency mechanism in Python. Today, I'll describe another common scenario in concurrent programming, the Producer/Consumer problem, with Python.
31. The Essential Guide to Relearning Java Thread Primitives
Synchronized was revolutionary and still has great uses. But it's time to move to newer thread primitives and potentially, rethink our core logic.
32. The Truth About “Cancelling” Async/Await: You’re Mostly Just Ignoring Results
JavaScript can’t truly cancel async/await work—most “cancellation” just stops waiting.
33. Go Concurrency: Goroutines, Mutexes, WaitGroups & Condition Variables
Comprehensive guide to Go concurrency: goroutines, mutexes, WaitGroups, and condition variables with examples, best practices, and gotchas.
34. Using Java Executor framework for Multithreading [A How To Guide]
35. Building a Simple REST API in Go Without Frameworks
Learn how to build a RESTful API in Go from scratch using only the net/http package, in-memory data, and mutex for concurrency.
36. Understanding Concurrency in Golang with Goroutines: Latest Update in Version 1.23
Explore the power of Goroutines in Golang for concurrency management, including new enhancements in Golang 1.23 that optimize performance and memory usage.
37. How Coroutines Enable Cooperative Multitasking and Concurrency
In this story I explain how concurrency works in Kotlin coroutines with an example to prove how it works. Concurrency in coroutines is cooperative.
38. Tips For A Successful Concurrent Requests With Async/Await And Promise.all
Let's talk about concurrency, async/await, promise.all, and lightning web components
39. How Goroutines Behave on CPU-Bound vs I/O-Bound Tasks
Goroutines can supercharge Go apps—or slow them down. Learn when they help, when they hurt, and how to benchmark your workloads.
40. What Every Gopher Should Know About the Go Memory Model
Learn how Go's memory model defines visibility between goroutines using happens-before rules and synchronization primitives like channels and mutexes.
41. The Myth of Single-Threaded JavaScript: Inside the Language’s Hidden Concurrency Engine
Explore the concurrency model of modern JavaScript, including the event loop, async/await, and more.
42. Safeguarding Concurrent Programs in Java: Thread Safety from an Object Oriented Perspective
A program that maintain its correctness in a multi-threaded environment is said to be a Thread-Safe program.
43. A Guide on How to Eliminate Thread Explosions in iOS: GCD and Swift Concurrency
Learn about thread explosion, how to manage it, and how modern Swift Concurrency addresses the issue.
44. A Simplified Comparison: Rust and Pointers
Understand Rust's unique memory management system by comparing it to C/C++ pointers. Discover ownership, borrowing, references, and smart pointers.
45. Best Practices for Object Sharing in Multi-threaded Systems
Your standard object sharing practices might totally fail in a multi-threaded environment. Learn about the ways to properly share objects across threads!
46. Mastering Object Visibility in Java
Sharing variables across threads isn't as easy as it sounds. There are a number of interesting cases that might blow your mind when it comes to variable sharing
47. Here's What You Need to Know Before Using Event Sourcing
This article is useful for those interested in the concept of Event Sourcing and who want to decide if it's a good fit for their projects while avoiding common
48. Go Concurrency Face-Off: Channels vs Mutexes
Demystify when to use channels and when to use mutexes, and why blindly following "Go concurrency patterns" can backfire.
49. Swift Concurrency Explained: Actors, Executors, and Reentrancy
Explore Structured Concurrency in Swift: Actors, @MainActor, @GlobalActor, understanding the Swift Concurrency runtime, and actor reentrancy.
50. Guide to Concurrency in React 18: How and Why
Guide to concurrency, CPU- and IO-bound components, and other interesting stuff. Finally, learn wtf deferred value is.
51. Synchronization Challenges in Multithreading
This is the sixth part of a series on Parallel Programming for Beginners. In this article, we’ll explore real-world scenarios and their solutions.
52. Streamlining Go Concurrency Using a Worker Pool
Before you start spawning thousands of goroutines, let's take a step back and understand how to do this efficiently.
53. Why Parallelism Isn't Always Concurrency (and Vice Versa)?
An in-depth exploration of concurrency and parallelism in Go, covering key concepts.
54. Well-Known Concurrency Problems and How Go Handles Them
Explore classic concurrency problems in Go. Including producer-consumer, dining philosophers, and rate limiting with simple code examples and clear explanation.
55. Efficient Concurrency in Serverless Architectures with Go and AWS
Goroutines let you run multiple operations in parallel within one request.
56. Swift Concurrency: Part 2 — Parent/child Relationship, Automatic Cancellation, Task Groups
Explore Structured Concurrency in Swift: parent/child relationship, automatic cancellation, task groups, and more.
57. Project Loom Revolution - and How Not to Break Production in the Process
A practical deep-dive into Project Loom, explaining how virtual threads and structured concurrency simplify Java’s concurrency model and enable high-throughput.
58. 3 Beginner Tips You Need to Know for async await in C#
Learn essential tips for using async await in C# to write concurrent code more effectively.
59. Inside Go Channels: Buffers, Locks, and the Runtime Memory Model
Go channels look simple, but under the hood they use buffers, queues, and scheduler tricks. Explore hchan, sudog, and Go’s concurrency model.
60. Why Would Anyone Call a Race Condition Nice?
Every heard of a nice race condition?
61. Singleton Beans and Debugging Nightmares 😲
A Spring bean. Sounds relatively harmless, doesn't it? What if I told you that this could be the source of many headaches in web servers, especially if you are
62. How to Build a High-Performance Concurrent Leaderboard in Go
Build a scalable, concurrent leaderboard in Go using sharding, heaps, and RWMutex to handle live updates and efficient Top-N queries.
Thank you for checking out the 62 most read blog posts about Concurrency on HackerNoon.
Visit the /Learn Repo to find the most read blog posts about any technology.