登录查看更多内容

What are common concurrency anti-patterns in programming languages?

由人工智能和领英社区提供技术支持

Concurrency is the ability of a program to execute multiple tasks simultaneously, which can improve performance, responsiveness, and scalability. However, concurrency also introduces new challenges and pitfalls that can lead to bugs, errors, and inefficiencies. In this article, we will explore some of the common concurrency anti-patterns in programming languages, and how to avoid or fix them.

此文章中的业界达人

由社区从 5 条内容中精选。了解更多

Mehul Sachdeva

Lead SDE @ Bank of New York | CSE, BITS Pilani | MITACS GRI 2022 | Apache Iceberg, Contributor | Dremio | Samsung…
Bhavana P

Detail-Oriented Data Analyst | 5 ? SQL Hackerrank| 5 ? Python Hackerrank | Statistical Insights
Teguh Sutanto

1 Blocking calls

One of the most common concurrency anti-patterns is blocking calls, which are operations that prevent the current thread from executing until they complete. Blocking calls can cause delays, deadlocks, and wasted resources, especially if they involve network or disk access, user input, or synchronization. To avoid blocking calls, you should use asynchronous or non-blocking alternatives, such as callbacks, promises, futures, or coroutines, that allow the thread to continue working while waiting for the result.

添加您的观点

Bhavana P

Detail-Oriented Data Analyst | 5 ? SQL Hackerrank| 5 ? Python Hackerrank | Statistical Insights
举报内容
Blocking calls hinder system efficiency and responsiveness in concurrent programming. They halt thread execution, causing deadlocks and wasted processing time, especially with I/O operations. To counter this, favor non-blocking alternatives like asynchronous programming and callbacks. These methods enable threads to remain active while awaiting results, enhancing scalability and responsiveness. Employing event-driven architecture and optimizing concurrency control further mitigates the impact of blocking calls, crafting more efficient concurrent systems.

已翻译

赞

2 Shared mutable state

Another concurrency anti-pattern is shared mutable state, which is when multiple threads access and modify the same data without proper coordination. Shared mutable state can lead to race conditions, data corruption, and inconsistent behavior, as different threads may overwrite or interfere with each other's changes. To avoid shared mutable state, you should use immutable data structures, thread-local storage, or synchronization mechanisms, such as locks, semaphores, or atomic operations, that ensure only one thread can access or modify the data at a time.

添加您的观点

3 False sharing

False sharing is a concurrency anti-pattern that occurs when multiple threads access different data that are located on the same cache line, which is a unit of memory that the processor fetches and updates in bulk. False sharing can degrade performance, as each thread invalidates the cache line of the other threads, forcing them to reload the data from memory. To avoid false sharing, you should align or pad the data structures, or use cache line size annotations, that ensure each thread accesses a separate cache line.

添加您的观点

Bartosz P.

Staff Software Engineer
举报内容
False sharing is something that most engineers will never see in their careers, or at least it will be insignificant to the problem. However, this can occur when the data is linearly aligned and split between threads. This is a clear false sharing. To avoid this issue simply copy the part of the processed data to thread local storage, do the computation, and put the data back to the shared storage. There will be a refresh at the end of the computation, but writing to a common memory space will no longer happen, mitigating the false sharing.

已翻译

赞

4 Nested parallelism

Nested parallelism is a concurrency anti-pattern that occurs when a parallel task spawns another parallel task, creating a hierarchy of parallelism. Nested parallelism can cause overhead, contention, and imbalance, as the nested tasks may compete for the same resources, create more threads than necessary, or distribute the work unevenly. To avoid nested parallelism, you should use flat parallelism, which is when a parallel task does not spawn another parallel task, or limit the depth or granularity of the nested tasks.

添加您的观点

5 Busy waiting

Busy waiting is a concurrency anti-pattern that occurs when a thread repeatedly checks a condition or a flag, without yielding or sleeping, until it becomes true. Busy waiting can waste CPU cycles, power, and battery life, as the thread consumes resources without doing any useful work. To avoid busy waiting, you should use event-driven or blocking mechanisms, such as signals, notifications, or condition variables, that allow the thread to wait for the condition or the flag to change without polling.

添加您的观点

Mehul Sachdeva

Lead SDE @ Bank of New York | CSE, BITS Pilani | MITACS GRI 2022 | Apache Iceberg, Contributor | Dremio | Samsung Electronics
举报内容
In a prior project, we faced challenges using busy waiting to check resource availability, causing excessive CPU usage and impacting system performance. Transitioning to an event-driven approach with semaphores improved responsiveness and resource utilization. The lesson learned emphasized avoiding busy waiting for optimized performance and efficient resource allocation, showcasing the significance of event-driven mechanisms.

已翻译

赞

6 Premature optimization

Premature optimization is a concurrency anti-pattern that occurs when a programmer tries to improve the performance of a program before measuring and identifying the actual bottlenecks. Premature optimization can introduce complexity, bugs, and maintenance costs, as the programmer may use unnecessary or inappropriate concurrency techniques, such as parallel loops, threads, or locks, that may not improve or even worsen the performance. To avoid premature optimization, you should follow the principle of "measure, don't guess", which means that you should use profiling tools, benchmarks, and metrics, to analyze the performance of your program, and apply concurrency techniques only when and where they are needed and effective.

添加您的观点

7 Here’s what else to consider

This is a space to share examples, stories, or insights that don’t fit into any of the previous sections. What else would you like to add?

添加您的观点

Teguh Sutanto
举报内容
Livelocks, a subtle challenge in concurrent programming, occur when threads, in a well-intentioned loop, make no progress. Picture two threads politely deferring to each other endlessly, akin to dancers stuck in an eternal bow. The solution lies in introducing unpredictability—a touch of chaos—to disrupt the cycle and break free from unproductive patterns.

已翻译

赞
Bartosz P.

Staff Software Engineer
举报内容
Languages that are used for high-performance computation usually have good standard libraries that provide a lot of building blocks for more complex algorithms. Moreover, those are written by language and subject expect. So unless you know what you are doing, or have very specific needs, build on the shoulders of the giants.

已翻译

赞

Computer Science

+ 关注

给文章评分

我们借助人工智能创建了此文章。您认为这篇文章怎么样？

很棒不太好

举报此文章

查看全部

What are common concurrency anti-patterns in programming languages?

1

2

3

4

5

6

7

1 Blocking calls

2 Shared mutable state

3 False sharing

4 Nested parallelism

5 Busy waiting

6 Premature optimization

7 Here’s what else to consider

Computer Science

给文章评分

感谢您的反馈

更多Computer Science相关文章

更多相关阅读内容

What are common concurrency anti-patterns in programming languages?

1

2

3

4

5

6

7

1 Blocking calls

2 Shared mutable state

3 False sharing

4 Nested parallelism

5 Busy waiting

6 Premature optimization

7 Here’s what else to consider

Computer Science

给文章评分

感谢您的反馈

查看其他技能