Java Multithreading Tutorial
Last Updated :
25 Mar, 2025
Threads are the backbone of multithreading. We are living in the real world which in itself is caught on the web surrounded by lots of applications. With the advancement in technologies, we cannot achieve the speed required to run them simultaneously unless we introduce the concept of multi-tasking efficiently. It is achieved by the concept of thread.
Real-life Example of Java Multithreading
Suppose you are using two tasks at a time on the computer, be it using Microsoft Word and listening to music. These two tasks are called processes . So you start typing in Word and at the same time start music app, this is called multitasking . Now you committed a mistake in a Word and spell check shows exception, this means Word is a process that is broken down into sub-processes. Now if a machine is dual-core then one process or task is been handled by one core and music is been handled by another core.
In the above example, we come across both multiprocessing and multithreading. These are somehow indirectly used to achieve multitasking. In this way the mechanism of dividing the tasks is called multithreading in which every process or task is called by a thread where a thread is responsible for when to execute, when to stop and how long to be in a waiting state. Hence, a thread is the smallest unit of processing whereas multitasking is a process of executing multiple tasks at a time.
Multitasking is being achieved in two ways :
- Multiprocessing : Process-based multitasking is a heavyweight process and occupies different address spaces in memory. Hence, while switching from one process to another, it will require some time be it very small, causing a lag because of switching. This happens as registers will be loaded in memory maps and the list will be updated.
- Multithreading : Thread-based multitasking is a lightweight process and occupies the same address space. Hence, while switching cost of communication will be very less.
Below is the Lifecycle of a Thread been illustrated
- New : When a thread is just created.
- Runnable : When a start() method is called over thread processed by the thread scheduler.
- Case A: Can be a running thread
- Case B: Can not be a running thread
- Running : When it hits case 1 means the scheduler has selected it to be run the thread from runnable state to run state.
- Blocked : When it hits case 2 meaning the scheduler has selected not to allow a thread to change state from runnable to run.
- Terminated : When the run() method exits or stop() method gets called.
If we do incorporate threads in operating systems one can perceive that the process scheduling algorithms in operating systems are strongly deep-down working on the same concept incorporating thread in Gantt charts . A few of the most popular are listed below which wraps up all of them and are used practically in software development.
- First In First Out
- Last In First Out
- Round Robin Scheduling
Now Imagine the concept of Deadlock in operating systems with threads - how the switching is getting computed over internally if one only has an overview of them.
So far we have understood multithreading and thread conceptually, so we can conclude advantages of multithreading before moving to any other concept or getting to programs in multithreading.
- The user is not blocked as threads are independent even if there is an issue with one thread then only the corresponding process will be stopped rest all the operations will be computed successfully.
- Saves time as too many operations are carried over at the same time causing work to get finished as if threads are not used the only one process will be handled by the processor.
- Threads are independent though sharing the same address space.
So we have touched all main concepts of multithreading but the question striving in the head is left. why do we need it, where to use it and how? Now, we will discuss all three scenarios why multithreading is needed and where it is implemented via the help of programs in which we will be further learning more about threads and their methods. We need multithreading in four scenarios as listed.
- Thread Class
- Mobile applications
- Web applications
- Game Development
Note: By default we only have one main thread which is responsible for main thread exception as you have encountered even without having any prior knowledge of multithreading
Two Ways to Implement Multithreading
Method 1: Using Thread Class
Java provides Thread class to achieve programming invoking threads thereby some major methods of thread class are shown below in the tabular format with which we deal frequently along the action performed by them.
| Methods | Action Performed |
|---|
| isDaemon() | It checks whether the current thread is daemon or not |
| start() | It starts the execution of the thread |
| run() | It does the executable operations statements in the body of this method over a thread |
| sleep() | It is a static method that puts the thread to sleep for a certain time been passed as an argument to it |
| wait() | It sets the thread back in waiting state. |
| notify() | It gives out a notification to one thread that is in waiting state |
| notifyAll() | It gives out a notification to all the thread in the waiting state |
| setDaemon() | It set the current thread as Daemon thread |
| stop() | It is used to stop the execution of the thread |
| resume() | It is used to resume the suspended thread. |
Pre-requisites: Basic syntax and methods to deal with threads
Now let us come up with how to set the name of the thread. By default, threads are named thread-0, thread-1, and so on. But there is also a method that is often used as setName() method. Also corresponding to it there is a method getName() which returns the name of the thread be it default or settled already by using setName() method. The syntax is as follows:
Syntax:
(a) Returning the name of the thread
public String getName() ;
(b) Changing the name of the thread
public void setName(String name);
Taking a step further, let us dive into the implementation part to understand more concepts about multithreading. So, there are basically two ways of implementing multithreading:
Illustration: Consider if one has to multiply all elements by 2 and there are 500 elements in an array.
Examples
Java
// Case 1
// Java Program to illustrate Creation and execution of
// thread via start() and run() method in Single inheritance
// Class 1
// Helper thread Class extending main Thread Class
class MyThread1 extends Thread {
// Method inside MyThread2
// run() method which is called as
// soon as thread is started
public void run()
{
// Print statement when the thread is called
System.out.println("Thread1 is running");
}
}
// Class 2
// Main thread Class extending main Thread Class
class MyThread2 extends Thread {
// Method inside MyThread2
// run() method which is called
// as soon as thread is started
public void run()
{
// run() method which is called as soon as thread is
// started
// Print statement when the thread is called
System.out.println("Thread2 is running");
}
}
// Class 3
// Main Class
class GFG {
// Main method
public static void main(String[] args)
{
// Creating a thread object of our thread class
MyThread1 obj1 = new MyThread1();
MyThread2 obj2 = new MyThread2();
// Getting the threads to the run state
// This thread will transcend from runnable to run
// as start() method will look for run() and execute
// it
obj1.start();
// This thread will also transcend from runnable to
// run as start() method will look for run() and
// execute it
obj2.start();
}
}
// Case 2
// Java Program to illustrate Difference between Runnable
// & Non-runnable Threads And Single Inheritance
// Class 1
// Helper thread Class extending main Thread Class
class MyThread1 extends Thread {
// Method inside MyThread2
// run() method which is called as soon as thread is
// started
public void run() {
// Print statement when the thread is called
System.out.println("Thread 1 is running");
}
}
// Class 2
// Main thread Class extending main Thread Class
class MyThread2 extends Thread {
// Method
public void show() {
// Print statement when thread is called
System.out.println("Thread 2");
}
}
// Class 3
// Main Class
class GFG {
// Main method
public static void main(String[] args) {
// Creating a thread object of our thread class
MyThread1 obj1 = new MyThread1();
MyThread2 obj2 = new MyThread2();
// Getting the threads to the run state
// This thread will transcend from runnable to run
// as start() method will look for run() and execute
// it
obj1.start();
// This thread will now look for run() method which is absent
// Thread is simply created not runnable
obj2.start();
}
}
// Java Program to illustrate difference between
// start() method thread vs show() method
// Class 1
// Helper thread Class extending main Thread Class
class MyThread1 extends Thread {
// Method inside MyThread2
// run() method which is called as soon as thread is
// started
public void run() {
// Print statement when the thread is called
System.out.println("Thread 1 is running");
}
}
// Class 2
// Main thread Class extending main Thread Class
class MyThread2 extends Thread {
// Method
public void show() {
// Print statement when thread is called
System.out.println("Thread 2");
}
}
// Class 3
// Main Class
class GFG {
// Main method
public static void main(String[] args) {
// Creating a thread object of our thread class
MyThread1 obj1 = new MyThread1();
MyThread2 obj2 = new MyThread2();
// Getting the threads to the run state
// This thread will transcend from runnable to run
// as start() method will look for run() and execute
// it
obj1.start();
// This thread is simply a function call as
// no start() method is executed so here only
// thread is created only followed by call
obj2.show();
}
}
Output:
Case 1:
Thread1 is running
Thread2 is running
Here we have created our two thread classes for each thread. In the main method , we are simply creating objects of these thread classes where objects are now threads. So in main , we call thread using start() method over both the threads. Now start() method starts the thread and lookup for their run() method to run. Here both of our thread classes were having run() methods, so both threads are put to run state from runnable by the scheduler, and output on the console is justified.
Case 2:
Thread 1 is running
Here we have created our two thread classes for each thread. In the main method, we are simply creating objects of these thread classes where objects are now threads. So in main, we call thread using start() method over both the threads. Now start() method starts the thread and lookup their run() method to run. Here only class 1 is having the run() method to make the thread transcend from runnable to run state to execute whereas thread 2 is only created but not put to run state by the scheduler as its corresponding run() method was missing. Hence, only thread 1 is called rest thread 2 is created only and is in the runnable state later blocked by scheduler because the corresponding run() method was missing.
Case 3:
Thread 2
Thread 1 is running
Method 2: Using Runnable Interface
Another way to achieve multithreading in java is via the Runnable interface. Here as we have seen in the above example in way 1 where Thread class is extended. Here Runnable interface being a functional interface has its own run() method. Here classes are implemented to the Runnable interface. Later on, in the main() method, Runnable reference is created for the classes that are implemented in order to make bondage with Thread class to run our own corresponding run() methods.
Further, while creating an object of Thread class we will pass these references in Thread class as its constructor allows only one runnable object, which is passed as a parameter while creating Thread class object in a main() method. Now lastly just like what we did in Thread class, start() method is invoked over the runnable object who are now already linked with Thread class objects, so the execution begins for our run() methods in case of Runnable interface. It is shown in the program below as follows:
Example:
Java
// Java Program to illustrate Runnable Interface in threads
// as multiple inheritance is not allowed
// Importing basic packages
import java.io.*;
import java.util.*;
// Class 1
// Helper class implementing Runnable interface
class MyThread1 implements Runnable {
// run() method inside this class
public void run()
{
// Iterating to get more execution of threads
for (int i = 0; i < 5; i++) {
// Print statement whenever run() method
// of this class is called
System.out.println("Thread1");
// Getting sleep method in try block to
// check for any exceptions
try {
// Making the thread pause for a certain
// time using sleep() method
Thread.sleep(1000);
}
// Catch block to handle the exceptions
catch (Exception e) {
}
}
}
}
// Class 2
// Helper class implementing Runnable interface
class MyThread2 implements Runnable {
// run() method inside this class
public void run()
{
for (int i = 0; i < 5; i++) {
// Print statement whenever run() method
// of this class is called
System.out.println("Thread2");
// Getting sleep method in try block to
// check for any exceptions
try {
// Making the thread pause for a certain
// time
// using sleep() method
Thread.sleep(1000);
}
// Catch block to handle the exceptions
catch (Exception e) {
}
}
}
}
// Class 3
// Main class
public class GFG {
// Main driver method
public static void main(String[] args)
{
// Creating reference of Runnable to
// our classes above in main() method
Runnable obj1 = new MyThread1();
Runnable obj2 = new MyThread2();
// Creating reference of thread class
// by passing object of Runnable in constructor of
// Thread class
Thread t1 = new Thread(obj1);
Thread t2 = new Thread(obj2);
// Starting the execution of our own run() method
// in the classes above
t1.start();
t2.start();
}
}
OutputThread2
Thread1
Thread2
Thread1
Thread2
Thread1
Thread2
Thread1
Thread2
Thread1
Points to remember: Whenever you wanted to create threads, there are only two ways:
- Extending the class
- Implementing the interface which is runnable
Make sure to create an object of threads in which you have to pass the object of runnable
Special Methods of Threads
Now let us discuss various methods that are there for threads. Here we will be discussing major methods in order to have a practical understanding of threads and multithreading which are sequential as follows:
- start() Method
- suspend() Method
- stop() Method
- wait() Method
- notify() Method
- notifyAll() Method
- sleep() Method
- Output Without sleep() Method
- Output with sleep() method in Serial Execution Processes (Blocking methods approach)
- Output with sleep() method in Parallel Execution Processes (Unblocking methods approach)
- join() Method
Note: For naive users in multithreading where threads are backbone go through Program 4 to get very basics of threads, how to start, make it hold, or terminate then only toggle to program 1 and rest as follows.
Implementation:
Java
// Example 1
// Java Program to illustrate Output Without sleep() Method
// Class 1
// Helper Class 1
class Shot extends Thread {
// Method 1
public void show() {
// Iterating to print more number of times
for (int i = 0; i < 5; i++) {
// Print statement whenever method
// of this class is called
System.out.println("Shot");
}
}
}
// Class 2
// Helper Class 2
class Miss extends Thread {
// Method 2
public void show() {
// Iterating to print more number of times
for (int i = 0; i < 5; i++) {
// Print statement whenever method
// of this class is called
System.out.println("Miss");
}
}
}
// Class 3
// Main class
public class GFG {
// Method 3
// Main method
public static void main(String[] args) {
// Creating objects in the main() method
// of class 1 and class 2
Shot obj1 = new Shot();
Miss obj2 = new Miss();
// Calling methods of the class 1 and class 2
obj1.show();
obj2.show();
}
}
// Example 2
// Java Program to illustrate Output Using sleep() Method
// in Serial Execution
// Class 1
// Helper Class 1
class Shot extends Thread {
// Method 1
// public void show() {
public void show()
{
// Iterating to print more number of times
for (int i = 0; i < 5; i++) {
// Print statement
System.out.println("Shot");
// Making thread to sleep using sleep() method
// Try-catch block for exceptions
try {
Thread.sleep(1000);
}
catch (Exception e) {
}
}
}
}
// Class 2
// Helper Class 2 Hello
class Miss extends Thread {
// Method 2
// public void show() {
public void show()
{
// Iterating to print more number of times
for (int i = 0; i < 5; i++) {
// Print statement
System.out.println("Miss");
// Making thread to sleep using sleep() method
// Try-catch block for exceptions
try {
Thread.sleep(1000);
}
catch (Exception e) {
}
}
}
}
// Class 3
// Main class
public class GFG {
// Method 3
// Main method
public static void main(String[] args)
{
// Creating objects in the main() method
Shot obj1 = new Shot();
Miss obj2 = new Miss();
// Starting the thread objects
obj1.start();
obj2.start();
// Calling methods of class 1 and class 2
obj1.show();
obj2.show();
}
}
// Example 3
// Java Program to illustrate Output Using sleep() Method
// in Parallel Execution
// Class 1
// Helper Class 1
class Shot extends Thread {
// Method 1
// public void show() {
public void run()
{
// Iterating to print more number of times
for (int i = 0; i < 5; i++) {
// Print statement
System.out.println("Shot");
// Making thread to sleep using sleep() method
// Try catch block for exceptions
try {
Thread.sleep(1000);
}
catch (Exception e) {
}
}
}
}
// Class 2
// Helper Class 2 Hello
class Miss extends Thread {
// Method 2
// public void show() {
public void run()
{
// Iterating to print more number of times
for (int i = 0; i < 5; i++) {
// Print statement
System.out.println("Miss");
// Making thread to sleep using sleep() method
// Try catch block for exceptions
try {
Thread.sleep(1000);
}
catch (Exception e) {
}
}
}
}
// Class 3
// Main class
public class GFG {
// Method 3
// Main method
public static void main(String[] args)
{
// Creating objects in the main() method
Shot obj1 = new Shot();
Miss obj2 = new Miss();
// Starting the thread objects
// using start() method
// start() method calls the run() method
// automatically
obj1.start();
obj2.start();
}
}
Output:
Case 1:
Shot
Shot
Shot
Shot
Shot
Miss
Miss
Miss
Miss
Miss
Case 2: V ideo output
Shot
Shot
Shot
Shot
Shot
Miss
Miss
Miss
Miss
Miss
Case 3: Video output
Shot
Miss
Shot
Miss
Shot
Miss
Shot
Miss
Shot
Miss
Note: There is no priority been set for threads for which as per the order of execution of threads outputs will vary so do remember this drawback of multithreading of different outputs leading to data inconsistency issues which we will be discussing in-depth in the later part under synchronization in threads.
Priorities in Threads
Priorities in threads is a concept where each thread is having a priority which is represented by numbers ranging from 1 to 10.
- The default priority is set to 5 as excepted.
- Minimum priority is set to 1.
- Maximum priority is set to 10.
Here 3 constants are defined in it namely as follows:
- public static int NORM_PRIORITY
- public static int MIN_PRIORITY
- public static int MAX_PRIORITY
Let us discuss it with an example to get how internally the work is getting executed. Here we will be using the knowledge gathered above as follows:
- We will use currentThread() method to get the name of the current thread. User can also use setName() method if he/she wants to make names of thread as per choice for understanding purposes.
- getName() method will be used to get the name of the thread.
Java
// Java Program to illustrate Priority Threads
// Case 1: No priority is assigned (Default priority)
// Importing input output thread class
import java.io.*;
// Importing Thread class from java.util package
import java.util.*;
// Class 1
// Helper Class (Our thread class)
class MyThread extends Thread {
public void run()
{
// Printing the current running thread via getName()
// method using currentThread() method
System.out.println("Running Thread : "
+ currentThread().getName());
// Print and display the priority of current thread
// via currentThread() using getPriority() method
System.out.println("Running Thread Priority : "
+ currentThread().getPriority());
}
}
// Class 2
// Main Class
class GFG {
// Main driver method
public static void main(String[] args)
{
// Creating objects of MyThread(above class)
// in the main() method
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
// Case 1: Default Priority no setting
t1.start();
t2.start();
}
}
// Java Program to illustrate Priority Threads
// Case 2: NORM_PRIORITY
// Importing input output thread class
import java.io.*;
// Importing Thread class from java.util package
import java.util.*;
// Class 1
// Helper Class (Our thread class)
class MyThread extends Thread {
// run() method to transit thread from
// runnable to run state
public void run()
{
// Printing the current running thread via getName()
// method using currentThread() method
System.out.println("Running Thread : "
+ currentThread().getName());
// Print and display the priority of current thread
// via currentThread() using getPriority() method
System.out.println("Running Thread Priority : "
+ currentThread().getPriority());
}
}
// Class 2
// Main Class
class GFG {
// Main driver method
public static void main(String[] args)
{
// Creating objects of MyThread(above class)
// in the main() method
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
// Setting priority to thread via NORM_PRIORITY
// which set priority to 5 as default thread
t1.setPriority(Thread.NORM_PRIORITY);
t2.setPriority(Thread.NORM_PRIORITY);
// Setting default priority using
// NORM_PRIORITY
t1.start();
t2.start();
}
}
// Java Program to illustrate Priority Threads
// Case 3: MIN_PRIORITY
// Importing input output thread class
import java.io.*;
// Importing Thread class from java.util package
import java.util.*;
// Class 1
// Helper Class (Our thread class)
class MyThread extends Thread {
// run() method to transit thread from
// runnable to run state
public void run()
{
// Printing the current running thread via getName()
// method using currentThread() method
System.out.println("Running Thread : "
+ currentThread().getName());
// Print and display the priority of current thread
// via currentThread() using getPriority() method
System.out.println("Running Thread Priority : "
+ currentThread().getPriority());
}
}
// Class 2
// Main Class
class GFG {
// Main driver method
public static void main(String[] args)
{
// Creating objects of MyThread(above class)
// in the main() method
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
// Setting priority to thread via NORM_PRIORITY
// which set priority to 1 as least priority thread
t1.setPriority(Thread.MIN_PRIORITY);
t2.setPriority(Thread.MIN_PRIORITY);
// Setting default priority using
// NORM_PRIORITY
t1.start();
t2.start();
}
}
// Java Program to illustrate Priority Threads
// Case 4: MAX_PRIORITY
// Importing input output thread class
import java.io.*;
// Importing Thread class from java.util package
import java.util.*;
// Class 1
// Helper Class (Our thread class)
class MyThread extends Thread {
// run() method to transit thread from
// runnable to run state
public void run()
{
// Printing the current running thread via getName()
// method using currentThread() method
System.out.println("Running Thread : "
+ currentThread().getName());
// Print and display the priority of current thread
// via currentThread() using getPriority() method
System.out.println("Running Thread Priority : "
+ currentThread().getPriority());
}
}
// Class 2
// Main Class
class GFG {
// Main driver method
public static void main(String[] args)
{
// Creating objects of MyThread(above class)
// in the main() method
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
// Setting priority to thread via MAX_PRIORITY
// which set priority to 10 as most priority thread
t1.setPriority(Thread.MAX_PRIORITY);
t2.setPriority(Thread.MAX_PRIORITY);
// Setting default priority using
// MAX_PRIORITY
// Starting the threads using start() method
// which automatically invokes run() method
t1.start();
t2.start();
}
}
Output:
Case 1: Default Priority
Running Thread : Thread-0
Running Thread : Thread-1
Running Thread Priority : 5
Running Thread Priority : 5
Case 2: NORM_PRIORITY
Running Thread : Thread-0
Running Thread : Thread-1
Running Thread Priority : 5
Running Thread Priority : 5
Case 3: MIN_PRIORITY
Running Thread : Thread-0
Running Thread : Thread-1
Running Thread Priority : 1
Running Thread Priority : 1
Case 4: MAX_PRIORITY
Running Thread : Thread-1
Running Thread : Thread-0
Running Thread Priority : 10
Running Thread Priority : 10
Output Explanation :
If we look carefully we do see the outputs for cases 1 and 2 are equivalent. This signifies that when the user is not even aware of the priority threads still NORM_PRIORITY is showcasing the same result as to what default priority is. It is because the default priority of running thread as soon as the corresponding start() method is called is executed as per setting priorities for all the thread to 5 which is equivalent to the priority of NORM case. This is because both the outputs are equivalent to each other. While in case 3 priority is set to a minimum on a scale of 1 to 10 so do the same in case 4 where priority is assigned to 10 on the same scale.
Hence, all the outputs in terms of priorities are justified. Now let us move ahead onto an important aspect of priority threading been incorporated in daily life - Daemon thread
Daemon thread is basically a service provider thread that provides services to the user thread. The scope for this thread start() or be it terminate() is completely dependent on the user's thread as it supports in the backend for user threads being getting run. As soon as the user thread is terminated daemon thread is also terminated at the same time as being the service provider thread.
Hence, the characteristics of the Daemon thread are as follows:
- It is only the service provider thread not responsible for interpretation in user threads.
- So, it is a low-priority thread.
- It is a dependent thread as it has no existence on its own.
- JVM terminates the thread as soon as user threads are terminated and come back into play as the user's thread starts.
- Yes, you guess the most popular example is garbage collector in java. Some other examples do include 'finalizer'.
Exceptions: IllegalArgumentException as return type while setting a Daemon thread is boolean so do apply carefully.
Note: To get rid of the exception users thread should only start after setting it to daemon thread. The other way of starting prior setting it to daemon will not work as it will pop-out IllegalArgumentException
As discussed above in the Thread class two most widely used method is as follows:
| Daemon Thread Methods | Action Performed |
|---|
| isDaemon() | It checks whether the current thread is a daemon thread or not |
| setDaemon() | It set the thread to be marked as daemon thread |
Let us discuss the implementation of the Daemon thread before jumping onto the garbage collector.
Java
// Java Program to show Working of Daemon Thread
// with users threads
import java.io.*;
// Importing Thread class from java.util package
import java.util.*;
// Class 1
// Helper Class extending Thread class
class CheckingMyDaemonThread extends Thread {
// Method
// run() method which is invoked as soon as
// thread start via start()
public void run()
{
// Checking whether the thread is daemon thread or
// not
if (Thread.currentThread().isDaemon()) {
// Print statement when Daemon thread is called
System.out.println(
"I am daemon thread and I am working");
}
else {
// Print statement whenever users thread is
// called
System.out.println(
"I am user thread and I am working");
}
}
}
// Class 2
// Main Class
class GFG {
// Main driver method
public static void main(String[] args)
{
// Creating threads in the main body
CheckingMyDaemonThread t1
= new CheckingMyDaemonThread();
CheckingMyDaemonThread t2
= new CheckingMyDaemonThread();
CheckingMyDaemonThread t3
= new CheckingMyDaemonThread();
// Setting thread named 't2' as our Daemon thread
t2.setDaemon(true);
// Starting all 3 threads using start() method
t1.start();
t2.start();
t3.start();
// Now start() will automatically
// invoke run() method
}
}
// Java Program to show Working of Daemon Thread
// with users threads where start() is invoked
// prior before setting thread to Daemon
import java.io.*;
// Basically we are importing Thread class
// from java.util package
import java.util.*;
// Class 1
// Helper Class extending Thread class
class CheckingMyDaemonThread extends Thread {
// Method
// run() method which is invoked as soon as
// thread start via start()
public void run()
{
// Checking whether the thread is daemon thread or
// not
if (Thread.currentThread().isDaemon()) {
// Print statement when Daemon thread is called
System.out.println(
"I am daemon thread and I am working");
}
else {
// Print statement whenever users thread is
// called
System.out.println(
"I am user thread and I am working");
}
}
}
// Class 2
// Main Class
class GFG {
// Method
// Main driver method
public static void main(String[] args)
{
// Creating threads objects of above class
// in the main body
CheckingMyDaemonThread t1
= new CheckingMyDaemonThread();
CheckingMyDaemonThread t2
= new CheckingMyDaemonThread();
CheckingMyDaemonThread t3
= new CheckingMyDaemonThread();
// Starting all 3 threads using start() method
t1.start();
t2.start();
t3.start();
// Now start() will automatically invoke run()
// method
// Now at last setting already running thread 't2'
// as our Daemon thread will throw an exception
t2.setDaemon(true);
}
}
Another way to achieve the same is through Thread Group in which as the name suggests multiple threads are treated as a single object and later on all the operations are carried on over this object itself aiding in providing a substitute for the Thread Pool.
Note:
While implementing ThreadGroup do note that ThreadGroup is a part of ' java.lang.ThreadGroup' class not a part of Thread class in java so do peek out constructors and methods of ThreadGroup class before moving ahead keeping a check over deprecated methods in his class so as not to face any ambiguity further.
Here main() method in itself is a thread because of which you do see Exception in main() while running the program because of which system.main thread exception is thrown sometimes while execution of the program.
Synchronization
It is the mechanism that bounds the access of multiple threads to share a common resource hence is suggested to be useful where only one thread at a time is granted the access to run over.
It is implemented in the program by using ' synchronized ' keyword.
Now let's finally discuss some advantages and disadvantages of synchronization before implementing the same. For more depth in synchronization, one can also learn object level lock and class level lock and do notice the differences between two to get a fair understanding of the same before implementing the same.
Why Synchronization is Required?
- Data inconsistency issues are the primary issue where multiple threads are accessing the common memory which sometimes results in faults in order to avoid that a thread is overlooked by another thread if it fails out.
- Data integrity
- To work with a common shared resource which is very essential in the real world such as in banking systems.
Note: Do not go for synchronized keyword unless it is most needed, remember this as there is no priority setup for threads, so if the main thread runs before or after other thread the output of the program would be different.
The biggest advantage of synchronization is the increase in idiotic resistance as one can not choose arbitrarily an object to lock on as a result string literal can not be locked or be the content. Hence, these bad practices are not possible to perform on synchronized method block.
As we have seen humongous advantages and get to know how important it is but there comes disadvantage with it.
Disadvantage: Performance issues will arise as during the execution of one thread all the other threads are put to a blocking state and do note they are not in waiting state . This causes a performance drop if the time taken for one thread is too long.
multi-tasking
As perceived from the image in which we are getting that count variable being shared resource is updating randomly. It is because of multithreading for which this concept becomes a necessity.
- Case 1: If ' main thread' executes first then count will be incremented followed by a ' thread T' in synchronization
- Case 2: If ' thread T ' executes first then count will not increment followed by ' main thread ' in synchronization
Implementation: Let us take a sample program to observe this 0 1 count conflict
Example:
Java
// Java Program to illustrate Output Conflict between
// Execution of Main thread vs Thread created
// count = 1 if main thread executes first
// count = 1 if created thread executes first
// Importing basic required libraries
import java.io.*;
import java.util.*;
// Class 1
// Helper Class extending Thread class
class MyThread extends Thread {
// Declaring and initializing initial count to zero
int count = 0;
// Method 1
// To increment the count above by unity
void increment() { count++; }
// Method 2
// run method for thread invoked after
// created thread has started
public void run()
{
// Call method in this method
increment();
// Print and display the count
System.out.println("Count : " + count);
}
}
// Class 2
public class GFG {
// Main driver method
public static void main(String[] args)
{
// Creating the above our Thread class object
// in the main() method
MyThread t1 = new MyThread();
// start() method to start execution of created
// thread that will look for run() method
t1.start();
}
}
Output:
Output Explanation:
Here the count is incremented to 1 meaning ' main thread ' has executed prior to ' created thread '. We have run it many times and compiled and run once again wherein all cases here main thread is executing faster than created thread but do remember output may vary. Our created thread can execute prior to ' main thread ' leading to 'Count : 0' as an output on the console.
Now another topic that arises in dealing with synchronization in threads is Thread safety in java synchronization is the new concept that arises out in synchronization so let us discuss it considering
- A real-life scenario followed by
- Pictorial representation as an illustration followed by
- Technically description and implementation
Real-life Scenario
Suppose a person is withdrawing some amount of money from the bank and at the same time the ATM card registered with the same account number is carrying on withdrawal operation by some other user. Now suppose if withdrawing some amount of money from net banking makes funds in account lesser than the amount which needed to be withdrawal or the other way. This makes the bank unsafe as more funds are debited from the account than was actually present in the account making the bank very unsafe and is not seen in daily life. So what banks do is that they only let one transaction at a time. Once it is over then another is permitted.
Illustration:
Interpreting the same technology as there are two different processes going on which object in case of parallel execution is over headed by threads. Now possessing such traits over threads such that they should look after for before execution or in simpler words making them synchronized. This mechanism is referred to as Thread Safe with the use of the keyword ' synchronized ' before the common shared method/function to be performed parallel.
Technical Description:
As we know Java has a feature, Multithreading , which is a process of running multiple threads simultaneously. When multiple threads are working on the same data, and the value of our data is changing, that scenario is not thread-safe, and we will get inconsistent results. When a thread is already working on an object and preventing another thread from working on the same object, this process is called Thread-Safety. Now there are several ways to achieve thread-safety in our program namely as follows:
- Using Synchronization
- Using Volatile Keyword
- Using Atomic Variable
- Using Final Keyword
Conclusion: Hence, if we are accessing one thread at a time then we can say thread-safe program and if multiple threads are getting accessed then the program is said to be thread-unsafe that is one resource at a time can not be shared by multiple threads at a time.
Implementation:
- Java Program to illustrate Incomplete Thread Iterations returning counter value to Zero irrespective of iteration bound
- Java Program to Illustrate Complete Thread Iterations illustrating join() Method
- Java Program to Illustrate thread-unsafe or non-synchronizing programs as of incomplete iterations
- Java Program to Illustrate Thread Safe And synchronized Programs as of Complete iterations using ' synchronized ' Keyword.
Examples
Java
// Example 1
// Java Program to illustrate Incomplete Thread Iterations
// Returning Counter Value to Zero
// irrespective of iteration bound
// Importing input output classes
import java.io.*;
// Class 1
// Helper Class
class TickTock {
// Member variable of this class
int count;
// Method of this Class
// It increments counter value whenever called
public void increment()
{
// Increment count by unity
// i.e count = count + 1;
count++;
}
//
}
// Class 2
// Synchronization demo class
// Main Class
class GFG {
// Main driver method
public static void main(String[] args) throws Exception
{
// Creating an object of class TickTock in main()
TickTock tt = new TickTock();
// Now, creating an thread object
// using Runnable interface
Thread t1 = new Thread(new Runnable() {
// Method
// To begin the execution of thread
public void run()
{
// Expression
for (int i = 0; i < 10000; i++) {
// Calling object of above class
// in main() method
tt.increment();
}
}
});
// Making above thread created to start
// via start() method which automatically
// calls run() method in Ticktock class
t1.start();
// Print and display the count
System.out.println("Count : " + tt.count);
}
}
// Example 2
// Java Program to Illustrate Complete Thread Iterations
// illustrating join() Method
// Importing input output classes
import java.io.*;
// Class 1
// Helper Class
class TickTock {
// Member variable of this class
int count;
// Method of this Class
public void increment()
{
// Increment count by unity
// whenever this function is called
count++;
}
}
// Class 2
// Synchronization demo class
// Main Class
class GFG {
// Main driver method
public static void main(String[] args) throws Exception
{
// Creating an object of class TickTock in main()
TickTock tt = new TickTock();
// Now, creating an thread object
// using Runnable interface
Thread t1 = new Thread(new Runnable() {
// Method
// To begin the execution of thread
public void run()
{
// Expression
for (int i = 0; i < 1000; i++) {
// Calling object of above class
// in main() method
tt.increment();
}
}
});
// Making above thread created to start
// via start() method which automatically
// calls run() method
t1.start();
// Now we are making main() thread to wait so
// that thread t1 completes it job
// using join() method
t1.join();
// Print and display the count value
System.out.println("Count : " + tt.count);
}
}
// Example 3
// Java Program to Illustrate Thread Unsafe Or
// Non-synchronizing Programs as of Incomplete Iterations
// Without using 'synchronized' program
// Importing input output classes
import java.io.*;
// Class 1
// Helper Class
class TickTock {
// Member variable of this class
int count;
// Method of this Class
public void increment()
{
// Increment count by unity
count++;
}
}
// Class 2
// Synchronization demo class
// Main Class
class GFG {
// Main driver method
public static void main(String[] args) throws Exception
{
// Creating an object of class TickTock in main()
TickTock tt = new TickTock();
// Now, creating an thread object
// using Runnable interface
Thread t1 = new Thread(new Runnable() {
// Method
// To begin the execution of thread
public void run()
{
// Expression
for (int i = 0; i < 100000; i++) {
// Calling object of above class
// in main() method
tt.increment();
}
}
});
// Now creating another thread and lets check
// how they increment count value running parallelly
// Thread 2
Thread t2 = new Thread(new Runnable() {
// Method
// To begin the execution of thread
public void run()
{
// Expression
for (int i = 0; i < 100000; i++) {
// Calling object of above class
// in main() method
tt.increment();
}
}
});
// Making above thread created to start
// via start() method which automatically
// calls run() method
t1.start();
t2.start();
// Now we are making main() thread to wait so
// that thread t1 completes it job
t1.join();
t2.join();
// Print and display the count
System.out.println("Count : " + tt.count);
}
}
// Example 4
// Java Program to Illustrate Thread Safe And
// Synchronized Programs as of Complete Iterations
// using 'synchronized' Keyword
// Importing input output classes
import java.io.*;
// Class 1
// helper Class
class TickTock {
// Member variable of this class
int count;
// Method of this Class
public synchronized void increment()
{
// Increment count by unity
count++;
}
//
}
// Class 2
// Synchronization demo class
// Main Class
class GFG {
// Main driver method
public static void main(String[] args) throws Exception
{
// Creating an object of class TickTock in main()
TickTock tt = new TickTock();
// Now, creating an thread object
// using Runnable interface
Thread t1 = new Thread(new Runnable() {
// Method
// To begin the execution of thread
public void run()
{
// Expression
for (int i = 0; i < 100000; i++) {
// Calling object of above class
// in main() method
tt.increment();
}
}
});
// Thread 2
Thread t2 = new Thread(new Runnable() {
// Method
// To begin the execution of thread
public void run()
{
// Expression
for (int i = 0; i < 100000; i++) {
// Calling object of above class
// in main() method
tt.increment();
}
}
});
// Making above thread created to start
// via start() method which automatically
// calls run() method
t1.start();
t2.start();
// Now we are making main() thread to wait so
// that thread t1 completes it job
t1.join();
t2.join();
// Print and display the count
System.out.println("Count : " + tt.count);
}
}
Output:
Case 1
Count : 0
Case 2
Count : 10000
Case 3
Count : 151138
Case 4
Count : 200000
Output Explanation:
In case 1 we can see that count is zero as initialized. Now we have two threads main thread and the thread t1. So there are two threads so now what happens sometimes instance is shared among both of the threads.
In case 1 both are accessing the count variable where we are directly trying to access thread via thread t1.count which will throw out 0 always as we need to call it with the help of object to perform the execution.
Now we have understood the working of synchronization is a thread that is nothing but referred to as a term Concurrency in java which in layman language is executing multiple tasks. Let us depict concurrency in threads with the help of a pictorial illustration.
Consider the task of multiplying an array of elements by a multiplier of 2. Now if we start multiplying every element randomly wise it will take a serious amount of time as every time the element will be searched over and computer. By far we have studied multithreading above in which we have concluded to a single line that thread is the backbone of multithreading.
So incorporating threads in the above situation as the machine is quad-core we here take 4 threads for every core where we divide the above computing sample set to (1/4) th resulting out in 4x faster computing. If in the above scenario it had taken 4 seconds then now it will take 1 second only. This mechanism of parallel running threads in order to achieve faster and lag-free computations is known as concurrency.
Note: Go for multithreading always for concurrent execution and if not using this concept go for sequential execution despite having bigger chunks of code as safety to our code is the primary issue.
Conclusion
Understanding Java Multithreading is important for creating fast and efficient applications. By using multithreading, you can run multiple tasks at the same time, making your programs more responsive and powerful. Key ideas like thread synchronization, concurrent collections, and the executor framework help manage multiple threads safely. In the above article we have described all details about Java multithreading.
Similar Reads
Java Tutorial Java is a high-level, object-oriented programming language used to build web apps, mobile applications, and enterprise software systems. It is known for its Write Once, Run Anywhere capability, which means code written in Java can run on any device that supports the Java Virtual Machine (JVM).Java s
10 min read
Basics
Introduction to JavaJava is a high-level, object-oriented programming language developed by Sun Microsystems in 1995. It is platform-independent, which means we can write code once and run it anywhere using the Java Virtual Machine (JVM). Java is mostly used for building desktop applications, web applications, Android
4 min read
How to Install Java on Windows, Linux and macOS?Java is a versatile programming language widely used for building applications. To start coding in Java, you first need to install the Java Development Kit (JDK) on your system. This article provides detailed steps for installing Java on Windows 7, 8, 10, 11, Linux Ubuntu, and macOS.Download and Ins
5 min read
Differences Between JDK, JRE and JVMUnderstanding the difference between JDK, JRE, and JVM plays a very important role in understanding how Java works and how each component contributes to the development and execution of Java applications. The main difference between JDK, JRE, and JVM is:JDK: Java Development Kit is a software develo
3 min read
Java IdentifiersAn identifier in Java is the name given to Variables, Classes, Methods, Packages, Interfaces, etc. These are the unique names used to identify programming elements. Every Java Variable must be identified with a unique name.Example:public class Test{ public static void main(String[] args) { int a = 2
2 min read
Java KeywordsIn Java, keywords are the reserved words that have some predefined meanings and are used by the Java compiler for some internal process or represent some predefined actions. These words cannot be used as identifiers such as variable names, method names, class names, or object names. Now, let us go t
5 min read
Java VariablesIn Java, variables are containers that store data in memory. Understanding variables plays a very important role as it defines how data is stored, accessed, and manipulated.Key Components of Variables in Java:A variable in Java has three components, which are listed below:Data Type: Defines the kind
9 min read
Java OperatorsJava operators are special symbols that perform operations on variables or values. These operators are essential in programming as they allow you to manipulate data efficiently. They can be classified into different categories based on their functionality. In this article, we will explore different
15 min read
Decision Making in Java (if, if-else, switch, break, continue, jump)Decision-making statements in Java execute a block of code based on a condition. Decision-making in programming is similar to decision-making in real life. In programming, we also face situations where we want a certain block of code to be executed when some condition is fulfilled.A programming lang
10 min read
Java LoopsLooping in programming languages is a feature that facilitates the execution of a set of instructions repeatedly while some condition evaluates to true. Java provides three ways for executing the loops. While all the ways provide similar basic functionality, they differ in their syntax and condition
7 min read
Java MethodsJava Methods are blocks of code that perform a specific task. A method allows us to reuse code, improving both efficiency and organization. All methods in Java must belong to a class. Methods are similar to functions and expose the behavior of objects.Example: Java program to demonstrate how to crea
8 min read
How to Call a Method in Java?In Java, calling a method helps us to reuse code and helps everything be organized. Java methods are just a block of code that does a specific task and gives us the result back. In this article, we are going to learn how to call different types of methods in Java with simple examples.What is a Metho
3 min read
Static Method vs Instance Method in JavaIn Java, methods are mainly divided into two parts based on how they are connected to a class, which are the static method and the Instance method. The main difference between static and instance methods is listed below:Static method: A static method is a part of the class and can be called without
4 min read
Access Modifiers in JavaIn Java, access modifiers are essential tools that define how the members of a class, like variables, methods, and even the class itself can be accessed from other parts of our program. They are an important part of building secure and modular code when designing large applications. Understanding de
7 min read
Command Line Arguments in JavaJava command-line argument is an argument, i.e., passed at the time of running the Java program. In Java, the command line arguments passed from the console can be received in the Java program, and they can be used as input. The users can pass the arguments during the execution, bypassing the comman
3 min read
Variable Arguments (Varargs) in JavaIn Java, Variable Arguments (Varargs) write methods that can take any number of inputs, which simply means we do not have to create more methods for different numbers of parameters. This concept was introduced in Java 5 to make coding easier. Instead of passing arrays or multiple methods, we can sim
5 min read
Arrays in JavaArrays in Java are one of the most fundamental data structures that allow us to store multiple values of the same type in a single variable. They are useful for storing and managing collections of data. Arrays in Java are objects, which makes them work differently from arrays in C/C++ in terms of me
15+ min read
How to Declare and Initialize an Array in Java?An array in Java is a linear data structure that is used to store multiple values of the same data type. In an array, each element has a unique index value, which makes it easy to access individual elements. We first need to declare the size of an array because the size of the array is fixed in Java
5 min read
Java Multi-Dimensional ArraysMultidimensional arrays are used to store the data in rows and columns, where each row can represent another individual array are multidimensional array. It is also known as array of arrays. The multidimensional array has more than one dimension, where each row is stored in the heap independently. T
10 min read
Jagged Array in JavaIn Java, a Jagged array is an array that holds other arrays. When we work with a jagged array, one thing to keep in mind is that the inner array can be of different lengths. It is like a 2D array, but each row can have a different number of elements.Example:arr [][]= { {10,20}, {30,40,50,60},{70,80,
6 min read
Arrays Class in JavaThe Arrays class in java.util package is a part of the Java Collection Framework. This class provides static methods to dynamically create and access Java arrays. It consists of only static methods and the methods of an Object class. The methods of this class can be used by the class name itself.The
15 min read
Final Arrays in JavaIn Java, final is a keyword that is used to make a variable constant. Once we declare a variable as final, its value can not be changed throughout the program. But when we use final with an array, it is a bit different thing. Final applies to the reference, not the contents. This means we cannot rea
4 min read
Java StringsIn Java, a String is the type of object that can store a sequence of characters enclosed by double quotes, and every character is stored in 16 bits, i.e., using UTF 16-bit encoding. A string acts the same as an array of characters. Java provides a robust and flexible API for handling strings, allowi
9 min read
Why Java Strings are Immutable?In Java, strings are immutable means their values cannot be changed once they are created. This feature enhances performance, security, and thread safety. In this article, we are going to learn why strings are immutable in Java and how this benefits Java applications.What Does Immutable Mean?When we
4 min read
Java String concat() Method with ExamplesThe string concat() method concatenates (appends) a string to the end of another string. It returns the combined string. It is used for string concatenation in Java. It returns NullPointerException if any one of the strings is Null.In this article, we will learn how to concatenate two strings in Jav
4 min read
String Class in JavaA string is a sequence of characters. In Java, objects of the String class are immutable, which means they cannot be changed once created. In this article, we are going to learn about the String class in Java.Example of String Class in Java:Java// Java Program to Create a String import java.io.*; cl
7 min read
StringBuffer Class in JavaThe StringBuffer class in Java represents a sequence of characters that can be modified, which means we can change the content of the StringBuffer without creating a new object every time. It represents a mutable sequence of characters.Features of StringBuffer ClassThe key features of StringBuffer c
11 min read
Java StringBuilder ClassIn Java, the StringBuilder class is a part of the java.lang package that provides a mutable sequence of characters. Unlike String (which is immutable), StringBuilder allows in-place modifications, making it memory-efficient and faster for frequent string operations.Declaration:StringBuilder sb = new
7 min read
String vs StringBuilder vs StringBuffer in JavaA string is a sequence of characters. In Java, String objects are immutable, which simply means once created, their values can not be changed. In Java, String, StringBuilder, and StringBuffer are used for handling strings. The main difference is:String: Immutable, meaning its value cannot be changed
6 min read
Regular Expressions in JavaIn Java, Regular Expressions or Regex (in short) in Java is an API for defining String patterns that can be used for searching, manipulating, and editing a string in Java. Email validation and passwords are a few areas of strings where Regex is widely used to define the constraints. Regular Expressi
7 min read
Java Pattern pattern() Methodpattern() method of the Pattern class in Java is used to get the regular expression which is compiled to create this pattern. We use a regular expression to create the pattern and this method is used to get the same source expression. Example 1: Using the pattern() method to check the regex pattern
2 min read
Java Matcher pattern() MethodThe pattern() method of the Matcher class is used to get the pattern to be matched by this matcher.Example 1: The below example demonstrates how the pattern() method retrieves the regex pattern "G.*s$" used to match a string ending with "s" and starting with "G".Java// Java code to illustrate patter
2 min read
java.lang.Character Class Methods | Set 1java.lang.Character Class wraps the value of a primitive data type char to an object of datatype Character. This object contains a single field having the data type char. This class provides several methods regarding character manipulations like converting them from lowercase to uppercase. Character
6 min read
Java QuantifiersQuantifiers in Java allow users to specify the number of occurrences to match against. These are used with regular expressions to specify the number of times a particular pattern or character can appear in the Input. Below are some commonly used quantifiers in Java.QuantifiersDescriptionX*Zero or mo
5 min read
OOPs & Interfaces
Java OOP(Object Oriented Programming) ConceptsJava Object-Oriented Programming (OOPs) is a fundamental concept in Java that every developer must understand. It allows developers to structure code using classes and objects, making it more modular, reusable, and scalable.The core idea of OOPs is to bind data and the functions that operate on it,
13 min read
Classes and Objects in JavaIn Java, classes and objects are basic concepts of Object Oriented Programming (OOPs) that are used to represent real-world concepts and entities. The class represents a group of objects having similar properties and behavior, or in other words, we can say that a class is a blueprint for objects, wh
11 min read
Java ConstructorsIn Java, constructors play an important role in object creation. A constructor is a special block of code that is called when an object is created. Its main job is to initialize the object, to set up its internal state, or to assign default values to its attributes. This process happens automaticall
10 min read
Object Class in JavaObject class in Java is present in java.lang package. Every class in Java is directly or indirectly derived from the Object class. If a class does not extend any other class then it is a direct child class of the Java Object class and if it extends another class then it is indirectly derived. The Ob
7 min read
Abstraction in JavaAbstraction in Java is the process of hiding the implementation details and only showing the essential details or features to the user. It allows to focus on what an object does rather than how it does it. The unnecessary details are not displayed to the user.Key features of abstraction:Abstraction
10 min read
Encapsulation in JavaIn Java, encapsulation is one of the coret concept of Object Oriented Programming (OOP) in which we bind the data members and methods into a single unit. Encapsulation is used to hide the implementation part and show the functionality for better readability and usability. The following are important
10 min read
Inheritance in JavaJava Inheritance is a fundamental concept in OOP(Object-Oriented Programming). It is the mechanism in Java by which one class is allowed to inherit the features(fields and methods) of another class. In Java, Inheritance means creating new classes based on existing ones. A class that inherits from an
13 min read
Polymorphism in JavaPolymorphism in Java is one of the core concepts in object-oriented programming (OOP) that allows objects to behave differently based on their specific class type. The word polymorphism means having many forms, and it comes from the Greek words poly (many) and morph (forms), this means one entity ca
7 min read
Method Overloading in JavaIn Java, Method Overloading allows us to define multiple methods with the same name but different parameters within a class. This difference may include:The number of parametersThe types of parametersThe order of parametersMethod overloading in Java is also known as Compile-time Polymorphism, Static
10 min read
Overriding in JavaOverriding in Java occurs when a subclass or child class implements a method that is already defined in the superclass or base class. When a subclass provides its own version of a method that is already defined in its superclass, we call it method overriding. The subclass method must match the paren
15 min read
Java PackagesPackages in Java are a mechanism that encapsulates a group of classes, sub-packages, and interfaces. Packages are used for: Prevent naming conflicts by allowing classes with the same name to exist in different packages, like college.staff.cse.Employee and college.staff.ee.Employee.They make it easie
8 min read
Java InterfaceAn Interface in Java programming language is defined as an abstract type used to specify the behaviour of a class. An interface in Java is a blueprint of a behaviour. A Java interface contains static constants and abstract methods. Key Properties of Interface:The interface in Java is a mechanism to
12 min read
Interfaces and Inheritance in JavaJava supports inheritance and interfaces, which are important concepts for building reusable code. A class can extend another class and can implement one and more than one Java interface. Note: This topic has a major influence on the concept of Java and Multiple Inheritance. Interface Implementation
7 min read
Java Class vs InterfacesIn Java, the difference between a class and an interface is syntactically similar; both contain methods and variables, but they are different in many aspects. The main difference is, A class defines the state of behaviour of objects.An interface defines the methods that a class must implement.Class
5 min read
Java Functional InterfacesA functional interface in Java is an interface that contains only one abstract method. Functional interfaces can have multiple default or static methods, but only one abstract method. Runnable, ActionListener, and Comparator are common examples of Java functional interfaces. From Java 8 onwards, lam
7 min read
Nested Interface in JavaIn Java, we can declare interfaces as members of a class or another interface. Such an interface is called a member interface or nested interface. Interfaces declared outside any class can have only public and default (package-private) access specifiers. In Java, nested interfaces (interfaces declar
5 min read
Marker Interface in JavaIn Java, a marker Interface is an empty interface that has no fields or methods. It is used just to mark or tag a class to tell Java or other programs something special about that class. These interfaces do not have any methods inside but act as metadata to provide information about the class. Examp
4 min read
Java Comparator InterfaceThe Comparator interface in Java is used to sort the objects of user-defined classes. The Comparator interface is present in java.util package. This interface allows us to define custom comparison logic outside of the class for which instances we want to sort. The comparator interface is useful when
7 min read
Collections
Collections in JavaAny group of individual objects that are represented as a single unit is known as a Java Collection of Objects. In Java, a separate framework named the "Collection Framework" has been defined in JDK 1.2 which holds all the Java Collection Classes and Interface in it. In Java, the Collection interfac
15+ min read
Collections Class in JavaCollections class in Java is one of the utility classes in the Java Collections Framework. The java.util package contains the Collections class in Java. The Java Collections class is used with the static methods that operate on the collections or return the collection. All the methods of this class
13 min read
Collection Interface in JavaThe Collection interface in Java is a core member of the Java Collections Framework located in the java.util package. It is one of the root interfaces of the Java Collection Hierarchy. The Collection interface is not directly implemented by any class. Instead, it is implemented indirectly through it
6 min read
Java List InterfaceThe List Interface in Java extends the Collection Interface and is a part of the java.util package. It is used to store the ordered collections of elements. In a Java List, we can organize and manage the data sequentially. Key Features:Maintained the order of elements in which they are added.Allows
15+ min read
ArrayList in JavaJava ArrayList is a part of the collections framework and it is a class of java.util package. It provides us with dynamic-sized arrays in Java. The main advantage of ArrayList is that, unlike normal arrays, we don't need to mention the size when creating ArrayList. It automatically adjusts its capac
9 min read
LinkedList in JavaLinked List is a part of the Collection framework present in java.util package. This class is an implementation of the LinkedList data structure, which is a linear data structure where the elements are not stored in contiguous locations, and every element is a separate object with a data part and an
12 min read
Set in JavaThe Set Interface is present in java.util package and extends the Collection interface. It is an unordered collection of objects in which duplicate values cannot be stored. It is an interface that implements the mathematical set. This interface adds a feature that restricts the insertion of duplicat
14 min read
Java HashSetHashSet in Java implements the Set interface of Collections Framework. It is used to store the unique elements and it doesn't maintain any specific order of elements. Can store the Null values.Uses HashMap (implementation of hash table data structure) internally.Also implements Serializable and Clon
12 min read
TreeSet in JavaTreeSet is one of the most important implementations of the SortedSet interface in Java that uses a Tree(red - black tree) for storage. The ordering of the elements is maintained by a set using their natural ordering whether or not an explicit comparator is provided. This must be consistent with equ
13 min read
Queue Interface In JavaThe Queue Interface is a part of java.util package and extends the Collection interface. It stores and processes the data in order means elements are inserted at the end and removed from the front. Key Features:Most implementations, like PriorityQueue, do not allow null elements.Implementation Class
11 min read
PriorityQueue in JavaThe PriorityQueue class in Java is part of the java.util package. It implements a priority heap-based queue that processes elements based on their priority rather than the FIFO (First-In-First-Out) concept of a Queue.Key Points:The PriorityQueue is based on the Priority Heap. The elements of the pri
9 min read
Deque Interface in JavaDeque Interface present in java.util package is a subtype of the queue interface. The Deque is related to the double-ended queue that supports adding or removing elements from either end of the data structure. It can either be used as a queue(first-in-first-out/FIFO) or as a stack(last-in-first-out/
9 min read
Map Interface in JavaIn Java, the Map Interface is part of the java.util package and represents a mapping between a key and a value. The Java Map interface is not a subtype of the Collections interface. So, it behaves differently from the rest of the collection types.Key Features:No Duplicates in Keys: Keys should be un
11 min read
HashMap in JavaIn Java, HashMap is part of the Java Collections Framework and is found in the java.util package. It provides the basic implementation of the Map interface in Java. HashMap stores data in (key, value) pairs. Each key is associated with a value, and you can access the value by using the corresponding
15+ min read
Java IteratorAn Iterator in Java is an interface used to traverse elements in a Collection sequentially. It provides methods like hasNext(), next(), and remove() to loop through collections and perform manipulation. An Iterator is a part of the Java Collection Framework, and we can use it with collections like A
6 min read
Java Comparator InterfaceThe Comparator interface in Java is used to sort the objects of user-defined classes. The Comparator interface is present in java.util package. This interface allows us to define custom comparison logic outside of the class for which instances we want to sort. The comparator interface is useful when
7 min read
Java Comparable InterfaceThe Comparable interface in Java is used to define the natural ordering of objects for a user-defined class. It is part of the java.lang package and it provides a compareTo() method to compare instances of the class. A class has to implement a Comparable interface to define its natural ordering.Exam
4 min read
Exception Handling
Java Exception HandlingException handling in Java allows developers to manage runtime errors effectively by using mechanisms like try-catch block, finally block, throwing Exceptions, Custom Exception handling, etc. An Exception is an unwanted or unexpected event that occurs during the execution of a program, i.e., at runt
10 min read
Java Checked vs Unchecked ExceptionsIn Java, an exception is an unwanted or unexpected event that occurs during the execution of a program, i.e., at run time, that disrupts the normal flow of the program’s instructions. In Java, there are two types of exceptions:Checked Exception: These exceptions are checked at compile time, forcing
5 min read
Java Try Catch BlockA try-catch block in Java is a mechanism to handle exceptions. This make sure that the application continues to run even if an error occurs. The code inside the try block is executed, and if any exception occurs, it is then caught by the catch block.Example: Here, we are going to handle the Arithmet
4 min read
Java final, finally and finalizeIn Java, the final, finally, and finalize keywords play an important role in exception handling. The main difference between final, finally, and finalize is listed below:final: The final is the keyword that can be used for immutability and restrictions in variables, methods, and classes.finally: The
4 min read
throw and throws in JavaIn Java, exception handling is one of the effective means to handle runtime errors so that the regular flow of the application can be preserved. It handles runtime errors such as NullPointerException, ArrayIndexOutOfBoundsException, etc. To handle these errors effectively, Java provides two keywords
5 min read
User-Defined Custom Exception in JavaIn Java, an Exception is an issue (run-time error) that occurs during the execution of a program. When an exception occurs, the program terminates abruptly, and the code beyond the exception never gets executed.Java provides us the facility to create our own exceptions by extending the Exception cla
3 min read
Chained Exceptions in JavaChained Exceptions in Java allow associating one exception with another, i.e. one exception describes the cause of another exception. For example, consider a situation in which a method throws an ArithmeticException because of an attempt to divide by zero.But the root cause of the error was an I/O f
3 min read
Null Pointer Exception in JavaA NullPointerException in Java is a RuntimeException. It occurs when a program attempts to use an object reference that has the null value. In Java, "null" is a special value that can be assigned to object references to indicate the absence of a value.Reasons for Null Pointer ExceptionA NullPointerE
5 min read
Exception Handling with Method Overriding in JavaIn Java, an exception is an unwanted or unexpected event that occurs during a program's execution, i.e., at runtime, and disrupts the normal flow of the program’s instructions. Exception handling in Java handles runtime errors and helps maintain the program's normal flow by using constructs like try
5 min read
Java Advanced
Java Multithreading TutorialThreads are the backbone of multithreading. We are living in the real world which in itself is caught on the web surrounded by lots of applications. With the advancement in technologies, we cannot achieve the speed required to run them simultaneously unless we introduce the concept of multi-tasking
15+ min read
Java ThreadsJava threads are lightweight subprocesses, representing the smallest unit of execution with separate paths. The main advantage of multiple threads is efficiency (allowing multiple things at the same time). For example, in MS Word, one thread automatically formats the document while another thread is
11 min read
Java Thread ClassThread is a line of execution within a program. Each program can have multiple associated threads. Each thread has a priority which is used by the thread scheduler to determine which thread must run first. Java provides a thread class that has various method calls to manage the behavior of threads b
5 min read
Java Runnable Interfacejava.lang.Runnable is an interface that is to be implemented by a class whose instances are intended to be executed by a thread. There are two ways to start a new Thread - Subclass Thread and implement Runnable. There is no need to subclass a Thread when a task can be done by overriding only the run
3 min read
Lifecycle and States of a Thread in JavaA thread in Java can exist in any one of the following states at any given time. A thread lies only in one of the shown states at any instant:New StateRunnable StateBlocked StateWaiting StateTimed Waiting StateTerminated StateThe diagram below represents various states of a thread at any instant:Lif
5 min read
Main thread in JavaJava provides built-in support for multithreaded programming. A multi-threaded program contains two or more parts that can run concurrently. Each part of such a program is called a thread, and each thread defines a separate path of execution.When a Java program starts up, one thread begins running i
4 min read
Java Thread Priority in MultithreadingJava being Object-Oriented works within a Multithreading environment in which the thread scheduler assigns the processor to a thread based on the priority of the thread. Whenever we create a thread in Java, it always has some priority assigned to it. Priority can either be given by JVM while creatin
5 min read
Java Naming a Thread and Fetching Name of Current ThreadA thread can be referred to as a lightweight process. Assigning descriptive names to threads enhances code readability and simplifies debugging. Now let us discuss the different ways to name a thread in Java.Methods to Set the Thread NameThere are two ways by which we can set the name either be it d
4 min read
Java Thread.start() vs Thread.run() MethodIn Java's multi-threading concept, start() and run() are the two most important methods. In this article, we will learn the main differences between Thread.start() and Thread.run() in Java. Thread.start() vs Thread.run() MethodThread.start()Thread.run()Creates a new thread and the run() method is ex
4 min read
Java Thread.sleep() MethodThread class contains the sleep() method. There are two overloaded methods of sleep() method present in Thread Class, one is with one argument and another one is with two arguments. The sleep() method is used to stop the execution of the current thread (whichever might be executing in the system) fo
3 min read
Java Daemon ThreadIn Java, daemon threads are low-priority threads that run in the background to perform tasks such as garbage collection or provide services to user threads. The life of a daemon thread depends on the mercy of user threads, meaning that when all user threads finish their execution, the Java Virtual M
5 min read
Java Thread Safety and How to Achieve it?As we know Java has a feature, Multithreading, which is a process of running multiple threads simultaneously. When multiple threads are working on the same data, and the value of our data is changing, that scenario is not thread-safe and we will get inconsistent results. When a thread is already wor
5 min read
Thread Pools in JavaBackground Server Programs such as database and web servers repeatedly execute requests from multiple clients and these are oriented around processing a large number of short tasks. An approach for building a server application would be to create a new thread each time a request arrives and service
9 min read
Synchronization in JavaIn multithreading, synchronization is important to make sure multiple threads safely work on shared resources. Without synchronization, data can become inconsistent or corrupted if multiple threads access and modify shared variables at the same time. In Java, it is a mechanism that ensures that only
10 min read
Importance of Thread Synchronization in JavaThread synchronization in Java is important for managing shared resources in a multithreaded environment. It ensures that only one thread can access a shared resource at a time, which enhances the overall system performance and prevents race conditions and data corruption.Why is Thread Synchronizati
8 min read
Java Method and Block SynchronizationIn Java, Synchronization is very important in concurrent programming when multiple threads need to access shared resources. Java Synchronization can be applied to methods and blocks. Method synchronization in Java locks the entire method and Block synchronization locks only a specific section of the
6 min read
Java Atomic vs Volatile vs SynchronizedIn Java, multithreading can lead to challenges related to thread safety and data consistency. Java provides concurrency mechanisms like Atomic, Volatile, and Synchronized to address these issues and ensure thread safety. These mechanisms offer unique advantages and limitations.Atomic vs Volatile vs
5 min read
Java Lock Framework vs Thread SynchronizationIn Java, thread synchronization is achieved using the Lock framework which is present in the java.util.concurrent package. Synchronization ensures that only one thread can access a resource at a time by preventing issues like data corruption or inconsistency. Java offers two primary mechanisms for a
4 min read
Deadlock in Java MultithreadingDeadlock occurs in Java when multiple threads block each other while waiting for locks held by one another. To prevent deadlocks, we can use the synchronized keyword to make methods or blocks thread-safe which means only one thread can have the lock of the synchronized method and use it, other threa
4 min read
Deadlock Prevention And AvoidanceDeadlock prevention and avoidance are strategies used in computer systems to ensure that different processes can run smoothly without getting stuck waiting for each other forever. Think of it like a traffic system where cars (processes) must move through intersections (resources) without getting int
5 min read
Difference Between Lock and Monitor in Java ConcurrencyJava Concurrency deals with concepts like Multithreading and other concurrent operations. To manage shared resources effectively, tools like Locks (Mutex) and Monitors are used to ensure thread synchronization and avoid race conditions. Locks represent a low-level synchronization mechanism and Monit
5 min read
ReentrantLock in JavaReentrantLock in Java is a part of the java.util.concurrent package that helps to achieve synchronization more effectively and optimally compared to the traditional Synchronized keyword. It offers features like,TimeoutsInterruptible locksMore control over Thread SchedulingThese features make it a va
6 min read
File Handling in JavaIn Java, with the help of File Class, we can work with files. This File Class is inside the java.io package. The File class can be used to create an object of the class and then specifying the name of the file.Why File Handling is Required?File Handling is an integral part of any programming languag
6 min read
Java File ClassJava File class is a representation of a file or directory pathname. Because file and directory names have different formats on different platforms, a simple string is not adequate to name them. Java File class contains several methods for working with the pathname, deleting and renaming files, crea
6 min read
Java Program to Create a New FileThere are two standard methods to create a new file, either directly with the help of the File class or indirectly with the help of the FileOutputStream class by creating an object of the file in both approaches.Methods to Create Files in JavaThere are two methods mentioned belowUsing the File Class
4 min read
Different ways of Reading a text file in JavaThere are multiple ways of writing and reading a text file in Java. this is required while dealing with many applications. There are several ways to read a plain text file in Java e.g. you can use FileReader, BufferedReader, or Scanner to read a text file. Every utility provides something special e.
6 min read
Java Program to Write into a FileFileWriter class in Java is used to write character-oriented data to a file as this class is character-oriented because it is used in file handling in Java. There are many ways to write into a file in Java as there are many classes and methods which can fulfill the goal as follows:Using writeString(
5 min read
Delete a File Using JavaJava provides methods to delete files programmatically. In contrast to normal delete operations in any operating system, files being deleted using the Java program are deleted permanently without being moved to the trash/recycle bin. Example: A basic program to delete the file from a static path.Jav
2 min read
Java FileReader ClassFileReader in Java is a class in the java.io package which can be used to read a stream of characters from the files. Java IO FileReader class uses either specified charset or the platform's default charset for decoding from bytes to characters.1. Charset: The Charset class is used to define methods
3 min read
Java FileWriter ClassJava FileWriter class of the java.io package is used to write data in character form to a file. The FileWriter class in Java is used to write character-oriented data to a file. It is a character-oriented class that is used for file handling in Java.This Class inherits from OutputStreamWriter class w
5 min read
Java FilePermission Classjava.io.FilePermission class represents access to a file or directory. These accesses are in the form of a path name and a set of actions associated with the path name(specifies which file to open along with the extension and the path).Example: In FilePermission("GEEKS.txt", "read") "GEEKS.txt" is t
3 min read
Java FileDescriptor Classjava.io.FileDescriptor class in Java works for opening a file having a specific name. If there is any content present in that file it will first erase all that content and put "Beginning of Process" as the first line. Instances of the file descriptor class serve as an opaque handle to the underlying
4 min read
Java IO - Input/Output in Java with ExamplesJava provides various Streams with its I/O package that helps the user to perform all the input-output operations. These streams support all the types of objects, data-types, characters, files, etc., to fully execute the I/O operations. The image below demonstrates the flow of data from a source to
6 min read
Java Reader ClassReader class in Java is an abstract class used for reading character streams. It serves as the base class for various subclasses like FileReader, BufferedReader, CharArrayReader, and others, which provide more efficient implementations of the read() method. To work with the Reader class, we must ext
6 min read
Java Writer ClassJava writer class is an abstract class in the java.io package. It is designed for writing character streams. Writer class in Java provides methods for writing characters, arrays of characters, and strings. Since it is an abstract class, we cannot create an instance of it directly. Instead, we will u
5 min read
Java FileInputStream ClassFileInputStream class in Java is useful for reading data from a file in the form of a Java sequence of bytes. FileInputStream is meant for reading streams of raw bytes such as image data. For reading streams of characters, consider using FileReader.Example: FileInputStream class to read data from fi
4 min read
FileOutputStream in JavaIn Java, the FileOutputStream class is a subclass of OutputStream. It is used to write data to a file as a stream of bytes. FileOutputStream is commonly employed for writing primitive values into a file. FileOutputStream supports writing both byte-oriented and character-oriented data.Note: FileWrite
7 min read
Ways to Read Input from Console in JavaIn Java, there are four different ways to read input from the user in the command line environment(console). 1. Using Buffered Reader ClassBuffered Reader Class is the classical method to take input, Introduced in JDK 1.0. This method is used by wrapping the System.in (standard input stream) in an I
5 min read
Java BufferedOutputStream ClassBufferedOutputStream class in Java is a part of the java.io package. It improves the efficiency of writing data to an output stream by buffering the data. This reduces the number of direct writes to the underlying output stream, making the process faster and more efficient.Example 1: The below Java
2 min read
Java BufferedReader vs Scanner ClassJava provides several classes for reading input, but two of the most commonly used are Scanner and BufferedReader. The main difference between Scanner and BufferedReader is:Scanner class provides parsing and input reading capabilities with built-in methods for different data types.BufferedReader cla
2 min read
Fast I/O in Java in Competitive ProgrammingIn competitive programming, fast input and output (I/O) are essential to avoid time limit exceeded (TLE) errors. Java can be slower for I/O tasks, but there are different ways to speed it up. Using methods like BufferedReader, Scanner, and custom input classes, we can improve the performance of our
6 min read
Java Lambda ExpressionsLambda expressions in Java, introduced in Java SE 8. It represents the instances of functional interfaces (interfaces with a single abstract method). They provide a concise way to express instances of single-method interfaces using a block of code.Key Functionalities of Lambda ExpressionLambda Expre
5 min read
Java Method ReferencesIn Java, a method is a collection of statements that perform some specific task and return the result to the caller. A method reference is the shorthand syntax for a lambda expression that contains just one method call. In general, one does not have to pass arguments to method references.Why Use Met
9 min read
Java 8 Stream TutorialJava 8 introduces Stream, which is a new abstract layer, and some new additional packages in Java 8 called java.util.stream. A Stream is a sequence of components that can be processed sequentially. These packages include classes, interfaces, and enum to allow functional-style operations on the eleme
15+ min read
Java 8 Features - Complete TutorialJava 8 is the most awaited release of the Java programming language development because, in the entire history of Java, it has never released that many major features. It consists of major features of Java. It is a new version of Java and was released by Oracle on 18 March 2014. Java provided suppor
9 min read
Java NetworkingWhen computing devices such as laptops, desktops, servers, smartphones, and tablets and an eternally-expanding arrangement of IoT gadgets such as cameras, door locks, doorbells, refrigerators, audio/visual systems, thermostats, and various sensors are sharing information and data with each other is
15+ min read
TCP/IP ModelThe TCP/IP model (Transmission Control Protocol/Internet Protocol) is a four-layer networking framework that enables reliable communication between devices over interconnected networks. It provides a standardized set of protocols for transmitting data across interconnected networks, ensuring efficie
7 min read
User Datagram Protocol (UDP)User Datagram Protocol (UDP) is a Transport Layer protocol. UDP is a part of the Internet Protocol suite, referred to as UDP/IP suite. Unlike TCP, it is an unreliable and connectionless protocol. So, there is no need to establish a connection before data transfer. The UDP helps to establish low-late
10 min read
Difference Between IPv4 and IPv6In the digital world, where billions of devices connect and communicate, Internet Protocol (IP) Addresses play a crucial role. These addresses are what allow devices to identify and locate each other on a network.To know all about IP Addresses - refer to What is an IP Address?Currently, there are tw
9 min read
Difference Between Connection-oriented and Connection-less ServicesIn computer networks, communication between devices occurs using two types of services: connection-oriented and connectionless. These services define how data is transferred between a source and a destination. Connection-oriented services establish a dedicated connection before data transfer, ensuri
5 min read
Socket Programming in JavaSocket programming in Java allows different programs to communicate with each other over a network, whether they are running on the same machine or different ones. This article describes a very basic one-way Client and Server setup, where a Client connects, sends messages to the server and the serve
6 min read
Java ServerSocket ClassServerSocket Class in Java provides a system-independent way to implement the server side of a client/server socket connection. The constructor for ServerSocket throws an exception if it can’t listen on the specified port (for example, the port is already being used).In the java.nio channel, ServerS
4 min read
Java URL ClassURL class in Java is a part of java.net package that makes it easy to work with Uniform Resource Locators (URLs). URL is simply a string of text that identifies all the resources on the internet, telling us the address of the resource, how to communicate with it, and retrieve something from it. This
4 min read
JDBC (Java Database Connectivity)JDBC is an API that helps applications to communicate with databases, it allows Java programs to connect to a database, run queries, retrieve, and manipulate data. Because of JDBC, Java applications can easily work with different relational databases like MySQL, Oracle, PostgreSQL, and more.JDBC Arc
5 min read
JDBC DriversJava Database Connectivity (JDBC) is an application programming interface (API) for the Java programming language that defines how a client can access and interact with any kind of tabular data, especially a relational database. JDBC Drivers uses JDBC APIs which was developed by Sun Microsystem, but
4 min read
Establishing JDBC Connection in JavaBefore Establishing a JDBC Connection in Java (the front end, i.e., your Java Program, and the back end, i.e., the database), we should learn what precisely a JDBC is and why it came into existence. Now, let us discuss what exactly JDBC stands for and why it is essential, and how to establish a data
7 min read
Types of Statements in JDBCIn Java, the Statement interface in JDBC (Java Database Connectivity) is used to create and execute SQL queries in Java applications. JDBC provides three types of statements to interact with the database:StatementPrepared StatementCallable Statement1. StatementA Statement object is used for general-
5 min read
Java Memory ManagementJava memory management is a fundamental concept that involves the automatic allocation and deallocation of objects, managed by the Java Virtual Machine (JVM). The JVM uses a garbage collector to automatically remove unused objects, freeing up memory in the background. This eliminates the need for de
5 min read
How are Java Objects Stored in Memory?In Java, memory management is handled by the Java Virtual Machine (JVM). The breakdown of how objects are stored in memory:All Java objects are dynamically stored in the heap memory.References to these objects are stored in the stack memory.Objects are created using the "new" keyword and are allocat
5 min read
Stack vs Heap Memory AllocationIn C, C++, and Java, memory can be allocated on either a stack or a heap. Stack allocation happens in the function call stack, where each function gets its own memory for variables. In C/C++, heap memory is controlled by programmer as there is no automatic garbage collection.Stack AllocationStack al
7 min read
Java Virtual Machine (JVM) Stack AreaThe Java Virtual Machine is responsible for running Java applications, and it manages various memory areas, one of which is the Stack Area. In this article, we are going to discuss about JVM Stack Area in depth.JVM Stack AreaIn Java, each thread has its own stack called the Run-Time Stack, created w
5 min read
How Many Types of Memory Areas are Allocated by JVM?JVM (Java Virtual Machine) is an abstract machine. In other words, it is a program/software that takes Java bytecode and converts the bytecode (line by line) into machine-understandable code. JVM acts as a run-time engine to run Java applications. JVM is the one that calls the main method present in
4 min read
Garbage Collection in JavaGarbage collection in Java is an automatic memory management process that helps Java programs run efficiently. Java programs compile to bytecode that can be run on a Java Virtual Machine (JVM). When Java programs run on the JVM, objects in the heap are created, which is a portion of memory dedicated
7 min read
JVM Garbage CollectorsJVM Garbage Collectors are essential for Java memory management. It automatically frees up unused memory to prevent memory leaks and improve performance. Java manages memory through the Java Virtual Machine using a process called garbage collection. Garbage collection automatically frees up memory b
5 min read
Stack vs Heap Memory AllocationIn C, C++, and Java, memory can be allocated on either a stack or a heap. Stack allocation happens in the function call stack, where each function gets its own memory for variables. In C/C++, heap memory is controlled by programmer as there is no automatic garbage collection.Stack AllocationStack al
7 min read
Memory Leaks in JavaIn programming, a memory leak happens when a program keeps using memory but does not give it back when it's done. It simply means the program slowly uses more and more memory, which can make things slow and even stop working. Working of Memory Management in JavaJava has automatic garbage collection,
3 min read
Practice Java
Java Interview Questions and AnswersJava is one of the most popular programming languages in the world, known for its versatility, portability, and wide range of applications. Java is the most used language in top companies such as Uber, Airbnb, Google, Netflix, Instagram, Spotify, Amazon, and many more because of its features and per
15+ min read
Java Multiple Choice QuestionsJava is a widely used high-level, general-purpose, object-oriented programming language and platform that was developed by James Gosling in 1982. Java Supports WORA(Write Once, Run Anywhere) also, it defined as 7th most popular programming language in the world.Java language is a high-level, multi-t
3 min read
Java Programs - Java Programming ExamplesIn this article, we will learn and prepare for Interviews using Java Programming Examples. From basic Java programs like the Fibonacci series, Prime numbers, Factorial numbers, and Palindrome numbers to advanced Java programs.Java is one of the most popular programming languages today because of its
8 min read
Java Exercises - Basic to Advanced Java Practice Programs with SolutionsLooking for Java exercises to test your Java skills, then explore our topic-wise Java practice exercises? Here you will get 25 plus practice problems that help to upscale your Java skills. As we know Java is one of the most popular languages because of its robust and secure nature. But, programmers
7 min read
Java Quiz | Level Up Your Java SkillsThe best way to scale up your coding skills is by practicing the exercise. And if you are a Java programmer looking to test your Java skills and knowledge? Then, this Java quiz is designed to challenge your understanding of Java programming concepts and assess your excellence in the language. In thi
4 min read
Top 50 Java Project Ideas For Beginners and Advanced [Update 2025]Java is one of the most popular and versatile programming languages, known for its reliability, security, and platform independence. Developed by James Gosling in 1982, Java is widely used across industries like big data, mobile development, finance, and e-commerce.Building Java projects is an excel
15+ min read
Number Guessing Game in JavaA number-guessing game in Java is a simple program where the computer randomly selects a number, and the user has to guess it within a limited number of attempts. The program provides feedback on whether the guessed number is too high or too low, guiding the user toward the correct answer.This proje
4 min read
Mini Banking Application in JavaIn any Bank Transaction, there are several parties involved to process transaction like a merchant, bank, receiver, etc. so there are several numbers reasons that transaction may get failed, declined, so to handle a transaction in Java, there is a JDBC (Java Database Connectivity) which provides us
7 min read
Java Program to Convert Currency using AWTSwing is a part of the JFC (Java Foundation Classes). Building a Graphical User Interface in Java requires the use of Swings. Swing Framework contains a large set of components that allow a high level of customization and provide rich functionalities and is used to create window-based applications.
4 min read
Tic-Tac-Toe Game in JavaTic-Tac-Toe is a classic game that two people can enjoy together. It is played on a 3x3 grid where players take turns placing their marks, X or O, in empty spots. The main goal is to get three of the same marks in a row-horizontally, vertically, or diagonally.In this article, we are going to build a
7 min read
Design Snake GameLet us see how to design a basic Snake Game that provides the following functionalities: Snake can move in a given direction and when it eats the food, the length of snake increases. When the snake crosses itself, the game will be over. Food will be generated at a given interval.Asked In: Amazon, Mi
9 min read
Memory Game in JavaThe Memory Game is a fun and simple two-player game that tests your memory. In this game, a set of cards is laid face down. Players take turns flipping two cards to find matching pairs. If the two cards match, they remain face up. If not, they are flipped back down. The game continues until all pair
5 min read
How to Implement a Simple Chat Application Using Sockets in Java?In this article, we will create a simple chat application using Java socket programming. Before we are going to discuss our topic, we must know Socket in Java. Java Socket connects two different JREs (Java Runtime Environment). Java sockets can be connection-oriented or connection-less. In Java, we
4 min read
Image Processing in Java - Face DetectionPrerequisites: Image Processing in Java - Read and WriteImage Processing In Java - Get and Set PixelsImage Processing in Java - Colored Image to Grayscale Image ConversionImage Processing in Java - Colored Image to Negative Image ConversionImage Processing in Java - Colored to Red Green Blue Image C
3 min read
Design Media Sharing Social Networking SystemPURPOSE OF MEDIA SOCIAL NETWORKING SERVICE SYSTEMThis system will allow users to share photos and videos with other users. Additionally, users can follow other users based on follow request and they can see other user's photos and videos. In this system, you can search users and see their profile if
14 min read
Java Swing | Create a simple text editorTo create a simple text editor in Java Swing we will use a JTextArea, a JMenuBar and add JMenu to it and we will add JMenuItems. All the menu items will have actionListener to detect any action.There will be a menu bar and it will contain two menus and a button:Â File menuopen: this menuitem is used
6 min read