A Thread is a small set of instructions designed to be scheduled and executed by the CPU independently of the parent process.
To run the process in another thread, you the support of both the operating system and the process. When you create another thread, JVM communicates OS to create a new thread which can then run on the "multi-threaded CPU".
Well this article isn't about explain threads, it's about how you can play with them in Java
Threads are everywhere by default
- When write and run a simple java program, JVM is creating the main thread for you to print hello world
public class Solution {
public static void main(String[] args) throws Exception {
System.out.println("hello world");
throw new Exception();
}
}
// output :
hello world
Exception in thread "main" java.lang.Exception
at Solution.main(Solution.java:5)
If you read the error message carefully, it says Exception in thread "main" , hence proved ...
How to create a thread ?
Well, cuz Java is an Object-Oriented Language, everything is wrapped in OOP concepts. To run a method of some class in-parallel
- Extend the class from the Thread class
- Create a method overriding the run() method
This run method is what is executed separately in a thread.
Here is an example :
class Hi extends Thread {
@Override
public void run() {
for (int i = 1; i < 5; i++) {
System.out.println("hi");
// just sleeping for some time
try {Thread.sleep(400);} catch (Exception e) {}
}
}
}
public class App {
public static void main(String[] args) {
Hi obj1 = new Hi();
obj1.start();
}
}
To run two thread of seperate class
class Hi extends Thread {
@Override
public void run() {
for (int i = 1; i < 5; i++) {
System.out.println("hi");
try { Thread.sleep(400); } catch (Exception e) {}
}
}
}
class Hello extends Thread {
public void run() {
for (int i = 1; i < 5; i++) {
System.out.println("hello");
try { Thread.sleep(400); } catch (Exception e) {}
}
}
}
public class App {
public static void main(String[] args) {
Hi obj1 = new Hi();
Thread obj2 = new Hello();
obj1.start();
obj2.start();
}
}
When you call the .start() method, it will execute the run() method in a seperate thread.
Well becuase java doesnt support mulitple inheritanc, if you ever have to inherit from another class, you wont be able to do it. To overcome this limitation/feature we can implement the Runnable interface
class Hi implements Runnable {
public void run() {
for (int i = 1; i < 5; i++) {
System.out.println("hi");
try { Thread.sleep(400); } catch (Exception e) {}
}
}
}
class Hello implements Runnable {
public void run() {
for (int i = 1; i < 5; i++) {
System.out.println("hello");
try { Thread.sleep(400); } catch (Exception e) {}
}
}
}
public class App {
public static void main(String[] args) {
Runnable obj1 = new Hi();
Runnable obj2 = new Hello();
Thread t1 = new Thread(obj1);
Thread t2 = new Thread(obj2);
t1.start();
t2.start();
}
}
The only difference here is you implement the Runnable interface, create objects of the Thread class passing the objects implementing Runnable, and call the start method on the thread object, which in--return executes the .run() methods.
Properties of a Thread Class
-
getName() : Stringgets you the name of the thread-
setName(String name): set name of a thread
-
-
isAlive() : Booleanwhether the thread is active or not -
getId() : Longget the execution id of the thread -
getPriority(): get the priority of thread-
setPriority(int num): on a scale of 1-10 - Predefined ENUMS
-
Thread.MAX_PRIORITY= 10 -
Thread.MIN_PRIORITY= 1 -
Thread.NORM_PRIORITY= 5
-
For more, refer to documentation : https://download.java.net/java/early_access/loom/docs/api/java.base/java/lang/Thread.html
class Hi extends Thread {
public void run() {
for (int i = 1; i < 5; i++) {
try { Thread.sleep(400); } catch (Exception e) { }
}
}
}
public class App {
public static void main(String[] args) throws InterruptedException {
Hi obj1 = new Hi();
obj1.start();
System.out.println("Name : " + obj1.getName());
var threadName = obj1.getName();
System.out.println(threadName + " isAlive : " + obj1.isAlive());
System.out.println(threadName + " threadId : " + obj1.getId());
System.out.println(threadName + " priority : " + obj1.getPriority());
System.out.println(Thread.MAX_PRIORITY);
System.out.println(Thread.MIN_PRIORITY);
System.out.println(Thread.NORM_PRIORITY);
obj1.join();
}
}
Joining Threads
When you spin off a thread, you also have to wait for it to finish its task before moving on to avoid errors/exception
class App {
public static void main(String[] args) {
Thread obj1 = new Thread(() -> {
for (int i = 1; i < 5; i++) {
System.out.println(Thread.currentThread().getName());
try { Thread.sleep(400); } catch (Exception e) {}
}
}, "Thread 1");
Thread obj2 = new Thread(() -> {
for (int i = 1; i < 5; i++) {
System.out.println(Thread.currentThread().getName());
try { Thread.sleep(400); } catch (Exception e) {}
}
}, "Thread 2");
obj1.start();
obj2.start();
try {
obj1.join();
obj2.join();
} catch (Exception e) {
System.out.println("execption");
}
System.out.println("bye");
}
}
Synchronizing Threads
class DataClass {
int num;
boolean valueSet = false;
public synchronized void getNum() {
while (!valueSet) {
try {
wait();
} catch (Exception e) {
}
}
System.out.println("get : " + num);
valueSet = false;
notify();
}
public synchronized void setNum(int num) {
while (valueSet) {
try {
wait();
} catch (Exception e) {
}
}
this.num = num;
System.out.println("set : " + num);
valueSet = true;
notify();
}
}
class Producer implements Runnable {
DataClass dataClass;
public Producer(DataClass data) {
this.dataClass = data;
}
@Override
public void run() {
int i = 0;
while (true) {
dataClass.setNum(i++);
try {
Thread.sleep(800);
} catch (Exception e) {
System.out.println("exception");
}
}
}
}
class Consumer implements Runnable {
DataClass dataClass;
public Consumer(DataClass data) {
this.dataClass = data;
}
@Override
public void run() {
while (true) {
dataClass.getNum();
try {
Thread.sleep(1000);
} catch (Exception e) {
System.out.println("exception");
}
}
}
}
public class App {
public static void main(String[] args) {
DataClass dataClass = new DataClass();
var producer = new Producer(dataClass);
var consumer = new Consumer(dataClass);
Thread t1 = new Thread(producer);
Thread t2 = new Thread(consumer);
t1.start();
t2.start();
}
}
Top comments (0)