concurrency.md

concurrency

Let's learn about Concurrency via these 62 free blog posts. They are ordered by HackerNoon reader engagement data. Visit the /Learn 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

The React JS dev team announced some exciting changes several months ago - React would be getting a "Concurrent Mode". Essentially this would allow React to perform multiple UI renders concurrently. Of course, JavaScript is single threaded and true concurrency is an illusion, but the new features will allow web apps (and Native Apps once these features hit React Native) to be much more responsive and snappy than they are now with less effort and custom code from the developer to make this happen.

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]

In my Previous Blog I covered the basics of Multithreading in Java. Click here to read that blog.

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.