Update Things-To-Know.md

Author: Ashfaqbs

Things-To-Know.md

@@ -1 +1,179 @@
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+# Internal Working
 
+## When we call the start() method on a thread, the JVM schedules the thread for execution on a logical processor, which can be a physical core or a hyper-threaded logical core in our CPU.
+
+## CPU Structure
+### Physical Cores:
+
+These are the actual hardware components in the CPU that perform computation.
+Each physical core can execute one thread at a time.
+
+### Logical Processors:
+
+Modern CPUs often use a technology called Hyper-Threading (by Intel) or Simultaneous Multithreading (SMT) (by AMD).
+This technology allows each physical core to be split into multiple logical processors.
+Each logical processor can handle its own thread, giving the appearance of more cores to the operating system and applications.
+
+
+## Example
+### 4-core CPU with Hyper-Threading:
+
+A CPU with 4 physical cores might support Hyper-Threading, providing 8 logical processors.
+This means the CPU can handle 8 threads simultaneously.
+Execution Flow
+
+Thread Start:
+
+You call start() on a thread, notifying the JVM that the thread is ready to run.
+JVM Scheduler:
+
+The JVM's thread scheduler decides when and on which logical processor the thread will run.
+Core Execution:
+
+The thread is executed on one of the logical processors.
+The logical processor could be a physical core or a hyper-threaded logical core.
+
+```
+
+
+class MyRunnable implements Runnable {
+    @Override
+    public void run() {
+        System.out.println("Thread is running on: " + Thread.currentThread().getName());
+    }
+}
+
+public class Main {
+    public static void main(String[] args) {
+        Thread thread1 = new Thread(new MyRunnable());
+        Thread thread2 = new Thread(new MyRunnable());
+        thread1.start();
+        thread2.start();
+    }
+}
+
+```
+### What Happens Internally
+Thread Initialization: new Thread(new MyRunnable()) creates a new thread object.
+Thread Scheduling: thread1.start() and thread2.start() notify the JVM scheduler.
+Core Execution: The JVM maps thread1 and thread2 to available logical processors for execution.
+Run Method: The cores (or logical processors) execute the run() method of MyRunnable.
+
+### Summary
+Physical Cores: Actual hardware units that perform computation.
+Logical Processors: Virtual cores created by technologies like Hyper-Threading, allowing multiple threads per physical core.
+When you call start(), the JVM schedules the thread to run on a logical processor.
+The logical processor could be a physical core or a hyper-threaded core.
+
+In modern CPUs, this allows better utilization of CPU resources and can improve performance by allowing more threads to run concurrently.
+
+
+
+
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+# Key Components of a CPU
+## Cores:
+
+1. Physical Cores: These are the actual hardware units that perform computation. They execute instructions from the computer’s programs.
+2. Logical Processors: Created by technologies like Hyper-Threading (Intel) or Simultaneous Multithreading (SMT) (AMD). Each physical core can be divided into multiple logical processors, allowing more threads to be handled simultaneously.
+
+## Cache Memory:
+
+L1 Cache: The smallest and fastest cache, located directly on the CPU core. It stores frequently accessed data and instructions.
+L2 Cache: Larger than L1, but slower. It also stores frequently accessed data and can serve multiple cores.
+L3 Cache: The largest and slowest cache, shared across all cores in a CPU. It helps reduce the latency for memory accesses.
+
+## Arithmetic Logic Unit (ALU):
+
+The ALU performs arithmetic and logical operations (such as addition, subtraction, and comparisons).
+## Floating Point Unit (FPU):
+
+The FPU handles complex mathematical calculations, particularly those involving floating-point numbers.
+## Control Unit (CU):
+
+The CU directs the operation of the processor. It tells the ALU, memory, and I/O devices how to respond to the instructions received from the program.
+## Registers:
+
+Small, fast storage locations within the CPU used to hold data that is being processed or used immediately. Examples include the instruction register, accumulator, and program counter.
+## Bus Interface Unit (BIU):
+
+The BIU manages the data transfer between the CPU and the system’s memory or input/output devices. It includes address buses, data buses, and control buses.
+## Instruction Decoder:
+
+This component interprets the instructions fetched into the CPU, determining which operations the ALU and other components should perform.
+## Clock:
+
+The clock synchronizes the operations of the CPU by generating a continuous sequence of electrical pulses. The frequency of these pulses (measured in GHz) determines the speed at which the CPU can process instructions.
+## Memory Management Unit (MMU):
+
+The MMU handles the translation of virtual memory addresses to physical addresses. It manages the memory hierarchy and paging mechanisms.
+## Additional CPU Features
+## Integrated Graphics Processing Unit (GPU): Some CPUs come with an integrated GPU to handle graphics processing tasks.
+## Thermal Management: Modern CPUs include mechanisms for managing heat, such as thermal sensors and throttling capabilities.
+## Security Features: CPUs often include hardware-based security features like Intel’s SGX (Software Guard Extensions) or AMD’s SEV (Secure Encrypted Virtualization).
+## Summary
+The CPU is a complex and highly integrated component comprising physical cores, logical processors, cache memory, the ALU, FPU, control unit, registers, BIU, instruction decoder, clock, and MMU. These components work together to execute instructions and process data efficiently. Understanding these parts helps appreciate how a CPU handles multiple tasks, such as those in multithreading and parallel processing.
+
+
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+
+
+When we call the start() method on a Thread in Java, the CPU and its components play specific roles to handle the execution of the thread. Here’s a step-by-step breakdown of what happens and how the CPU components are involved:
+
+1. Calling start() Method
+When we call the start() method on a thread, the following happens:
+
+A new thread is created in the JVM.
+The thread is registered with the operating system.
+The run() method of the thread is scheduled to be executed by the JVM.
+2. Operating System Scheduler
+The operating system’s scheduler is responsible for managing which threads run on which cores or logical processors. It schedules the threads based on their priority and the current workload of the system.
+
+3. Thread Allocation to CPU Core
+The operating system assigns the thread to an available logical processor (which could be one of the multiple threads on a physical core).
+
+4. CPU Core Execution
+Once assigned to a core or logical processor, the following CPU components are involved in executing the thread:
+
+a. Instruction Fetch and Decode
+Instruction Decoder: The CPU fetches instructions from the memory (via the instruction register) and decodes them to understand what actions to perform.
+Control Unit (CU): Directs the execution of these instructions, telling the ALU, FPU, and other components what to do.
+b. Execution
+Arithmetic Logic Unit (ALU): Performs arithmetic and logical operations as required by the thread.
+Floating Point Unit (FPU): Handles complex mathematical calculations if needed by the thread.
+c. Memory Access
+Cache Memory (L1, L2, L3): The CPU uses its cache to quickly access frequently used data and instructions.
+Memory Management Unit (MMU): Translates virtual addresses to physical addresses, ensuring the correct data is accessed from the main memory.
+d. Data Transfer
+Registers: Temporary storage within the CPU where data and instructions currently being used are held.
+Bus Interface Unit (BIU): Manages the data transfer between the CPU and the system’s memory or I/O devices.
+
+5. Multithreading and Parallel Execution
+If the CPU has multiple cores and supports multithreading, several threads can run in parallel. Here’s how:
+
+Physical Cores: Each physical core can handle one or more threads at the same time.
+Logical Processors: Technologies like Hyper-Threading allow a single physical core to handle multiple threads concurrently by providing additional logical processors.
+6. Context Switching
+If the CPU is running multiple threads on the same core (logical or physical), it will perform context switching:
+
+Save State: The current state of a thread is saved (registers, program counter, etc.).
+Load State: The state of the next thread to run is loaded.
+Execution Resumes: The new thread resumes execution.
+7. Completion and Shutdown
+Once a thread completes its execution:
+
+The CPU stops executing its instructions.
+The operating system scheduler may assign the logical processor to another thread.
+If the thread pool or executor service is being used, the thread is returned to the pool for reuse.
+
+
+Summary
+Instruction Fetch and Decode: Fetch and decode instructions from the thread.
+Execution: Perform arithmetic, logical, and floating-point operations.
+Memory Access: Use caches and MMU for fast and correct memory access.
+Data Transfer: Manage data transfers via registers and buses.
+Multithreading: Execute multiple threads in parallel using cores and logical processors.
+Context Switching: Save and load thread states to handle multiple threads on a single core.
+Completion: Threads complete, and resources are freed or reused