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.
- Java threads and Interrupts in Java programming language
- Abstract classes and Generic function in Java
- Constructors in programming language
- Static components and constants concept in programming language
- Data encapsulation in programming language.
- Java threads and Interrupts in Java programming language
Posts
1 comments:
Thank you for your appreciation.
ReplyPost a Comment