Java Basic Multi-threading Tutorial

A thread is a lightweight sub-process that runs concurrently with other threads within a single process. Threads share the same memory space, making it easier to share data between them.

• Main Thread: The default thread that starts when a Java program begins execution.
• User-defined Threads: Threads created by the programmer to perform specific tasks.

There are two main ways to create threads in Java:

• Extending the Thread Class:
  Edit Copy

  class MyThread extends Thread {
      public void run() {
          System.out.println("Thread is running.");
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          MyThread thread = new MyThread();
          thread.start(); // Start the thread
      }
  }

• Implementing the Runnable Interface:
  Edit Copy

  class MyRunnable implements Runnable {
      public void run() {
          System.out.println("Thread is running.");
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          Thread thread = new Thread(new MyRunnable());
          thread.start(); // Start the thread
      }
  }

A thread goes through various states during its lifecycle:

• New: The thread is created but not yet started.
• Runnable: The thread is ready to run and waiting for CPU time.
• Running: The thread is executing its task.
• Blocked/Waiting: The thread is waiting for a resource or another thread.
• Terminated: The thread has completed its task.

When multiple threads access shared resources, synchronization is necessary to prevent data inconsistency. You can use the synchronized keyword to create synchronized methods or blocks.

• Synchronized Method:
  Edit Copy

  class Counter {
      private int count = 0;
  
      public synchronized void increment() {
          count++;
      }
  
      public int getCount() {
          return count;
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          Counter counter = new Counter();
  
          Thread t1 = new Thread(() -> {
              for (int i = 0; i < 1000; i++) {
                  counter.increment();
              }
          });
  
          Thread t2 = new Thread(() -> {
              for (int i = 0; i < 1000; i++) {
                  counter.increment();
              }
          });
  
          t1.start();
          t2.start();
  
          try {
              t1.join();
              t2.join();
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
  
          System.out.println("Count: " + counter.getCount());
      }
  }

• Synchronized Block:
  Edit Copy

  class Counter {
      private int count = 0;
  
      public void increment() {
          synchronized (this) {
              count++;
          }
      }
  
      public int getCount() {
          return count;
      }
  }

Threads can communicate with each other using methods like wait(), notify(), and notifyAll().

• Example:
  Edit Copy

  class SharedResource {
      private boolean ready = false;
  
      public synchronized void produce() {
          ready = true;
          notify(); // Notify the waiting thread
      }
  
      public synchronized void consume() {
          while (!ready) {
              try {
                  wait(); // Wait until notified
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
          }
          System.out.println("Resource is ready.");
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          SharedResource resource = new SharedResource();
  
          Thread producer = new Thread(() -> {
              resource.produce();
          });
  
          Thread consumer = new Thread(() -> {
              resource.consume();
          });
  
          consumer.start();
          producer.start();
      }
  }