Threads and Processes

Threads: The smallest unit of execution within a process. They share the same memory space and resources of the process they belong to.
Processes: Independent units that run in their own memory space. Each process can have multiple threads.

Java:
- Uses the java.lang.Thread class.
- Create a thread by extending the Thread class or implementing the Runnable interface.
- Start a thread using the start() method.
Python:
- Uses the threading module.
- Create a thread by subclassing Thread and overriding the run() method.
- Start a thread using the start() method.
Go:
- Uses goroutines.
- Start a goroutine using the go keyword followed by a function call.
Rust:
- Uses the std::thread module.
- Create a thread using thread::spawn().
- Join threads using the join() method.

Java: Uses the java.lang.ProcessBuilder class to create and manage processes.
Python: Uses the subprocess module to spawn and interact with processes.
Go: Uses the os/exec package for process management.
Rust: Uses the std::process module to spawn and manage processes.

Race Conditions: Occur when multiple threads access shared data and try to change it simultaneously.
Deadlocks: Occur when two or more threads are waiting for each other to release resources, leading to a standstill.
Starvation: Occurs when a thread is perpetually denied necessary resources.
Thread interference: Occurs when multiple threads interfere with each other while sharing data.

Locks: Use synchronization mechanisms like mutexes or semaphores to ensure only one thread accesses a resource at a time.
Immutable Data: Use immutable data structures to prevent modification by multiple threads.
Thread-local Storage: Use thread-local storage to ensure data is not shared between threads.
Avoid Global Variables: Global variables can lead to race conditions.
Test with Multiple Threads: Always test multithreaded code with multiple threads to uncover potential issues.