Merge branch 'main' of https://github.com/Ashfaqbs/Concurrency-Multithreading-and-Parallel-Computing-in-Java

Author: Ashfaqbs

CheatSheet.md

@@ -0,0 +1,181 @@
+# Cheat Sheet
+## Concurrent Data Structures
+
+### 1. ConcurrentHashMap
+- **Usage**: A thread-safe variant of `HashMap`.
+- **Example**:
+  ```
+  ConcurrentMap<String, Integer> map = new ConcurrentHashMap<>();
+  map.put("key", 1);
+  int value = map.get("key");
+  
+### 2. CopyOnWriteArrayList
+- **Usage**:  A thread-safe variant of ArrayList for read-mostly scenarios.
+- **Example**:
+```
+List<String> list = new CopyOnWriteArrayList<>();
+list.add("element");
+for (String s : list) {
+    System.out.println(s);
+}
+```
+
+### 3. BlockingQueue
+- **Usage**:  Thread-safe queues that block on operations when necessary.
+
+Types:
+ArrayBlockingQueue
+LinkedBlockingQueue
+PriorityBlockingQueue
+- **Example**:
+```
+BlockingQueue<String> queue = new ArrayBlockingQueue<>(10);
+queue.put("element");
+String element = queue.take();
+```
+
+### 4. ConcurrentSkipListMap
+Usage: A thread-safe variant of TreeMap for scalable sorted maps.
+- **Example**:
+
+```
+ConcurrentNavigableMap<String, Integer> map = new ConcurrentSkipListMap<>();
+map.put("key", 1);
+int value = map.get("key");
+```
+
+###  5. DelayQueue
+Usage: A thread-safe queue that holds elements until a delay has expired.
+- **Example**:
+```
+DelayQueue<DelayedElement> queue = new DelayQueue<>();
+queue.put(new DelayedElement());
+DelayedElement element = queue.take();
+```
+
+## Using ExecutorService
+
+Creating an ExecutorService
+```
+Fixed Thread Pool:
+
+ExecutorService executor = Executors.newFixedThreadPool(5);
+
+Single Thread Executor:
+
+ExecutorService executor = Executors.newSingleThreadExecutor();
+
+Cached Thread Pool:
+
+ExecutorService executor = Executors.newCachedThreadPool();
+
+Scheduled Thread Pool:
+
+ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
+```
+
+Submitting Tasks
+
+```
+Runnable Task:
+
+executor.submit(() -> {
+    System.out.println("Task executed");
+});
+
+Callable Task:
+
+Future<String> future = executor.submit(() -> {
+    return "Task result";
+});
+```
+
+Shutting Down ExecutorService
+Shutdown gracefully:
+
+```
+executor.shutdown();
+if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
+    executor.shutdownNow();
+}
+
+Force shutdown:
+
+
+executor.shutdownNow();
+
+```
+
+## Good Practices
+
+1. Use Appropriate Data Structures
+Choose thread-safe data structures from the java.util.concurrent package.
+Example: Use ConcurrentHashMap instead of HashMap.
+
+3. Minimize Locking
+Prefer using higher-level concurrency utilities like Semaphore, CountDownLatch, CyclicBarrier over explicit locks.
+Example:
+```
+Semaphore semaphore = new Semaphore(1);
+semaphore.acquire();
+try {
+    // critical section
+} finally {
+    semaphore.release();
+}
+```
+
+3. Use Executors for Thread Management
+Avoid manual thread creation; use ExecutorService for better management.
+Example:
+```
+ExecutorService executor = Executors.newFixedThreadPool(5);
+executor.submit(() -> {
+    // task
+});
+executor.shutdown();
+```
+
+4. Handle Exceptions in Tasks
+Ensure that tasks submitted to an executor service handle exceptions properly.
+Example:
+```
+executor.submit(() -> {
+    try {
+        // task
+    } catch (Exception e) {
+        e.printStackTrace();
+    }
+});
+```
+
+5. Properly Shutdown ExecutorService
+Always shutdown ExecutorService to release resources.
+Example:
+```
+executor.shutdown();
+try {
+    if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
+        executor.shutdownNow();
+    }
+} catch (InterruptedException e) {
+    executor.shutdownNow();
+}
+```
+6. Avoid Blocking Operations in Tasks
+Avoid long-running or blocking operations inside tasks to keep the thread pool responsive.
+Example:
+
+```
+executor.submit(() -> {
+    // Avoid blocking calls like Thread.sleep() or I/O operations
+});
+```
+
+7. Use Thread-Safe Collections
+Use collections from java.util.concurrent for thread safety.
+Example:
+```
+ConcurrentMap<String, Integer> map = new ConcurrentHashMap<>();
+```
+

README.md

@@ -1,2 +1,104 @@
 # Concurrency-Multithreading-and-Parallel-Computing-in-Java
-Concurrency, Multithreading and Parallel Computing in Java
+
+# Understanding Multithreading and Parallelism
+
+## Types of Memory
+
+### Registers
+- **Location**: Inside the CPU.
+- **Speed**: Fastest type of memory.
+- **Purpose**: Holds data that the CPU is currently processing.
+- **Example**: Program counter, instruction register, accumulator.
+
+### Cache Memory
+- **Levels**: L1, L2, and sometimes L3.
+- **Location**: Closer to the CPU than main memory (RAM).
+- **Speed**: Faster than RAM but slower than registers.
+- **Purpose**: Stores frequently accessed data to speed up processing.
+- **Example**: Instructions and data that are likely to be reused by the CPU.
+
+### Main Memory (RAM)
+- **Location**: External to the CPU.
+- **Speed**: Slower than cache and registers.
+- **Purpose**: Stores data and instructions that the CPU needs while running programs.
+- **Example**: The currently running applications and their data.
+
+### Secondary Storage
+- **Types**: Hard drives (HDD), solid-state drives (SSD).
+- **Speed**: Much slower than RAM.
+- **Purpose**: Persistent storage for data and programs.
+- **Example**: Operating system, applications, and files.
+
+## CPU Architecture
+
+### Cores
+- Modern CPUs have multiple cores, each capable of executing its own thread.
+- Each core has its own set of registers and often its own L1 cache.
+
+### Hyper-Threading (Simultaneous Multithreading)
+- Allows each core to execute multiple threads.
+- Improves utilization of CPU resources by switching between threads.
+
+### Instruction Pipeline
+- **Stages**: Fetch, decode, execute, memory access, write-back.
+- Allows the CPU to work on multiple instructions simultaneously, increasing throughput.
+
+### Control Unit (CU)
+- Directs the operation of the processor.
+- Fetches instructions from memory and decodes them.
+
+### Arithmetic Logic Unit (ALU)
+- Performs arithmetic and logical operations.
+
+### Cache Hierarchy
+- **L1 Cache**: Smallest and fastest, specific to each core.
+- **L2 Cache**: Larger than L1, may be shared between cores.
+- **L3 Cache**: Even larger, often shared among all cores in a CPU.
+
+## Multithreading and Parallelism
+
+### Concurrency
+- Multiple threads make progress by sharing CPU time.
+- Useful for I/O-bound tasks where threads can be paused while waiting for I/O operations to complete.
+
+### Parallelism
+- Multiple threads run simultaneously on different cores.
+- Useful for CPU-bound tasks that can be divided into independent subtasks.
+
+## Memory and Threading
+
+### Shared Memory
+- Threads within the same process share the same memory space.
+- **Benefits**: Efficient communication between threads.
+- **Challenges**: Requires synchronization to avoid race conditions.
+
+### Synchronization Mechanisms
+- **Mutexes**: Ensure that only one thread can access a resource at a time.
+- **Semaphores**: Control access to a resource that can handle a fixed number of concurrent accesses.
+- **Monitors**: A combination of mutex and condition variables for thread synchronization.
+- **Atomic Variables**: Ensure thread-safe operations on shared data without needing explicit locks.
+
+### Thread Local Storage
+- Each thread has its own local storage, preventing interference between threads.
+
+## Important Considerations
+
+### Race Conditions
+- Occur when two threads access shared data simultaneously and at least one access is a write.
+- **Solution**: Use synchronization mechanisms to control access to shared data.
+
+### Deadlock
+- Occurs when two or more threads are waiting indefinitely for resources held by each other.
+- **Solution**: Avoid circular wait conditions, use timeout mechanisms.
+
+### Livelock
+- Occurs when threads continuously change their state in response to each other but no progress is made.
+- **Solution**: Implement proper coordination and avoid excessive retries.
+
+### Thread Safety
+- Ensuring that shared data is accessed in a thread-safe manner.
+- Use thread-safe collections (e.g., `ConcurrentHashMap`), synchronization mechanisms, and atomic variables.
+
+## Note : 
+Understanding the types of memory and how a CPU works helps in designing efficient multithreaded applications. It involves recognizing the importance of CPU cores, cache hierarchy, and synchronization mechanisms to manage concurrent access to shared resources. Properly handling synchronization can prevent issues like race conditions, deadlocks, and livelocks, ensuring efficient and correct execution of multithreaded programs.
+