original_route_handler = super().get_route_handler()

        async def custom_route_handler(request: Request) -> Response:
            before = time.time()
            response: Response = await original_route_handler(request)
            duration = time.time() - before
            response.headers["X-Response-Time"] = str(duration)
            print(f"route duration: {duration}")

      queue.enqueue(incrementingEvent(counters, listener, 4));
      queue.enqueue(countDownEvent(latch));
      assertEquals(0, counters.size());
      queue.dispatch();
      latch.await();
      assertEquals(multiset(listener, 4), counters);
    } finally {
      service.shutdown();
    }
  }

  public void testEnqueueAndDispatch_multithreaded_withThrowingRunnable()

///

## Aguardar por mensagens e enviar mensagens

Em sua rota WebSocket você pode esperar (`await`) por mensagens e enviar mensagens.

{*../../docs_src/websockets/tutorial001.py hl[48:52]*}

Você pode receber e enviar dados binários, de texto e JSON.

## Tente você mesmo

      queue.enqueue(incrementingEvent(counters, listener, 4));
      queue.enqueue(countDownEvent(latch));
      assertEquals(0, counters.size());
      queue.dispatch();
      latch.await();
      assertEquals(multiset(listener, 4), counters);
    } finally {
      service.shutdown();
    }
  }

  public void testEnqueueAndDispatch_multithreaded_withThrowingRunnable()

* `read(size)`: ✍ `size` (`int`) 🔢/🦹 📁.
* `seek(offset)`: 🚶 🔢 🧘 `offset` (`int`) 📁.
    * 🤶 Ⓜ., `await myfile.seek(0)` 🔜 🚶 ▶️ 📁.
    * 👉 ✴️ ⚠ 🚥 👆 🏃 `await myfile.read()` 🕐 & ⤴️ 💪 ✍ 🎚 🔄.
* `close()`: 🔐 📁.

🌐 👫 👩‍🔬 `async` 👩‍🔬, 👆 💪 "⌛" 👫.

🖼, 🔘 `async` *➡ 🛠️ 🔢* 👆 💪 🤚 🎚 ⏮️:

```Python
contents = await myfile.read()
```

🚥 👆 🔘 😐 `def` *➡ 🛠️ 🔢*, 👆 💪 🔐 `UploadFile.file` 🔗, 🖼:

                  startLatch.countDown();
                  startLatch.await();
                  callable.call();
                  doneLatch.countDown();
                  return null;
                }
              });
    }
    doneLatch.await();
  }

		return 0, err
	}

	// In case we're booting a device or emulator alongside all.bash, wait for
	// it to be ready. adb wait-for-device is not enough, we have to
	// wait for sys.boot_completed.
	if err := adb("wait-for-device", "exec-out", "while [[ -z $(getprop sys.boot_completed) ]]; do sleep 1; done;"); err != nil {
		return 0, err
	}

	// Done once per make.bash.

				fmt.Printf("Task in the queue: %#v\n", task)
			}
		default:
			// task queue is full, no more workers, we shall move on and heal later.
			return nil
		}
		// Don't wait for result
		return nil
	}

	// respCh must be set to wait for result.
	// We make it size 1, so a result can always be written
	// even if we aren't listening.
	task.respCh = make(chan healResult, 1)
	select {

   * numElements} elements are not available, it will wait for them up to the specified timeout.
   *
   * @param q the blocking queue to be drained
   * @param buffer where to add the transferred elements
   * @param numElements the number of elements to be waited for
   * @param timeout how long to wait before giving up
   * @return the number of elements transferred

    }
    return new ListenableFutureAdapter<>(future, executor);
  }

  /**
   * An adapter to turn a {@link Future} into a {@link ListenableFuture}. This will wait on the
   * future to finish, and when it completes, run the listeners. This implementation will wait on
   * the source future indefinitely, so if the source future never completes, the adapter will never
   * complete either.
   *