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

import com.twitter.concurrent.NamedPoolThreadFactory
import com.twitter.util.{ExecutorServiceFuturePool, Future, FuturePool}
import java.util.concurrent.{ArrayBlockingQueue, ThreadPoolExecutor, TimeUnit}

case class Message(endpoint: Option[String], result: FieldMap[Any])

trait MapLifter {
  def apply(input: Array[Byte]): Future[Message]
}

object MapLifterPool {
  val QueueSizeDefault = 5

  def apply(mapLifterFactory: => MapLifter) = {
    val executorService =
      new ThreadPoolExecutor(
        3,   // core pool size
        10,  // max pool size
        500, // keep alive time
        TimeUnit.MILLISECONDS,
        new ArrayBlockingQueue[Runnable](10), // work queue
        new NamedPoolThreadFactory("maplifter", makeDaemons = true),
        new ThreadPoolExecutor.AbortPolicy()
      )
    executorService.prestartCoreThread()
    new MapLifterPool(mapLifterFactory, new ExecutorServiceFuturePool(executorService))
  }
}

class MapLifterPool(underlying: MapLifter, futurePool: FuturePool) extends MapLifter {
  override def apply(input: Array[Byte]): Future[Message] =
    (futurePool { underlying(input) }).flatten
} 

//设置package包名称以及导入依赖的类
package org.kirhgoff.munchkin

import java.net.Socket
import java.util.concurrent.Executors._
import java.util.concurrent.ThreadPoolExecutor

class MudBot(hostname: String, port: Int) {
  val executor:ThreadPoolExecutor =
    newFixedThreadPool(2).asInstanceOf[ThreadPoolExecutor]

  val socket = new Socket(hostname, port)
  val outputStream = socket.getOutputStream
  val inputStream = socket.getInputStream

  def stop() = {
    try { inputStream.close() } catch { case e:Exception => e.printStackTrace()}
    try { outputStream.close() } catch { case e:Exception => e.printStackTrace()}
    try { socket.close() } catch { case e:Exception => e.printStackTrace()}
  }

  def startLoop() = {
    val writer = new MudWriter(outputStream)
    val ai = new FalloutBot (writer)
    val inputReader = new UserInputReader(ai)
    val reader = new MudReader(inputStream, ai)

    executor.execute(reader)
    executor.execute(inputReader)

    while (executor.getActiveCount == 2) {
      Thread.sleep(1000)
    }
    println("system> Exiting")
    executor.shutdownNow()
    System.exit(0)
  }

  //def enterWarzone(): Unit = ???

  //def login(login: String, passwordPath: String): Unit = ???

} 

//设置package包名称以及导入依赖的类
package teleporter.stream.integration.transaction

import java.util.concurrent.{LinkedBlockingQueue, ThreadPoolExecutor, TimeUnit}


object Test extends App {
  val pool = new ThreadPoolExecutor(2, 20, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue[Runnable](1))
  for (i ? 1 to 10) {
    pool.execute(new Runnable {
      override def run(): Unit = {
        while (true) {
          println(s"${Thread.currentThread().getName}: $i")
          Thread.sleep(2000)
        }
      }
    })
  }
} 

//设置package包名称以及导入依赖的类
package alexsmirnov.stream

import java.util.concurrent.Executors
import java.util.concurrent.ThreadPoolExecutor
import java.util.concurrent.TimeUnit
import org.reactivestreams.Processor
import java.util.concurrent.LinkedBlockingQueue

  class AsyncProcessor[A](queueSize: Int = 100) extends Processor[A, A] with PublisherBase[A] with SubscriberBase[A] {

    private[this] val executor = Executors.unconfigurableExecutorService(
      new ThreadPoolExecutor(1, 1,
        0L, TimeUnit.MILLISECONDS,
        new LinkedBlockingQueue[Runnable](queueSize + 1),
        streamsThreadFactory))

    def onStart() { request(queueSize) }
    def onStop() { cancel() }
    def onNext(a: A) {
      executor.submit(new Runnable { def run() { sendNext(a); request(1L) } })
    }
    def onComplete() = {
      executor.submit(new Runnable { def run() { sendComplete() } })
    }
    def onError(t: Throwable) {
      stopProducer()
      sendError(t)
    }
  }