Scala ScheduledFuture类代码示例

//设置package包名称以及导入依赖的类
package org.hpi.esb.datasender

import java.util.concurrent.{ScheduledFuture, ScheduledThreadPoolExecutor, TimeUnit}

import org.apache.kafka.clients.producer.KafkaProducer
import org.hpi.esb.commons.util.Logging
import org.hpi.esb.datasender.config.Configurable
import org.hpi.esb.datasender.output.writers.DatasenderRunResultWriter
import org.hpi.esb.util.OffsetManagement


class DataProducer(resultHandler: DatasenderRunResultWriter, kafkaProducer: KafkaProducer[String, String],
                   dataReader: DataReader, topics: List[String], numberOfThreads: Int,
                   sendingInterval: Int, sendingIntervalTimeUnit: TimeUnit,
                   duration: Long, durationTimeUnit: TimeUnit, singleColumnMode: Boolean) extends Logging with Configurable {


  val executor: ScheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(numberOfThreads)
  val producerThread = new DataProducerThread(this, kafkaProducer, dataReader, topics,
    singleColumnMode, duration, durationTimeUnit)

  val topicOffsets = getTopicOffsets()

  var t: ScheduledFuture[_] = _

  def shutDown(): Unit = {
    t.cancel(false)
    dataReader.close()
    kafkaProducer.close()
    executor.shutdown()
    logger.info("Shut data producer down.")
    val expectedRecordNumber = producerThread.numberOfRecords
    resultHandler.outputResults(topicOffsets, expectedRecordNumber)
  }

  def execute(): Unit = {
    val initialDelay = 0
    t = executor.scheduleAtFixedRate(producerThread, initialDelay, sendingInterval, sendingIntervalTimeUnit)
    val allTopics = topics.mkString(" ")
    logger.info(s"Sending records to following topics: $allTopics")
  }

  def getTopicOffsets(): Map[String, Long] = {
    topics.map(topic => {
      val currentOffset = OffsetManagement.getNumberOfMessages(topic, partition = 0)
      topic -> currentOffset
    }).toMap[String, Long]
  }
} 

//设置package包名称以及导入依赖的类
package one.lockstep.util.concurrent

import java.util
import java.util.concurrent.{Callable, ScheduledExecutorService, ScheduledFuture}

import one.lockstep.util.japi._

import scala.concurrent.duration._

class DelegatingScheduledExecutorService(service: ScheduledExecutorService)
  extends ScheduledExecutorService {
  def prepareSchedule(delay: Long, unit: TimeUnit): Unit = ()
  override def scheduleAtFixedRate(command: Runnable, initialDelay: Long, period: Long, unit: TimeUnit): ScheduledFuture[_] = {
    prepareSchedule(List(initialDelay, period).max, unit)
    service.scheduleAtFixedRate(command, initialDelay, period, unit)
  }
  override def schedule(command: Runnable, delay: Long, unit: TimeUnit): ScheduledFuture[_] = {
    prepareSchedule(delay, unit)
    service.schedule(command, delay, unit)
  }
  override def schedule[V](callable: Callable[V], delay: Long, unit: TimeUnit): ScheduledFuture[V] = {
    prepareSchedule(delay, unit)
    service.schedule(callable, delay, unit)
  }
  override def scheduleWithFixedDelay(command: Runnable, initialDelay: Long, delay: Long, unit: TimeUnit): ScheduledFuture[_] = {
    prepareSchedule(List(initialDelay, delay).max, unit)
    service.scheduleWithFixedDelay(command, initialDelay, delay, unit)
  }
  override def shutdown(): Unit = service.shutdown()
  override def isTerminated: Boolean = service.isTerminated
  override def awaitTermination(timeout: Long, unit: TimeUnit): Boolean =
    service.awaitTermination(timeout, unit)
  override def shutdownNow(): util.List[Runnable] = service.shutdownNow()
  override def invokeAll[T](tasks: util.Collection[_ <: Callable[T]]): util.List[JFuture[T]] =
    service.invokeAll(tasks)
  override def invokeAll[T](tasks: util.Collection[_ <: Callable[T]], timeout: Long, unit: TimeUnit): util.List[JFuture[T]] =
    service.invokeAll(tasks, timeout, unit)
  override def invokeAny[T](tasks: util.Collection[_ <: Callable[T]]): T = service.invokeAny(tasks)
  override def invokeAny[T](tasks: util.Collection[_ <: Callable[T]], timeout: Long, unit: TimeUnit): T =
    service.invokeAny(tasks, timeout, unit)
  override def isShutdown: Boolean = service.isShutdown
  override def submit[T](task: Callable[T]): JFuture[T] = service.submit(task)
  override def submit[T](task: Runnable, result: T): JFuture[T] = service.submit(task, result)
  override def submit(task: Runnable): JFuture[_] = service.submit(task)
  override def execute(command: Runnable): Unit = service.execute(command)
} 

//设置package包名称以及导入依赖的类
package com.wavesplatform.network

import java.util.concurrent.ScheduledFuture

import com.wavesplatform.state2.ByteStr
import io.netty.channel.{ChannelDuplexHandler, ChannelHandlerContext, ChannelPromise}
import scorex.utils.ScorexLogging

import scala.concurrent.duration.FiniteDuration

class ExtensionSignaturesLoader(syncTimeout: FiniteDuration, peerDatabase: PeerDatabase)
  extends ChannelDuplexHandler with ScorexLogging {

  private var currentTimeout = Option.empty[ScheduledFuture[Unit]]
  private var lastKnownSignatures = Seq.empty[ByteStr]

  override def channelRead(ctx: ChannelHandlerContext, msg: AnyRef) = msg match {
    case s: Signatures =>
      val (known, unknown) = s.signatures.span(id => lastKnownSignatures.contains(id))
      currentTimeout.foreach(_.cancel(true))
      currentTimeout = None
      known.lastOption.foreach { lastKnown =>
        log.debug(s"${id(ctx)} Got extension with ${known.length}/${s.signatures.length} known signatures")
        ctx.fireChannelRead(ExtensionIds(lastKnown, unknown))
      }
    case _ => super.channelRead(ctx, msg)
  }

  override def channelInactive(ctx: ChannelHandlerContext) = {
    currentTimeout.foreach(_.cancel(false))
    currentTimeout = None
  }

  override def write(ctx: ChannelHandlerContext, msg: AnyRef, promise: ChannelPromise) = msg match {
    case LoadBlockchainExtension(sigs) if currentTimeout.isEmpty =>
      lastKnownSignatures = sigs

      log.debug(s"${id(ctx)} Loading extension, last ${sigs.length} are ${formatSignatures(sigs)}")

      currentTimeout = Some(ctx.executor().schedule(syncTimeout) {
        if (currentTimeout.nonEmpty && ctx.channel().isActive) {
          peerDatabase.blacklistAndClose(ctx.channel(),"Timeout expired while loading extension")
        }
      })

      ctx.writeAndFlush(GetSignatures(sigs), promise)

    case LoadBlockchainExtension(_) =>
      log.debug(s"${id(ctx)} Received request to load signatures while waiting for extension, ignoring for now")
      promise.setSuccess()

    case _ => super.write(ctx, msg, promise)
  }
} 

//设置package包名称以及导入依赖的类
package ru.tinkoff.cache

import java.util.concurrent.{ScheduledExecutorService, ScheduledFuture, TimeUnit}

import akka.actor.{Scheduler, Cancellable => AkkaCancellable}


trait StorageCleaner {
  def removeExpired(): Unit
  def scheduleCleaning(): Cancellable
}

trait Cancellable {
  def cancel(): Boolean
  def isCancelled: Boolean
}

object Cancellable {
  implicit def fromAkka(ac: AkkaCancellable): Cancellable = new Cancellable {
    def cancel(): Boolean = ac.cancel()
    def isCancelled: Boolean = ac.isCancelled
  }

  implicit def fromJava(sf: ScheduledFuture[_]): Cancellable = new Cancellable {
    def cancel() = sf.cancel(false)
    def isCancelled = sf.isCancelled
  }

  object empty extends Cancellable {
    val cancel = false
    val isCancelled = true
  }
}

trait NoCleaner extends StorageCleaner {
  def scheduleCleaning() = Cancellable.empty
}

trait AkkaSchedulerCleaner extends StorageCleaner { this: CacheStorage =>
  def scheduler: Scheduler
  def settings: CacheConfig
  def scheduleCleaning() = scheduler.schedule(settings.cleanInterval, settings.cleanInterval) {
    removeExpired()
  }(cacheContext)
}

trait JavaSchedulerCleaner extends StorageCleaner {
  def scheduler: ScheduledExecutorService
  def settings: CacheConfig
  def scheduleCleaning() = scheduler.scheduleAtFixedRate(new Runnable {
    def run() = removeExpired()
  }, settings.cleanInterval.toMillis, settings.cleanInterval.toMillis, TimeUnit.MILLISECONDS)
} 

//设置package包名称以及导入依赖的类
package com.twitter.jvm

import java.util.concurrent.{AbstractExecutorService, Callable, ScheduledExecutorService, ScheduledFuture, TimeUnit}

import scala.collection.mutable

// A mostly empty implementation so that we can successfully
// mock it.
class MockScheduledExecutorService extends AbstractExecutorService with ScheduledExecutorService {
  val schedules = mutable.Buffer[(Runnable, Long, Long, TimeUnit)]()

  def schedule[V](c: Callable[V], delay: Long, unit: TimeUnit) = throw new Exception
  def schedule(command: Runnable, delay: Long, unit: TimeUnit) = throw new Exception
  def scheduleWithFixedDelay(command: Runnable, initialDelay: Long, delay: Long, unit: TimeUnit) =
    throw new Exception
  def execute(command: Runnable) = throw new Exception
  def awaitTermination(timeout: Long, unit: TimeUnit) = throw new Exception
  def isTerminated() = throw new Exception
  def isShutdown() = throw new Exception
  def shutdownNow() = throw new Exception
  def shutdown() = throw new Exception

  def scheduleAtFixedRate(r: Runnable, initialDelay: Long, period: Long, unit: TimeUnit): ScheduledFuture[_] = {
    schedules += ((r, initialDelay, period, unit))
    null
  }
} 

//设置package包名称以及导入依赖的类
package com.kakao.mango.concurrent

import java.util.concurrent.{Callable, ScheduledFuture, TimeUnit, ScheduledExecutorService}

import scala.concurrent.duration.Duration
import scala.concurrent.duration._
import scala.language.postfixOps


class RichScheduledExecutorService(underlying: ScheduledExecutorService) extends RichExecutorService(underlying) with ScheduledExecutorService {

  def scheduleIn[T](delay: Duration)(command: => T): ScheduledFuture[T] = schedule(new Callable[T] {
    override def call(): T = command
  }, delay.toMillis, TimeUnit.MILLISECONDS)

  def withFixedRate[T](rate: Duration, initialDelay: Duration = 0.second)(command: => Unit) = scheduleAtFixedRate(new Runnable {
    override def run(): Unit = command
  }, initialDelay.toMillis, rate.toMillis, TimeUnit.MILLISECONDS)

  def withFixedDelay[T](delay: Duration, initialDelay: Duration = 0.second)(command: => Unit) = scheduleWithFixedDelay(new Runnable {
    override def run(): Unit = command
  }, initialDelay.toMillis, delay.toMicros, TimeUnit.MILLISECONDS)

  // delegating to underlying
  override def schedule(command: Runnable, delay: Long, unit: TimeUnit): ScheduledFuture[_] = underlying.schedule(wrap(command), delay, unit)
  override def scheduleAtFixedRate(command: Runnable, initialDelay: Long, period: Long, unit: TimeUnit): ScheduledFuture[_] = underlying.scheduleAtFixedRate(wrap(command), initialDelay, period, unit)
  override def schedule[V](callable: Callable[V], delay: Long, unit: TimeUnit): ScheduledFuture[V] = underlying.schedule(wrap(callable), delay, unit)
  override def scheduleWithFixedDelay(command: Runnable, initialDelay: Long, delay: Long, unit: TimeUnit): ScheduledFuture[_] = underlying.scheduleWithFixedDelay(wrap(command), initialDelay, delay, unit)
} 

//设置package包名称以及导入依赖的类
package com.wavesplatform.network

import java.util.concurrent.ScheduledFuture

import com.wavesplatform.state2.ByteStr
import io.netty.channel.{ChannelDuplexHandler, ChannelHandlerContext, ChannelPromise}
import scorex.utils.ScorexLogging

import scala.concurrent.duration.FiniteDuration

class ExtensionSignaturesLoader(syncTimeout: FiniteDuration, peerDatabase: PeerDatabase)
  extends ChannelDuplexHandler with ScorexLogging {

  private var currentTimeout = Option.empty[ScheduledFuture[Unit]]
  private var lastKnownSignatures = Seq.empty[ByteStr]

  override def channelRead(ctx: ChannelHandlerContext, msg: AnyRef) = msg match {
    case s: Signatures =>
      val (known, unknown) = s.signatures.span(id => lastKnownSignatures.contains(id))
      currentTimeout.foreach(_.cancel(true))
      currentTimeout = None
      known.lastOption.foreach { lastKnown =>
        log.debug(s"${id(ctx)} Got extension with ${known.length}/${s.signatures.length} known signatures")
        ctx.fireChannelRead(ExtensionIds(lastKnown, unknown))
      }
    case _ => super.channelRead(ctx, msg)
  }

  override def channelInactive(ctx: ChannelHandlerContext) = {
    currentTimeout.foreach(_.cancel(false))
    currentTimeout = None
  }

  override def write(ctx: ChannelHandlerContext, msg: AnyRef, promise: ChannelPromise) = msg match {
    case LoadBlockchainExtension(sigs) if currentTimeout.isEmpty =>
      lastKnownSignatures = sigs

      log.debug(s"${id(ctx)} Loading extension, last ${sigs.length} are [${sigs.head}..${sigs.last}]")

      currentTimeout = Some(ctx.executor().schedule(syncTimeout) {
        if (currentTimeout.nonEmpty && ctx.channel().isActive) {
          peerDatabase.blacklistAndClose(ctx.channel(),"Timeout expired while loading extension")
        }
      })

      ctx.writeAndFlush(GetSignatures(sigs), promise)

    case LoadBlockchainExtension(sigs) =>
      log.debug(s"${id(ctx)} Received request to load signatures while waiting for extension, ignoring for now")
      promise.setSuccess()

    case _ => super.write(ctx, msg, promise)
  }
}