Active object

From Infogalactic: the planetary knowledge core
(Redirected from Active Object)
Jump to: navigation, search

The active object design pattern decouples method execution from method invocation for objects that each reside in their own thread of control.[1] The goal is to introduce concurrency, by using asynchronous method invocation and a scheduler for handling requests.[2]

The pattern consists of six elements:[3]

  • A proxy, which provides an interface towards clients with publicly accessible methods.
  • An interface which defines the method request on an active object.
  • A list of pending requests from clients.
  • A scheduler, which decides which request to execute next.
  • The implementation of the active object method.
  • A callback or variable for the client to receive the result.

Example

Java

An example of active object pattern in Java.[4]

class OriginalClass
{
    private double val = 0.0;

    //
    void doSomething()
    {
        val = 1.0;
    }

    //
    void doSomethingElse()
    {
        val = 2.0;
    }
}

class BecomeActiveObject
{
    private double val = 0.0;
    private BlockingQueue<Runnable> dispatchQueue
            = new LinkedBlockingQueue<Runnable>();

    //
    public BecomeActiveObject()
    {
        new Thread(
                new Runnable()
                {
                    @Override
                    public void run()
                    {
                        while (true)
                        {
                            try
                            {
                                dispatchQueue.take().run();
                            } catch (InterruptedException e)
                            {   // okay, just terminate the dispatcher
                            }
                        }
                    }
                }
        ).start();
    }

    //
    void doSomething() throws InterruptedException
    {
        dispatchQueue.put(
                new Runnable()
                {
                    public void run() { val = 1.0; }
                }
        );
    }

    //
    void doSomethingElse() throws InterruptedException
    {
        dispatchQueue.put(
                new Runnable()
                {
                    public void run() { val = 2.0; }
                }
        );
    }
}

Java 8 (alternative)

Another example of active object pattern in Java.

public class AnotherActiveObject {
    private double val; 
    
    // container for tasks
    // decides which request to execute next 
    // asyncMode=true means our worker thread processes its local task queue in the FIFO order 
    // only single thread may modify internal state
    private final ForkJoinPool fj = new ForkJoinPool(1, ForkJoinPool.defaultForkJoinWorkerThreadFactory, null, true);
    
    // implementation of active object method
    public void doSomething() throws InterruptedException {
        fj.execute(new Runnable() {
            @Override
            public void run() {
                val = 1.0;
            }
        });
    }
 
    // implementation of active object method
    public void doSomethingElse() throws InterruptedException {
        fj.execute(new Runnable() {
            @Override
            public void run() {
                val = 2.0;
            }
        });
    }
}

See also

References

  1. Douglas C. Schmidt; Michael Stal; Hans Rohnert; Frank Buschmann (2000). Pattern-Oriented Software Architecture, Volume 2: Patterns for Concurrent and Networked Objects. John Wiley & Sons. ISBN 0-471-60695-2.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
  2. Bass, L., Clements, P., Kazman, R. Software Architecture in Practice. Addison Wesley, 2003
  3. Lavender, R. Greg; Schmidt, Douglas C. "Active Object" (PDF). Retrieved 2007-02-02.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
  4. Holub, Allen. "Java Active Objects - A Proposal". Retrieved 2014-06-16.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>

External links