In the previous four articles in my Unintuitive Multithreading series, I focused mostly on design of a multi-threaded application. This time, I plan to cover a few techniques that I have found helpful in troubleshooting multi-threaded applications. To some extent, the normal techniques you have used for troubleshooting will work in a multi-threaded program. But,… Read More »
Continuing my exploration of misunderstandings about multi-threading, this essay is about simplicity. If you are interested in the previous essays in this series, they can be found on the series page. This time I plan to start with an assertion that almost everyone will agree with and push it more than most people would. The… Read More »
This essay continues my exploration of misunderstandings about multi-threading. In the first essay of this series, Unintuitive Multithreading: Speed, I explained that multi-threading does not inherently speed up a process. In the second essay Unintuitive Multithreading: Waiting for Performance, I showed how to achieve better performance through waiting. In this essay, I plan to attack… Read More »
This essay continues my exploration of misunderstandings about multi-threading. In the first essay of this series, Unintuitive Multithreading: Speed, I explained that multi-threading does not inherently speed up a process. In this essay, I plan to show how to not achieve more performance from a multi-threaded system. Many new multi-threading (MT) developers make the same… Read More »
This begins a short series of essays on what most programmers get wrong about multi-threading. Over and over again, I’ve seen programmers make the same mistakes in multi-threaded applications on multiple operating systems and in multiple languages. So I decided to give you the benefits of what little insight I have into the problem. The… Read More »
This is a very simple concept that seems to escape many people. In fact, most of the multi-threaded code I’ve seen shows a distinct misunderstanding of this basic fact. Very often people seem to think that a mutex should protect a section of code. I think this misconception may have been caused by the term… Read More »
Java Cookbook Ian F. Darwin O’Reilly, 2001 In spite of the fact that it is supposedly written in the style of the Perl Cookbook, this book was a real disappointment. The cookbook format is intended for showing solutions to common problems. However, the author of this book appeared to be trying to force a tutorial… Read More »
There is a subtle aspect of threads that may be worth exploring having to do with the concept of joining. Many threading systems support the possibility of waiting until a thread completes in order to retrieve its exit state. This is often started through a function called join(). In order to support this feature, a… Read More »
Any system that uses the worker pattern may also want a dispatcher thread that wakes up workers and sends them on their way. In this approach, the dispatcher thread handles setting up the data needed to finish the task. The dispatcher may either choose a worker from a pool of suspended threads or create a… Read More »
Possibility of thinking of multi-threading design patterns as a way to organize threading code. Some possible patterns include: Fire and Forget (background thread) Periodic (Timer) IO thread Producer/Consumer Worker thread (work queue) Copier thread Pipeline (must be careful) Swarm? The background thread could be joined at a later time or a thread that runs it’s… Read More »