What is Thread ? Why Multithreading?

Thread

A thread is the smallest segment of an entire process, which allows a program to operate more efficiently by doing multiple things at the same time. It is an independent, virtual and sequential control flow within a process, so threads can be used to perform complicated tasks in the background without interrupting the main program.

There is always at least one thread running internally in every program and this thread is used by JVM to execute statements in the program. When a program contains a single flow of control, it is called a single-threaded program. In a single thread program, there is a beginning, a body, and an end, and execute commands sequentially. Look at the below figure which shows the Single-threaded program.

Single Thread

In Java, a single-threaded program is a program that executes a single set of instructions in a sequential manner, one after the other. In other words, the program executes only one task at a time and waits for the current task to be complete before moving on to the next one.

Here is the syntax for a simple single-threaded program in Java:

public class Main {
   public static void main(String[] args) {
      // code to be executed in the main thread
   }
}

In this example, the 'main()' method is the entry point for the program and it contains the code that will be executed by the single thread in the program.

Here is a simple example program that demonstrates a single-threaded program in java:

public class Main {
   public static void main(String[] args) {
      for (int i = 0; i < 10; i++) {
         System.out.println("Main thread: " + i);
         try {
            Thread.sleep(100);
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
      }
   }
}
 

This program runs a loop that prints out numbers to the console. Since it is a single-threaded program, only one set of instructions is executed at a time and the program will wait for the current iteration of the loop to complete before moving on to the next one.

Advantages & Disadvantages of threads:

Some advantages include:

1. Reduces development time.


2. Reduces maintenance costs.


3. Improves the performance of complex applications.


4. Useful for improving the responsiveness of the user interfaces.


5. Used in server applications for improving high throughput and resource utilization.


6. Parallelize tasks.


7. If a thread cannot use all the computing resources of the CPU (because instructions depend on each other's result), running another thread can avoid leaving these idle.


8. If several threads work on the same set of data, they can actually share their cache, leading to better cache usage or synchronization of its values.

Some disadvantages include:

1. Multiple threads can interfere with each other when sharing hardware resources such as caches or translation look-aside buffers (TLBs).


2. Execution times of a single thread are not improved but can be degraded, even when only one thread is executing. This is due to slower frequencies and/or additional pipeline stages that are necessary to accommodate thread-switching hardware.


3. Hardware support for multithreading is more visible to software, thus requiring more changes to both application programs and operating systems than multiprocessing.

Multithreading 

Multithreading in Java refers to the ability of a program or application to execute multiple threads concurrently. Threads are separate execution paths within a single program and they can run concurrently with each other, which can help improve the overall performance and responsiveness of an application. 

Here is the syntax for creating a multithreaded program in Java:

class MyThread implements Runnable {
  public void run() {
    // code to be executed by the thread
  }
}

public class Main {
  public static void main(String[] args) {
    // create the thread
    Thread t = new Thread(new MyThread());
    // start the thread
    t.start();
  }
}

In this example, we create a new class called 'MyThread' that extends the 'Thread' class. The 'run()' method contains the code that will be executed when the thread is started. To create a new thread, we create an instance of the 'MyThread' class and then call the 'start()' method on that instance.

Here is a simple example program that demonstrates multithreading in Java:

class MyThread implements Runnable {
  public void run() {
    System.out.println("Thread running...");
  }
}

public class Main {
  public static void main(String[] args) {
    Thread t1 = new Thread(new MyThread());
    Thread t2 = new Thread(new MyThread());
    
    t1.start();
    t2.start();
  }
}

In this example, we have created two threads 't1' and 't2' that are running the same code, defined in the 'MyThread' class. When the program is run, both threads will start simultaneously and print "Thread running......" to the console.

Advantages of Multithreading

1. Improved Performance: Multithreading allows multiple tasks to be executed concurrently, which can improve the overall performance of a system by utilizing the full capacity of the CPU.

2. Better Responsiveness: Multithreading can help improve the responsiveness of an application by allowing background tasks to be executed while the user continues to interact with the application.

3. Resource Sharing: Multiple threads within a single process share the same memory space, making it easier to share data and resources.

4. Efficient use of system resources: By executing multiple tasks simultaneously, multithreading helps to minimize the wastage of system resources, such as memory and CPU time.

Disadvantages of Multithreading

1. Complexity: Multithreading adds an additional layer of complexity to an application, making it more difficult to design, develop, and debug.

2. Synchronization Issues: Coordinating the execution of multiple threads can be challenging, especially when they share resources or need to communicate with each other. This can lead to synchronization issues and race conditions.

3. Deadlocks: Deadlocks can occur when two or more threads are blocked, waiting for resources that are held by the other threads, leading to a situation where none of the threads can proceed.

4. Performance overhead: The overhead associated with creating and managing threads can affect the performance of an application, especially on systems with limited resources. 

In Conclusion, multithreading in Java can bring significant benefits to an application, but it also requires careful design and implementation to avoid the potential issues that can arise from using multiple threads.