Updated February 10, 2023
Introduction to Java 8 Thread
Java 8 thread is nothing but the execution of thread in a specified program. The java virtual machine enables an application to run multiple threads concurrently. Every thread in Java has its own priority. The threads with the highest priority were executed first. Every thread in code can be marked as a daemon. When the code is executed, a new thread object is created.
Key Takeaways
- In Java, all threads are not daemon threads, and when they die, they either return the call method or the beyond run method.
- We create the thread in Java by implementing the runnable interface and using lambda expressions. When creating a thread, we use the runnable method.
What is Java 8 Thread?
At the time of creating a new thread in java 8, it will set its priority equal to the daemon thread and new thread. At the time the java virtual machine starts, it contains a single daemon thread. The threads are continuously executed by the java virtual machine until an event occurs. When the class’s exit method is called, and the security manager allows the exit operation, the thread execution is terminated.
In java 8, there are two ways to create the execution of a new thread. The first way is to declare the class to a thread subclass. This subclass overrides the run method of the thread class. The instance subclass is initialized and allocated. We make a thread class object by passing the created reference to the runnable interface.
How to Create Java 8 Thread Expressions?
We can create thread expressions by using lambda in Java 8. This expression in java is developed by using the functional interface. The functional interface is an interface that contains the abstract method.
To create the expressions, we need to follow the below steps as follows:
- In the first step, we need to create the runnable interface and reference and need to write the run method lambda expression.
- In the second step, we are creating the object of the thread class by passing created reference of a runnable interface by using the start method, which was defined in the object of the thread class.
- In the third step, we are invoking the start method for running the thread.
Below example shows how we can create the java 8 thread expressions as follows:
Example #1
In the below example, we are creating a class name as texp.
Code:
public class texp {
public static void main(String[] args)
{
Runnable mth = () ->
{
Thread.currentThread ().setName ("Thread");
System.out.println (Thread.currentThread ().getName() + " running");
};
Thread run = new Thread (mth);
run.start ();
}
}Output:
Example #2
In the below example, we are creating two threads as follows.
Code:
public class texp {
public static void main(String[] args)
{
Runnable bas = () ->
{
String tname
= Thread.currentThread ().getName();
System.out.println ("Running task by"
+ tname);
};
Thread th1 = new Thread (bas);
Thread th2 = new Thread (bas);
th1.start ();
th2.start ();
}
}Output:
Java 8 Thread Running
As we know that all operating system contains concurrency by using thread and process. At the time of starting the java program, the operating system creates a new process that runs in parallel with other programs. We are utilizing concurrently executing threads within those threads, resulting in more available CPU for our operations.
Java supports the threads since jdk version 1.0. Threads have been supported by Java since jdk version 1.0. When we start a new thread, we must specify the code that was executing the thread and was called by task. We can complete this by implementing the runnable interface and the run method.
Below example shows java 8 thread running as follows:
Code:
public class trun {
public static void main(String[] args) {
Runnable run1 = new Runnable (){
public void run (){
System.out.println ("Th1 is running...");
}
};
Thread th1=new Thread (run1);
th1.start ();
Runnable run2 = ()->{
System.out.println ("Th2 is running...");
};
Thread th2 = new Thread (run2);
th2.start ();
}
}Output:
Java 8 Thread Framework
The java 8 thread framework contains a bunch of components which was used to manage the worker threads effectively. The executor API will reduce the execution of the task from the actual task which was executed by the executor. The thread framework is nothing but the implementation of consumer and producer patterns.
To use the thread framework, we need to create the thread pool for executing the task and submitting the same task to thread pool.
The below example shows thread framework as follows. Here we are creating the first class.
Code:
public class Thread_Framework1 implements Runnable {
private String t_No;
public Thread_Framework1(String no) {
this.t_No = no;
}
@Override
public void run() {
System.out.println (Thread.currentThread ().getName()+" Execution started No. = "+t_No);
processThread ();
System.out.println (Thread.currentThread().getName()+" Execution stop.");
}
private void processThread() {
try {
Thread.sleep (4000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
@Override
public String toString(){
return this.t_No;
}
}Output:
After creating the first class now, in this step, we are creating an executor class; in that class, we are defining the main method as follows.
Code:
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Thread_Framework2
{
public static void main(String[] args)
{
ExecutorService eser = Executors.newFixedThreadPool (5);
for (int p = 0; p < 5; p++){
Runnable task = new Thread_Framework1 ("" + p);
eser.execute (task);
}
eser.shutdown ();
while (!eser.isTerminated ()) {
}
System.out.println ("Finished threads");
}
}Output:
Executors
Below are the types of executors available in the java 8 thread as follows:
There are four types of executors available in java.
- Single thread executor: This is the single thread pool which obtained by calling the executor class static method.
- Fixed thread pool: As per the name, it is a thread pool that contains a fixed number of threads. The thread executes the task submitted by the executor.
- Cached thread pool: This method creates a thread pool, which is used to create new threads.
- Scheduled executor: This executor is based on the interface name as ScheduledExecutorService, which extends the interface.
In the below example, we are creating the first class as follows.
Code:
import java.util.concurrent.*;
class Exec1 implements Callable<String>
{
private String msg;
public Exec1(String message)
{
this.msg = message;
}
public String call() throws Exception
{
return "Executor " + msg + "!";
}
}Output:
After creating the first class, now in this step, we are creating the executor second class, which contains the main method as follows.
Code:
import java.util.concurrent.*;
public class Exec2
{
public static void main(String[] args)
{
Exec1 task = new Exec1("Executor");
ExecutorService eser = Executors.newFixedThreadPool (4);
Future<String> res = eser.submit (task);
try {
System.out.println (res.get());
}
catch (InterruptedException | ExecutionException e)
{
System.out.println ("Received error");
e.printStackTrace ();
}
eser.shutdown ();
}
}Output:
Web Applications
Threading and thread pools are provided by Java. The thread pool was connected with the request processing model; all tasks originated from the external caller and are processed sequentially by a single thread. The thread pool always ensures that a thread is available in a task.
We are using a thread pool to dispose the thread and create a new thread. A new thread is created only when there is not any idle thread available. The old thread is disposed when there are multiple idle threads going, and they need some time to complete the execution.
Below example shows web applications as follows:
Code:
public class WebApp {
public static void main(String[] args) {
new Thread(() -> {
for(int p = 1; p <= 5; p++) {
System.out.println ("Child Thread: "+ p);
try {
Thread.sleep (100);
} catch (Exception e) {
e.printStackTrace ();
}
}
}).start();
for(int q = 1; q < 5; q++) {
System.out.println ("Main Thread: "+ q);
try {
Thread.sleep (100);
} catch (Exception e)
e.printStackTrace ();
}
}
}
}Output:
Conclusion
In Java 8, there are two ways to create the execution of the new thread. The first way to declare the class to a thread subclass. It is nothing but the execution of thread in a specified program. The Java virtual machine allows an application that contains multiple threads which were running concurrently.
Recommended Articles
This is a guide to Java 8 Thread. Here we discuss how to create java 8 thread expressions, frameworks, executors & web applications. You may also have a look at the following articles to learn more –
