private var writer = Http2Writer(bytesOut, client)
  private val outFrames: MutableList<OutFrame> = ArrayList()
  private val inFrames: BlockingQueue<InFrame> = LinkedBlockingQueue()
  private var port = 0
  private val executor = Executors.newSingleThreadExecutor(threadFactory("MockHttp2Peer"))
  private var serverSocket: ServerSocket? = null
  private var socket: Socket? = null

  fun setClient(client: Boolean) {
    if (this.client == client) return

    }

    eventListener.canceled(this)
  }

  override fun isCanceled(): Boolean = canceled

  override fun execute(): Response {
    check(executed.compareAndSet(false, true)) { "Already Executed" }

    timeout.enter()
    callStart()
    try {
      client.dispatcher.executed(this)
      return getResponseWithInterceptorChain()
    } finally {
      client.dispatcher.finished(this)
    }
  }

      .build()

  @After
  fun tearDown() {
    engine.shutdown()
    cacheDir.deleteRecursively()
  }

  @Test
  fun get() {
    val executor = Executors.newCachedThreadPool()

    val completableFuture = execute(engine, executor, "https://google.com/robots.txt")

    try {
      val response = completableFuture.get(10, TimeUnit.SECONDS)

      assertEquals(200, response.code)

    dispatcher.maxRequestsPerHost = 4
    executor.assertJobs("http://a/1", "http://a/2", "http://a/3", "http://a/4")
  }

  @Test
  fun oldJobFinishesNewJobCanRunDifferentHost() {
    dispatcher.maxRequests = 1
    client.newCall(newRequest("http://a/1")).enqueue(callback)
    client.newCall(newRequest("http://b/1")).enqueue(callback)
    executor.finishJob("http://a/1")
    executor.assertJobs("http://b/1")
  }

  @Test

class RelayTest {
  @TempDir
  var tempDir: File? = null
  private val executor = Executors.newCachedThreadPool(threadFactory("RelayTest"))
  private val metadata: ByteString = "great metadata!".encodeUtf8()
  private lateinit var file: File

  @BeforeEach
  fun setUp() {
    file = File(tempDir, "test")
  }

  @AfterEach
  fun tearDown() {
    executor.shutdown()
  }

  @Test
  fun singleSource() {

 */
class SocksProxy {
  private val executor = Executors.newCachedThreadPool(threadFactory("SocksProxy"))
  private var serverSocket: ServerSocket? = null
  private val connectionCount = AtomicInteger()
  private val openSockets = Collections.newSetFromMap(ConcurrentHashMap<Socket, Boolean>())

  fun play() {
    serverSocket = ServerSocket(0)
    executor.execute {
      val threadName = "SocksProxy ${serverSocket!!.localPort}"

  }

  private void parallelDrainQueue(int threadCount) {
    ExecutorService executor = Executors.newFixedThreadPool(threadCount);
    for (int i = 0; i < threadCount; i++) {
      executor.execute(() -> {
        try {
          drainQueue();
        } catch (Exception e) {
          e.printStackTrace();
        }
      });
    }
    executor.shutdown();
  }

  private void drainQueue() throws Exception {

    val flags: Int,
    val callback: DnsResolver.Callback<List<InetAddress>>,
  )

  @Implementation
  fun query(
    network: Network?,
    domain: String,
    nsType: Int,
    flags: Int,
    executor: Executor,
    cancellationSignal: CancellationSignal?,
    callback: DnsResolver.Callback<List<InetAddress>>,
  ) {
    responder(Request(network, domain, nsType, flags, callback))
  }

  companion object {

      }
    }

    override fun <T> decorate(queue: BlockingQueue<T>) = queue

    override fun execute(
      taskRunner: TaskRunner,
      runnable: Runnable,
    ) {
      executor.execute(runnable)
    }

    fun shutdown() {
      executor.shutdown()
    }
  }

  companion object {
    val logger: Logger = Logger.getLogger(TaskRunner::class.java.name)

Sometimes there's an action required like calling the application layer or responding to a ping, and the thread discovering the action is not the thread that should do the work. We enqueue a runnable on this executor and it gets handled by one of the executor's threads.

### Locks

We have 3 different things that we synchronize on.

#### Http2Connection