Java Multithreading

Java Thread methods

Thread Creation In Java

There are two ways to create a thread in Java.

1. By extending Thread class

2. By implementing Runnable interface and overriding run() method.

There are some differences in the above two approaches.

1. By using extend approach your class can’t extend any other class as it is already used while in case of Runnable interface your class may still extend some class.

2. Runnable approach creates an object and we pass that object to thread while in case of extending it is not so.

Example Of Java Thread Creation By Extending Thread Class

See below example of producer and consumer thread which are extending Thread class. Study it to understand.

package threads;
import java.util.Date;
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;

public class MyExtendThread extends Thread {
public static void main(String[] args) {
     BlockingDeque<String> bqueue = new LinkedBlockingDeque<String>(5);
    //Producer thread start
     Producer producer = new Producer(bqueue);
     producer.start();
     Producer producer2 = new Producer(bqueue);
     producer2.start();
     //Created Consumer thread
     Consumer consumerThread = new Consumer(bqueue);
     consumerThread.start();
     System.out.println("Main thread is dead, this does not mean other threads are dead, they still live");
}
}
class Producer extends Thread {
BlockingDeque<String> bqueue = new LinkedBlockingDeque<String>();
public Producer(BlockingDeque<String> bqueue) {
     this.bqueue = bqueue;
}






public void run() {
     while(true){
         String date = new Date().toString();
         bqueue.add(date);
         System.out.println("Producer - I have added: "+date+" in blocking queue, capacity now:"+bqueue.size()+" name"+Thread.currentThread().getName());
         try {
             Thread.sleep(1000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }
}
}
class Consumer extends Thread {
BlockingDeque<String> bqueue = new LinkedBlockingDeque<String>();
public Consumer(BlockingDeque<String> bqueue) {
     this.bqueue = bqueue;
}
public void run() {
     while(true){
         String date ="";
             try {
                 date = bqueue.take();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         System.out.println("Consumer - I have removed: "+date+" something from blocking queue, capacity now:"+bqueue.size()+" name"+Thread.currentThread().getName());
         try {
             Thread.sleep(1000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }
}
}

Output:

Main thread is dead, this does not mean other threads are dead, they still live
Producer - I have added: Wed Sep 15 18:54:35 IST 2021 in blocking queue, capacity now:0 nameThread-1
Consumer - I have removed: Wed Sep 15 18:54:35 IST 2021 something from blocking queue, capacity now:1 nameThread-2
Producer - I have added: Wed Sep 15 18:54:35 IST 2021 in blocking queue, capacity now:1 nameThread-0
Consumer - I have removed: Wed Sep 15 18:54:35 IST 2021 something from blocking queue, capacity now:0 nameThread-2
Producer - I have added: Wed Sep 15 18:54:36 IST 2021 in blocking queue, capacity now:2 nameThread-0
Producer - I have added: Wed Sep 15 18:54:36 IST 2021 in blocking queue, capacity now:1 nameThread-1
Consumer - I have removed: Wed Sep 15 18:54:36 IST 2021 something from blocking queue, capacity now:1 nameThread-2
Producer - I have added: Wed Sep 15 18:54:37 IST 2021 in blocking queue, capacity now:3 nameThread-1
Producer - I have added: Wed Sep 15 18:54:37 IST 2021 in blocking queue, capacity now:3 nameThread-0

Example of Java Thread Creation By Implementing Runnable Interface

package threads;
import java.util.Date;
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;

class MyRunnableThread extends Thread {
public static void main(String[] args) {
     BlockingDeque<String> bqueue = new LinkedBlockingDeque<String>(5);
     //Producer thread start
     ProducerRunnable producer = new ProducerRunnable(bqueue);
     new Thread(producer).start();






     Producer producer2 = new Producer(bqueue);
     producer2.start();
     //Created Consumer thread
     ConsumerRunnable consumerThread = new ConsumerRunnable(bqueue);
     new Thread(consumerThread).start();
     System.out.println("Main thread is dead, this does not mean other threads are dead, they will still live");
}
}
class ProducerRunnable implements Runnable {
BlockingDeque<String> bqueue;
public ProducerRunnable(BlockingDeque<String> bqueue) {
     this.bqueue = bqueue;
}
public void run() {
     while(true){
         String date = new Date().toString();
         bqueue.add(date);
         System.out.println("Producer - I have added: "+date+" in blocking queue, capacity now:"+bqueue.size()+" name"+Thread.currentThread().getName());
         try {
             Thread.sleep(1000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }
}
}






class ConsumerRunnable implements Runnable {
BlockingDeque<String> bqueue;
public ConsumerRunnable(BlockingDeque<String> bqueue) {
     this.bqueue = bqueue;
}
public void run() {
     while(true){
         String date ="";
         try {
             date = bqueue.take();
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println("Consumer - I have removed: "+date+" something from blocking queue, capacity now:"+bqueue.size()+" name"+Thread.currentThread().getName());
         try {
             Thread.sleep(1000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }
}
}

Output

Main thread is dead, this does not mean other threads are dead, they will still live
Producer - I have added: Thu Sep 16 10:18:27 IST 2021 in blocking queue, capacity now:0 nameThread-0
Consumer - I have removed: Thu Sep 16 10:18:27 IST 2021 something from blocking queue, capacity now:1 nameThread-2
Producer - I have added: Thu Sep 16 10:18:27 IST 2021 in blocking queue, capacity now:1 nameThread-1
Consumer - I have removed: Thu Sep 16 10:18:27 IST 2021 something from blocking queue, capacity now:0 nameThread-2
Producer - I have added: Thu Sep 16 10:18:28 IST 2021 in blocking queue, capacity now:2 nameThread-0
Producer - I have added: Thu Sep 16 10:18:28 IST 2021 in blocking queue, capacity now:1 nameThread-1
Consumer - I have removed: Thu Sep 16 10:18:28 IST 2021 something from blocking queue, capacity now:1 nameThread-2
Producer - I have added: Thu Sep 16 10:18:29 IST 2021 in blocking queue, capacity now:3 nameThread-0
Producer - I have added: Thu Sep 16 10:18:29 IST 2021 in blocking queue, capacity now:2 nameThread-1
Consumer - I have removed: Thu Sep 16 10:18:28 IST 2021 something from blocking queue, capacity now:2 nameThread

Example of Thread Creation Using Functional Interface and Lambda Expression

package threads;
public class LambdaExpressionThreads {
public static void main(String[] args) {

     //Using functional interface concept
     new Thread(new Runnable() {
         @Override
         public void run() {
             System.out.println("I am a thread, created without lambda with functional interface.");
         }
     }).start();
     //Lamda expression to create thread, same as above but with lamda
     new Thread(() -> {
         System.out.println("I am a thread, created with lambda expression.");
     }).start();
}
}

Output

I am a thread, created without lambda with a functional interface.
I am a thread, created with lambda expressions.

Next Article

• sleep, wait, notify and notifyAll, synchronized Methods of Thread In Java