import co.paralleluniverse.fibers.FiberScheduler; //导入依赖的package包/类
/**
 * Record events in a separate Fiber using one or more Recorders.
 *
 * This method returns immediately after starting the Fiber for recording events.
 *
 * @param fiberName the name of the fiber that records events.
 * @param fe an optional scheduler for the spawned recording fiber, null to use the default.
 * @param rp a channel on which to receive TimingEvents, which are passed to the underlying
 *           Recorders.
 * @param rs zero or more Recorders, each of which receives every event (after the delay period)
 *           in the order they are passed to this method.
 * @param <T> the type of the Response object in each TimingEvent.
 */
@SafeVarargs
static <T> Fiber<Void> record(final String fiberName,
                              final FiberScheduler fe,
                              final ReceivePort<TimingEvent<T>> rp,
                              final Recorder<T>... rs)
{
  return new Fiber<Void>(fiberName, fe != null ? fe : DefaultFiberScheduler.getInstance(), () -> {
    while (true) {
      final TimingEvent<T> event = rp.receive();

      if (event == null) {
        break;
      }

      for (final Recorder<T> r : rs) {
        r.record(event);
      }
    }
    return null;
  }).start();
}
 

import co.paralleluniverse.fibers.FiberScheduler; //导入依赖的package包/类
/**
 * 产生一个纤程actor，并且使用指定的Handler来放入指定的调度器执行
 * @param fibSche 调度器
 * @param ah 可运行单元
 * @return 新Actor的Id
 */
@Suspendable
public ActorId spawn(FiberScheduler fibSche, final IFiberActorHandler ah){
	if (fibSche == null){
		throw new NullPointerException();
	}
	
	final Actor actor = makeActor(fibSche);
	ActorId aid = actor.getActorId();
	new Fiber<Void>(fibSche) {
		private static final long serialVersionUID = 2841359941298581576L;
		@Override
		protected Void run() throws SuspendExecution, InterruptedException {
			Actor.runOnFiber(actor, ah);
			return null;
		}
	}.start();
	return aid;
}
 

import co.paralleluniverse.fibers.FiberScheduler; //导入依赖的package包/类
@Suspendable
private Actor makeActor(FiberScheduler fibSche){
	ActorId aid = generateActorId();
	Actor actor = new Actor(this, aid, fibSche);
	actorMap.put(aid, actor);
	return actor;
}
 

import co.paralleluniverse.fibers.FiberScheduler; //导入依赖的package包/类
private static <Req, Res> void loadTestThroughput(final IntervalGenerator intervalGen,
                                                  int warmupRequests,
                                                  final ReceivePort<Req> requests,
                                                  final RequestExecutor<Req, Res> executor,
                                                  final SendPort<TimingEvent<Res>> eventChannel,
                                                  final FiberScheduler fiberScheduler,
                                                  final StrandFactory strandFactory)
        throws SuspendExecution, InterruptedException
{
  final long startNanos = System.nanoTime();

  try {
    long overageNanos = 0;
    long overageStart = System.nanoTime();

    final WaitGroup waitGroup = new WaitGroup();
    while (true) {
      final long receiveNanosStart = System.nanoTime();
      final Req request = requests.receive();
      LOG.trace("Receive request time: {}", System.nanoTime() - receiveNanosStart);
      if (request == null) {
        break;
      }

      // Wait before dispatching request as much as generated, minus the remaining dispatching overhead
      // to be compensated for (up to having 0 waiting time of course, not negative)
      long waitNanos = intervalGen.nextInterval(System.nanoTime() - startNanos);
      final long adjust = Math.min(waitNanos, overageNanos);
      waitNanos -= adjust;
      overageNanos -= adjust;

      // Sleep in the accepting fiber
      long sleepNanosStart = System.nanoTime();
      Strand.sleep(waitNanos, TimeUnit.NANOSECONDS);
      LOG.trace("Sleep time: {}", System.nanoTime() - sleepNanosStart);

      // Increment wait group count for new request handler
      waitGroup.add();
      final long curWaitNanos = waitNanos;
      final long curWarmupRequests = warmupRequests;
      final long curOverageNanos = overageNanos;

      final SuspendableCallable<Void> sc = () -> {
        try {
          final RequestExecOutcome<Res> outcome = executeRequest(request, executor);
          if (curWarmupRequests <= 0) {
            report(curWaitNanos, curOverageNanos, outcome, eventChannel);
          }
        } finally {
          // Complete, decrementing wait group count
          waitGroup.done();
        }
        return null;
      };
      if (fiberScheduler != null) {
        new Fiber<>(fiberScheduler, sc).start();
      } else if (strandFactory != null) {
        strandFactory.newStrand(sc).start();
      } else {
        new Fiber<>(sc).start();
      }

      final long nowNanos = System.nanoTime();
      overageNanos += nowNanos - overageStart - waitNanos;
      overageStart = nowNanos;
      warmupRequests = Math.max(warmupRequests - 1, 0);
    }

    // Wait for all outstanding requests
    waitGroup.await();
  } finally {
    eventChannel.close();
  }
}
 

import co.paralleluniverse.fibers.FiberScheduler; //导入依赖的package包/类
private static <Req, Res> void loadTestConcurrency(final int concurrency,
                                                   int warmupRequests,
                                                   final ReceivePort<Req> requests,
                                                   final RequestExecutor<Req, Res> executor,
                                                   final SendPort<TimingEvent<Res>> eventChannel,
                                                   final FiberScheduler fiberScheduler,
                                                   final StrandFactory strandFactory)
        throws SuspendExecution, InterruptedException
{
  try {
    final WaitGroup waitGroup = new WaitGroup();
    final Semaphore running = new Semaphore(concurrency);

    while (true) {
      final Req request = requests.receive();
      if (request == null) {
        break;
      }

      running.acquire();
      waitGroup.add();
      final long curWarmupRequests = warmupRequests;
      final SuspendableCallable<Void> sc = () -> {
        try {
          final RequestExecOutcome<Res> outcome = executeRequest(request, executor);
          if (curWarmupRequests <= 0) {
            report(0, 0, outcome, eventChannel);
          }
        } finally {
          running.release();
          waitGroup.done();
        }
        return null;
      };
      if (fiberScheduler != null) {
        new Fiber<>(fiberScheduler, sc).start();
      } else if (strandFactory != null) {
        strandFactory.newStrand(sc).start();
      } else {
        new Fiber<>(sc).start();
      }

      warmupRequests = Math.max(warmupRequests - 1, 0);
    }

    waitGroup.await();
  } finally {
    eventChannel.close();
  }
}
 

import co.paralleluniverse.fibers.FiberScheduler; //导入依赖的package包/类
/**
 * 创建基于纤程的Actor
 * @param axs
 * @param aid
 */
public Actor(ActorSystem axs, ActorId aid, FiberScheduler fibSche){
	this.axs = axs;
	this.selfAid = aid;
	this.fibSche = fibSche;
}
 

import co.paralleluniverse.fibers.FiberScheduler; //导入依赖的package包/类
/**
 * 返回纤程调度器，如果使用纤程创建的Actor，则返回不为空
 * @return
 */
public FiberScheduler getFiberScheduler() {
	return fibSche;
}
 

import co.paralleluniverse.fibers.FiberScheduler; //导入依赖的package包/类
/**
 * Returns the The default {@link FiberScheduler} scheduler.
 *
 * @return the default {@link FiberScheduler} scheduler.
 */
public static FiberScheduler scheduler() {
    return scheduler;
}