Multithreading is a crucial concept in computer science that allows for the concurrent execution of two or more threads, enabling more efficient and optimized use of resources. It can significantly improve the performance of applications, particularl...

freeCodeCamp is a nonprofit organization offering free online coding courses and programming tutorials, covering topics such as web development, data science, and machine learning. Learners can gain practical coding skills, build real-world projects, and earn certifications to advance their careers in tech.

freeCodeCamp

Multithreading allows concurrent execution of threads for optimized resource use and improved application performance. It is crucial for handling multiple tasks simultaneously and is extensively used in Java. A comprehensive course on the freeCodeCamp.org YouTube channel covers multithreading basics to advanced topics, including thread creation, synchronization, inter-thread communication, and advanced frameworks like ExecutorService and ForkJoinPool. The course aims to enhance programming skills and opens up numerous career opportunities.

Multithreading for Beginners

<ol start="4">
<li>NEVER assume that the code you write is thread-safe. You need to stress test it with thousands of threads. You do not know how the assembler code is generated, where the thread will jump in.
I learned this way when my thread crashed on an int assignment (Delphi). “int temp = 12545” seems like an atomic operation, the CPU will not jump to another thread, but it did in the middle of the Delphi instruction. Only when you looked at the assembler code did you realize that the compiler made it into 2 assembler instructions. And the thread jumped after the first assembler instruction.</li>
</ol>

5 hours is too long for me to go through, but I will give some hints I learned from working with enormous numbers of threads.
<ol>
<li>I mark each method like this {rwRW} {r-r-}{rw–}.
r/R = read safe
w/W = write safe
rw = read/write safe during initialization phase
RW = read/write safe in full run mode.</li>
</ol>
Most of the time you will probably use {rwRW} or {–RW}.
When no threads are running (initialization phase), you can set global variables and no locking is required. Once they are running, they are only read, never written, so locking is not required.

<ol start="2">
<li>(I don’t know in Jave but in C) Create your data so that it fits into a struct, you just have to memcopy that struct (fast and never gets an error), and that’s the only time you need to lock a part. When you work on that copied structure, you don’t need to lock any properties anymore. All data stays in sync, no property in this struct will be changed by any other thread.</li>
</ol>

<ol start="3">
<li>People always claim that lock() is always slow. I have heard this claim for decades, but it is not true. It is ONLY slow when there is a collision, but it takes micro/nanoseconds to lock() when there is no collision.</li>
</ol>
The key here is to make the lock as short as possible. This is why I refer to using memcopy to copy a struct with your data in it and lock only during the memcopy. We are talking about microseconds here.
You lose a bit of memory because you allocate more local memory for your thread to work on. But you don’t lose any speed because the chance of getting into a collision is very small.