feat: Add ThreadsMethods demo showing thread metadata, sleep, and lifecycle checks

WHAT the code does:
- Adds `MyThread` (extends `Thread`) that:
  - Accepts a thread name via `super(name)`.
  - Sleeps 1 second at start of `run()` then enters an infinite counter loop printing increasing numbers.
- Adds `ThreadsMethods` main class that:
  - Instantiates a `MyThread` named "My Thread 1".
  - Prints runtime/thread metadata: `getId()`, `getContextClassLoader()`, `getPriority()`.
  - Starts the thread and prints its `getState()` and `isAlive()` status.
- Includes (commented) examples showing where to set priority and how to use Runnable anonymously.

WHY this matters:
- Shows how to create and name threads, and why naming helps debugging.
- Demonstrates thread lifecycle basics: NEW → RUNNABLE → TIMED_WAITING (during sleep) → RUNNABLE.
- Teaches how to inspect thread attributes for debugging or monitoring:
  - `getId()` for unique thread id,
  - `getPriority()` for scheduler hints,
  - `getContextClassLoader()` for class loading context,
  - `getState()` and `isAlive()` for runtime state checks.
- Reinforces safe use of `Thread.sleep()` and interruption handling.

HOW it works:
1. `new MyThread("My Thread 1")` creates a thread in state NEW.
2. `t.start()` asks the JVM to schedule the thread; JVM calls `run()` on the new thread.
3. `run()` performs `Thread.sleep(1000)` (TIMED_WAITING) then loops printing a counter.
4. Main thread immediately prints state and alive flag; because of timings the thread may still be NEW, RUNNABLE, or TIMED_WAITING depending on scheduling.
5. Because `MyThread.run()` loops forever, it will keep printing until JVM exits or the thread is interrupted/stopped.

TIPS & GOTCHAS:
- Don’t call `run()` directly — use `start()` to actually spawn a new OS/JVM thread.
- Always handle `InterruptedException` by restoring interrupt status if you cannot fully handle it: `Thread.currentThread().interrupt()`.
- Setting priority (`setPriority`) only hints to the scheduler — behavior is platform-dependent and not guaranteed.
- Avoid infinite loops in production; provide a controlled shutdown using a `volatile boolean running` flag or proper interrupt handling.
- Printing in tight loops can flood the console and distort scheduling observations — use sleep or bounded loops for demos.
- `getContextClassLoader()` useful in modular/classloader-heavy apps; often not required for simple demos.
- For real concurrency tasks prefer `ExecutorService` / thread pools instead of raw thread management.

Short key: java-threads thread-metadata sleep lifecycle getId getState isAlive priority debugging.

Signed-off-by: https://github.com/Someshdiwan <[email protected]>

Author: Someshdiwan

Section19MultiThreading/src/ThreadsMethods.java

@@ -1,28 +1,19 @@
 import javax.naming.Name;
 
-/*
-class MyRunThread implements Runnable
-{
-    public void run(){} //Dummy Method
-}
-*/
-class MyThread extends Thread
-{
-    public MyThread(String name)
-    {
+class MyThread extends Thread {
+    public MyThread(String name) {
         super(name);
-        //setPriority(Thread.MAX_PRIORITY); //setting a priority to the thread.
+        //setPriority(Thread.MAX_PRIORITY);
+        //setting a priority to the thread.
     }
-    public void run()
-    {
+    public void run() {
         int count=1;
-        //make thread sleep for while
 
+        //make thread sleep for a while.
         try {
             Thread.sleep(1000);
         }
-        catch (InterruptedException e)
-        {
+        catch (InterruptedException e) {
             System.out.println(e);
         }
         while(true) {
@@ -32,26 +23,32 @@ public void run()
 }
 
 public class ThreadsMethods {
-    public static void main(String[] args) throws Exception
-    {
+    public static void main(String[] args) throws Exception {
         /* Thread t=new Thread(new MyRunThread(),"My Name");*/
-        //Created anonmus object of runnable.
-        // without any reference we created an anonmuys object.
+
+        //Created an anonymous object of runnable.
+        //Without any reference, we created an anonymous object.
 
         MyThread t=new MyThread("My Thread 1");
         //MyThread class ka object.
-        System.out.println(t.getId());
 
+        System.out.println(t.getId());
         System.out.println(t.getContextClassLoader()+"ID");
-
         System.out.println(t.getPriority()+ "Name");
 
-        t.start(); //states
-       /* What are the all the sates.
-        System.out.println("State "+t.getState());*/
-
+        t.start();
+        /* What are the all the sates.
         System.out.println("State "+t.getState());
+        */
 
-        System.out.println("Alive " +t.isAlive());
+        System.out.println("State "+ t.getState());
+        System.out.println("Alive " + t.isAlive());
     }
 }
+
+/*
+class MyRunThread implements Runnable
+{
+    public void run(){} //Dummy Method
+}
+*/