Aktív objektum

A Wikipédiából, a szabad enciklopédiából
Jump to navigation Jump to search

Az aktív objektum tervezési minta a végrehajtást és a metódus hívást szétválasztó minta,[1] aminek célja, hogy kiküszöbölje az objektumokkal járó önvezérlési hibákat, valamint, hogy segítse a kommunikáció során az asszinkron metódusmeghívást és ütemezze a beérkező kéréseket.[2]

A minta hat elemből áll:[3]

  • A proxyból, ami biztosítja az interfészeket a felhasználók felé, nyilvánosan hozzáférhető metódusokkal.
  • Az interfészből, amelyik leírja, hogy az aktív objektum mely metódusai hívhatók.
  • A felhasználók függőben lévő kérelmeinek a listájából.
  • Az ütemezőből, amelyik dönt, hogy legközelebb melyik kérelmet hajtsa végre.
  • A kivitelezőből, ami végrehajtja az aktív objektum metódust.
  • A változóból, amiből a felhasználók/ügyfelek kiolvashatják az eredményt.

Példa[szerkesztés]

Egy példa az aktív objektum mintáról, Java nyelven.[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 (alternatív)[szerkesztés]

Egy másik példa, szintén Java nyelven.

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;
            }
        });
    }
}

További információk[szerkesztés]

Fordítás[szerkesztés]

Ez a szócikk részben vagy egészben az Active object című angol Wikipédia-szócikk fordításán alapul. Az eredeti cikk szerkesztőit annak laptörténete sorolja fel.

  1. Douglas C. Schmidt. Pattern-Oriented Software Architecture, Volume 2: Patterns for Concurrent and Networked Objects. John Wiley & Sons (2000). ISBN 0-471-60695-2 
  2. Bass, L., Clements, P., Kazman, R. Software Architecture in Practice. Addison Wesley, 2003
  3. Lavender, R. Greg: Active Object (PDF). (Hozzáférés: 2007. február 2.)
  4. Holub, Allen: Java Active Objects - A Proposal. (Hozzáférés: 2014. június 16.)