Active object

<h2 id="example">Example</h2>
<h3>Java</h3>
<p>An example of active object pattern in <a href="/facts/Java_(programming_language)/9ScgFyAL">Java</a>.<a class="footnote-ref" id="fnref:4" href="#fn:4"><sup>4</sup></a>
</p><p>Firstly we can see a standard class that provides two methods that set a double to be a certain value. This class does NOT conform to the active object pattern.
</p>
class MyClass {

private double val = 0.0;
    
    void doSomething() {
        val = 1.0;
    }

void doSomethingElse() {
        val = 2.0;
    }
}

<p>The class is dangerous in a multithreading scenario because both methods can be called simultaneously, so the value of val (which is not atomic—it's updated in multiple steps) could be undefined—a classic race condition. You can, of course, use synchronization to solve this problem, which in this trivial case is easy. But once the class becomes realistically complex, synchronization can become very difficult. <a class="footnote-ref" id="fnref:5" href="#fn:5"><sup>5</sup></a>
</p><p>To rewrite this class as an active object, you could do the following:
</p>
class MyActiveObject {

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

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

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

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

<h3>Java 8 (alternative)</h3>
<p>Another example of active object pattern in Java instead implemented in Java 8 providing a shorter solution.
</p>
public class MyClass {
    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(() -> { val = 1.0; });
    }
 
    // implementation of active object method
    public void doSomethingElse() throws InterruptedException {
        fj.execute(() -> { val = 2.0; });
    }
}

<h2 id="see-also">See also</h2>
<ul><li><a href="/facts/Concurrent_object-oriented_programming/N1q7h9Gs">Concurrent object-oriented programming</a></li>
<li><a href="/facts/Actor_model/MJ49opnU">Actor model</a></li>
<li><a href="/facts/Futures_and_promises/5Mpgxv4m">Futures and promises</a></li>
<li><a href="/facts/Live_distributed_object/HMP2Wbgm">Live distributed object</a></li></ul>

<h2 id="external-links">External links</h2>
<ul><li><a href="https://www.hummingbirdcode.net/">Ultra-high performance middleware based on Disruptor Active Object in C++14</a></li>
<li><a href="https://github.com/lightful/syscpp/">Active Object implementation in C++11</a></li></ul>

<h2 id="references">References</h2>

<ol>
<li id="fn:1"><p>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. <a href="0-471-60695-2" target="_blank">0-471-60695-2</a> <a href="#fnref:1" class="footnote-back-ref">↩</a></p></li>
<li id="fn:2"><p>Bass, L., Clements, P., Kazman, R. Software Architecture in Practice. Addison Wesley, 2003 <a href="#fnref:2" class="footnote-back-ref">↩</a></p></li>
<li id="fn:3"><p>Lavender, R. Greg; Schmidt, Douglas C. "Active Object" (PDF). Archived from the original (PDF) on 2012-07-22. Retrieved 2007-02-02. <a href="https://web.archive.org/web/20120722180050/http://www.cs.wustl.edu/%7Eschmidt/PDF/Act-Obj.pdf" target="_blank">https://web.archive.org/web/20120722180050/http://www.cs.wustl.edu/%7Eschmidt/PDF/Act-Obj.pdf</a> <a href="#fnref:3" class="footnote-back-ref">↩</a></p></li>
<li id="fn:4"><p>Holub, Allen. "Java Active Objects - A Proposal". Archived from the original on 2013-06-22. Retrieved 2014-06-16. <a href="https://web.archive.org/web/20130622122643/http://pragprog.com/magazines/2013-05/java-active-objects" target="_blank">https://web.archive.org/web/20130622122643/http://pragprog.com/magazines/2013-05/java-active-objects</a> <a href="#fnref:4" class="footnote-back-ref">↩</a></p></li>
<li id="fn:5"><p>Holub, Allen. "Java Active Objects - A Proposal". Archived from the original on 2013-06-22. Retrieved 2014-06-16. <a href="https://web.archive.org/web/20130622122643/http://pragprog.com/magazines/2013-05/java-active-objects" target="_blank">https://web.archive.org/web/20130622122643/http://pragprog.com/magazines/2013-05/java-active-objects</a> <a href="#fnref:5" class="footnote-back-ref">↩</a></p></li>
</ol>

Active object open-in-new

Active object