Featured

    Featured Posts

Callback functions In Java Programming Language




      Java permits parallel execution. One function can invoke another function to run in a parallel thread. Unlike a conventional function call, where the calling function is suspended till the called function terminates and returns, in this case the calling function proceeds to the next statement after the function invocation, while the invoked function executes in parallel. This parallelism may be actual, such as on a multiprocessor machine, where each thread is assigned to a separate processor, or virtual, such as on a single processor, where the threads are interleaved artibrarily to simulate parallel execution.

     Suppose now that we have two classes, Myclass and Timer, where an object m of Myclass can create a Timer object t and invoke a function t.f() to run in parallel with m. Recall that we have assumed that m is not suspended after invoking t.f(). We would like a mechanism for t.f() to report back to m when it has completed its work. To do this, t needs to have a reference back to
m. This can be accomplished by passing the reference when we create t: each instance of Timer is created by an object and the instance of Timer remembers the identity of the object that created it. For instance, we might have:

class Myclass{
...
public void some_function(){
...
Timer t = new Timer(this); // Tell t that this object
// created t
...
t.f(); // Start off t.f() in parallel
...
}
...
}


We need the following complementary structure in Timer:

class Timer implements Runnable{   // Says that                                 Timer can be invoked
                        // in a parallel thread
private Object owner;
public Timer(Object o){       // Constructor
owner = o;               // Remember who created me
}
...
public void f(){
...
o.notify();        // Tell my creator that I’m done
}
...
}

      The problem with this definition is that the function o.notify() cannot be invoked as stated without casting o (which is an Object
) back to Myclass . Of course, we could fix this by changing the type of owner from Object to Myclass, but then we would have to write a
different Timer class for each type of owner.

      In order to define a generic Timer class, all we need is that the owner have a method called notify() and that there is a uniform way to cast the owner to a type that can access this method. This can be achieved via an interface, say

interface Timerowner{
public abstract void notify();
}

 

Now, we modify Myclass to implement Timerowner:

class Myclass implements Timerowner{
...
public void some_function(){
...
Timer t = new Timer(this); // Tell t that this                                  object
                          // created t
...
t.f();               // Start off t.f() in parallel
...
}
public void notify(){ ... } // Implement the interface
...
}

Finally, we modify Timer to insist that the owner of a Timer
object must implement Timerowner:

class Timer implements Runnable{ // Can be invoked                                      in a
                                // parallel thread
private Timerowner owner;   // Owner must implement Timerowner
public Timer(Timerowner o){   // Constructor
owner = o;               // Remember who created me
}
...
public void f(){
...
o.notify();        // Tell my creator that I’m done
}
...
}

Even though the timer t gets a reference to its parent object, the parent only “exposes” its Timerowner features to t.

2 comments

I appreciate you and I would like to read your next post.
Thanks for sharing this useful information.
SharePoint jobs in Hyderabad
SharePoint jobs in Chennai

Reply

Thank you for your appreciation.

Reply

Post a Comment

www.CodeNirvana.in

www.posthatke.com. Powered by Blogger.

Google+ Followers

Copyright © www.posthatke.com | Blogger Templates | Designed By posthatke.com