co.paralleluniverse.actors.Actor Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of quasar-actors Show documentation
Fibers, Channels and Actors for the JVM
There is a newer version: 0.8.0
/*
 * Quasar: lightweight threads and actors for the JVM.
 * Copyright (C) 2013, Parallel Universe Software Co. All rights reserved.
 * 
 * This program and the accompanying materials are dual-licensed under
 * either the terms of the Eclipse Public License v1.0 as published by
 * the Eclipse Foundation
 *  
 *   or (per the licensee's choosing)
 *  
 * under the terms of the GNU Lesser General Public License version 3.0
 * as published by the Free Software Foundation.
 */
package co.paralleluniverse.actors;

import co.paralleluniverse.actors.ActorRefImpl.ActorLifecycleListener;
import co.paralleluniverse.common.monitoring.FlightRecorder;
import co.paralleluniverse.common.monitoring.FlightRecorderMessage;
import co.paralleluniverse.common.util.Debug;
import co.paralleluniverse.common.util.Objects;
import co.paralleluniverse.fibers.Fiber;
import co.paralleluniverse.fibers.FiberScheduler;
import co.paralleluniverse.fibers.Joinable;
import co.paralleluniverse.fibers.SuspendExecution;
import co.paralleluniverse.strands.Strand;
import co.paralleluniverse.strands.Stranded;
import co.paralleluniverse.strands.SuspendableCallable;
import co.paralleluniverse.strands.channels.ReceivePort;
import java.lang.reflect.Constructor;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import jsr166e.ConcurrentHashMapV8;

/**
 *
 * @author pron
 */
public abstract class Actor implements SuspendableCallable, Joinable, Stranded, ReceivePort {
    private static final Throwable NATURAL = new Throwable();
    private static final ThreadLocal currentActor = new ThreadLocal();
    private Strand strand;
    private final LocalActorRef ref;
    private final ActorRef wrapperRef;
    private final Set lifecycleListeners = Collections.newSetFromMap(new ConcurrentHashMapV8());
    private final Set observed = Collections.newSetFromMap(new ConcurrentHashMapV8());
    private volatile V result;
    private volatile RuntimeException exception;
    private volatile Throwable deathCause;
    private volatile Object globalId;
    private volatile ActorMonitor monitor;
    private ActorSpec spec;
    private Object aux;
    protected transient final FlightRecorder flightRecorder;

    @SuppressWarnings({"OverridableMethodCallInConstructor", "LeakingThisInConstructor"})
    public Actor(String name, MailboxConfig mailboxConfig) {
        this.ref = new LocalActorRef(this, name, new Mailbox(mailboxConfig));
        mailbox().setActor(this);
        this.flightRecorder = Debug.isDebug() ? Debug.getGlobalFlightRecorder() : null;
        this.wrapperRef = makeRef(ref);
    }

    protected ActorRef makeRef(ActorRef ref) {
        return ref;
    }

    public Actor(Strand strand, String name, MailboxConfig mailboxConfig) {
        this(name, mailboxConfig);
        if (strand != null)
            setStrand(strand);
    }

    public String getName() {
        return ref.getName();
    }

    public void setName(String name) {
        myRef().setName(name);
    }

    private ActorRefImpl myRef() {
        return ((ActorRefImpl) ref);
    }

    public ActorRef spawn(FiberScheduler scheduler) {
        new Fiber(getName(), scheduler, this).start();
        return ref();
    }

    public ActorRef spawn() {
        new Fiber(getName(), this).start();
        return ref();
    }

    public ActorRef spawnThread() {
        new Thread(Strand.toRunnable(this), getName()).start();
        return ref();
    }

    public static , Message, V> T newActor(Class clazz, Object... params) {
        return newActor(ActorSpec.of(clazz, params));
    }

    public static , Message, V> T newActor(ActorSpec spec) {
        return spec.build();
    }

    /**
     * '
     * Returns a "clone" of this actor, used by a {@link co.paralleluniverse.actors.behaviors.Supervisor supervisor} to restart this actor if it dies.
     * 
     * If this actor is supervised by a {@link co.paralleluniverse.actors.behaviors.Supervisor supervisor} and was not created with the
     * {@link #newActor(co.paralleluniverse.actors.ActorSpec) newActor} factory method, then this method should be overridden.
     *
     * @return A new LocalActor instance that's a clone of this.
     */
    protected Actor reinstantiate() {
        if (spec != null)
            return newActor(spec);
        else if (getClass().isAnonymousClass() && getClass().getSuperclass().equals(Actor.class))
            return newActor(createSpecForAnonymousClass());
        else
            throw new RuntimeException("Actor " + this + " cannot be reinstantiated");
    }

    private ActorSpec, Message, V> createSpecForAnonymousClass() {
        assert getClass().isAnonymousClass() && getClass().getSuperclass().equals(Actor.class);
        Constructor> ctor = (Constructor>) getClass().getDeclaredConstructors()[0];
        Object[] params = new Object[ctor.getParameterTypes().length];
        for (int i = 0; i < params.length; i++) {
            Class type = ctor.getParameterTypes()[i];
            if (String.class.equals(type))
                params[i] = getName();
            if (Integer.TYPE.equals(type))
                params[i] = mailbox().capacity();
            else
                params[i] = type.isPrimitive() ? 0 : null;
        }
        return new ActorSpec, Message, V>(ctor, params);
    }

    void setSpec(ActorSpec spec) {
        this.spec = spec;
    }

    Object getAux() {
        return aux;
    }

    void setAux(Object aux) {
        verifyInActor();
        this.aux = aux;
    }

    @Override
    public String toString() {
        String className = getClass().getSimpleName();
        if (className.isEmpty())
            className = getClass().getName().substring(getClass().getPackage().getName().length() + 1);
        return className + "@"
                + (getName() != null ? getName() : Integer.toHexString(System.identityHashCode(this)))
                + "[owner: " + systemToStringWithSimpleName(strand) + ']';
    }

    private static String systemToStringWithSimpleName(Object obj) {
        return (obj == null ? "null" : obj.getClass().getSimpleName() + "@" + Objects.systemObjectId(obj));
    }

    final void interrupt() {
        getStrand().interrupt();
    }

    public static  Actor currentActor() {
        final Fiber currentFiber = Fiber.currentFiber();
        if (currentFiber == null)
            return currentActor.get();
        final SuspendableCallable target = currentFiber.getTarget();
        if (target == null || !(target instanceof Actor))
            return null;
        return (Actor) target;
    }

    public ActorRef ref() {
        if (!isStarted())
            throw new IllegalStateException("Actor has not been started");
        return wrapperRef;
    }

    protected ActorRef self() {
        return ref();
    }

    @Override
    public final void setStrand(Strand strand) {
        if (strand == this.strand)
            return;
        if (this.strand != null)
            throw new IllegalStateException("Strand already set to " + strand);
        this.strand = strand;
        if (strand != null && getName() == null)
            setName(strand.getName());
        mailbox().setStrand(strand);
    }

    @Override
    public final Strand getStrand() {
        return strand;
    }

    //
    /////////// Mailbox methods ///////////////////////////////////
    public final int getQueueLength() {
        return mailbox().getQueueLength();
    }

    protected final Mailbox