Asynchronous Call in Java

In this article, we are going to study the Asynchronous call in the JAVA programming language. At the end of the article, we will get a clear picture of the Asynchronous call and how it differs from synchronous call in the JAVA programming language. Firstly, let us know what is a "CallBack" in the programming sense.

What is a CallBack in JAVA?

The CallBack keyword is used to define a function in JAVA programming along with many other programming languages. A CallBack function is an argument that is passed down into some other function. The CallBack function will be executed after the firing of a particular event in the given program. The true motive of a CallBack function is to inform a particular class about the status of a work in another class.

The CallBack function is useful when we are working on some Asynchronous tasks. The callback is also useful while making use of " Event Handling ", as it is used to provide some sort of notification when a button is clicked by the user on the interface. So, we can understand that a CallBack function plays an essential role while performing routine tasks in a program, such as performing various operations and fetching some data from the web. As for the implementation of a CallBack function in the JAVA programming language, it can be implemented using an interface. Let us see the standard procedure for the implementation of the CallBack function in JAVA programming.

A procedure that is followed for implementing the Callback function:

We start by defining the methods that are in an interface which we want to invoke after the CallBack.
In order to implement the CallBack methods of the interface, define a class.
To register the CallBack Interface, define a reference in some random class.
Make use of the defined reference to invoke the CallBack method.

Types of CallBack in Java

Synchronous call
Asynchronous call

What is a Synchronous call?

A call which will restrict a program from the execution of its code, and once the event returns a response or is complete, the call returns back from the event to the CallBack function is known as a Synchronous call. All the operations are performed by the callback before returning to the statement.

The Synchronous calls wait for the execution, so the time taken for the completion of the program is more than the actual time. We can find a significant time lag within these types of programs. The tasks in the Synchronous calls are executed sequentially. So, the user can use the Synchronous call when the problem must be completed in sequential order and when the problem does not require much time. The execution of the code is paused, and the code waits for the event before being resumed. In this way, the process of Synchronous calls takes place. Now let us understand a Synchronous call with the help of a program in JAVA.

Example2.java

// This is a program in JAVA for understanding 
// the implementation of " Asynchronous call ".

interface ExampleEventListener 
{
  
    // Any type of method 
    // can be defined below
    void exampleEvent();
}

// define a random class
// in which the main section is also 
// defined 
class Example2 
{
  
    private ExampleEventListener mListener; 
    // this is the listener field
  
    // Making the setup of Listener below using the public 
    // access and the void return data type

    public void registerexampleEventListener(ExampleEventListener mListener)
    {
        this.mListener = mListener;
    }
  
    // this is my synchronous task 
    // which is needed to be performed.
    public void myStuff()
    {
  
        // An Async task always executes within a new thread
        // so a new thread must be created in order to execute.

        System.out.print("The task that is being performed");
        System.out.println(" here is synchronous task");
  
        // Do check whether the 
        // listener is registered or not.
        if (this.mListener != null) 
        {
  
            // invoke the callback 
            // method of class Myclass
            mListener.exampleEvent();
        }
    }
    public static void main(String[] args)
    {
        Example2 obj = new Example2();
        ExampleEventListener mListener = new Myclass();
        obj.registerexampleEventListener(mListener);
        obj.myStuff();
    }
}
  
class Myclass implements ExampleEventListener 
{
  
    @Override
    public void exampleEvent()
    {
        System.out.print("Performing callback after ");
        System.out.print("the completion of Synchronous task");
        // perform any random routine operation
    }
    // some class Myclass methods
}

Output:

The task that is being performed here is synchronous task
Performing callback after the completion of Synchronous task

Explanation:

By getting to know the above program, we can understand the role of a Synchronous call using the CallBack method in the JAVA programming language. We can observe that every step that is discussed is involved within the above program. As mentioned above, we used the Event listener interface in the program.

When do we use Synchronous call?

We use Synchronous call in situations in which there are several tasks that are supposed to be performed in a particular order, one after the other involved within the program. The tasks that consume less time are also considered to be called under the Synchronous type.

What is an Asynchronous call?

A call which will not restrict a program from the execution of its code, and once the event is complete, the call returns back from the event to the CallBack function is known as an Asynchronous call. To avoid this, a new thread must be created, and the CallBack method should be invoked inside the thread in the JAVA programming context. It is not mandatory to invoke the CallBack method inside a thread. A CallBack may also create a new thread when invoked, thus making the call asynchronous.

The tasks in Asynchronous call are executed parallelly or simultaneously, i.e., if one task is executed at a particular time, the other task can also work within the same time without waiting for the completion of the previous task. So, the user or the programmer can use an Asynchronous call when the problem is very big, and the tasks must be completed parallelly in such a way that the tasks are not dependent on each other. The execution of the code is not asked to wait during this call. In this way, the process of Asynchronous call takes place. Now let us understand an Asynchronous call with the help of a program in JAVA.

// This is a program in JAVA for understanding the implementation of " Asynchronous call ".
interface examplecallEventListener {
// Any type of method can be defined below.
    void examplecallEvent();
}
class Example1 {

    private examplecallEventListener mListener; 
    // This is a Listener Field.

    // Making the setup of Listener below using the public access
    // and the void return data type
    public void registerexamplecallEventListener(examplecallEventListener mListener)
    {
        this.mListener = mListener;
    }
    // this is my asynchronous task which is needed to be performed.
    public void myStuff()
    {
        // An Async task always executes within a new thread
        // so a new thread must be created in order to execute.
        new Thread(new Runnable() {
            public void run()
            {
                // perform any kind of operations and print.
                System.out.println("This is Example and Tutorial here");
                // Do check whether the listener is registered or not.
                if (mListener != null) {

                    // invoke the callback method of class myclass
                    mListener.examplecallEvent();
                }
            }
        }).start();
    }
    public static void main(String[] args)
    {
        example1 obj = new example1();
        examplecallEventListener mListener = new myclass();
        obj.registerexamplecallEventListener(mListener);
        obj.myStuff();
    }
}

class myclass implements examplecallEventListener {

    @Override
    public void examplecallEvent()
    {
        System.out.println("Performing callback after the completion of an Async Task");
        // perform any of the routine operations
    }
    // some class myclass methods
}

Output:

This is Example and Tutorial here
Performing callback after the completion of an Async Task

Explanation

By getting to know the above program, we can understand the role of an Asynchronous call using the CallBack method in the JAVA programming language. We can observe that a new thread is created, and the CallBack is invoked inside this thread itself. As mentioned above, we made use of the Event listener interface in the program.

When do we use Asynchronous call?

We use Asynchronous call in situations in which the tasks that are involved within the program are not depending on each other so that the pause of execution in one task will not affect the other. The tasks that consume more time are also considered to be called under the Asynchronous type.

Next TopicMinimum Window Substring in Java

← prev next →