# Concurrency and async / await { #concurrency-and-async-await }

Details about the `async def` syntax for *path operation functions* and some background about asynchronous code, concurrency, and parallelism.

## In a hurry? { #in-a-hurry }

<abbr title="too long; didn't read"><strong>TL;DR:</strong></abbr>

If you are using third party libraries that tell you to call them with `await`, like:

```Python
results = await some_library()
```

                        // WAIT #1
                        barrier.await(1, SECONDS);

                        // WAIT #2
                        barrier.await(1, SECONDS);
                        assertTrue(executor.isShutdown());
                        assertFalse(executor.isTerminated());

                        // WAIT #3
                        barrier.await(1, SECONDS);
                        return null;

                        // WAIT #1
                        barrier.await(1, SECONDS);

                        // WAIT #2
                        barrier.await(1, SECONDS);
                        assertTrue(executor.isShutdown());
                        assertFalse(executor.isTerminated());

                        // WAIT #3
                        barrier.await(1, SECONDS);
                        return null;

        });

        deferred.resolve(new SuggestResponse("", 0, Collections.emptyList(), 0, null));

        assertTrue("Then callback should complete", latch.await(10, TimeUnit.SECONDS));
        Thread.sleep(100); // Wait a bit to ensure error callback isn't called
        assertEquals("Then callback should be invoked", 1, thenCount.get());
        assertEquals("Error callback should not be invoked", 0, errorCount.get());

            });

            longRunningThread.start();
            startLatch.await();

            // Check active requests
            assertEquals(1, cbWithTracking.getActiveRequests(), "Should have 1 active request");

            // Complete the operation
            holdLatch.countDown();
            completeLatch.await();
            longRunningThread.join();

                        startLatch.await();
                        response.received();
                        endLatch.countDown();
                    } catch (InterruptedException e) {
                        // Ignore
                    }
                }).start();
            }

            startLatch.countDown();
            assertTrue(endLatch.await(1, TimeUnit.SECONDS));

    Thread runner = new Thread(task);
    runner.start();
    isInterruptibleRegistered.await();
    RuntimeException expected = assertThrows(RuntimeException.class, task::interruptTask);
    assertThat(expected)
        .hasMessageThat()
        .isEqualTo("I bet you didn't think Thread.interrupt could throw");
    /*
     * We need to wait for the runner to exit. It used to be that the runner would get stuck in the

    Thread runner = new Thread(task);
    runner.start();
    isInterruptibleRegistered.await();
    RuntimeException expected = assertThrows(RuntimeException.class, task::interruptTask);
    assertThat(expected)
        .hasMessageThat()
        .isEqualTo("I bet you didn't think Thread.interrupt could throw");
    /*
     * We need to wait for the runner to exit. It used to be that the runner would get stuck in the

	// even if updating the value errors out.
	// Returns the last good value AND the error.
	ReturnLastGood bool

	// If NoWait is set, Get() will return the last good value,
	// if TTL has expired but 2x TTL has not yet passed,
	// but will fetch a new value in the background.
	NoWait bool
}

// Cache contains a synchronized value that is considered valid
// for a specific amount of time.

        for (int i = 0; i < readerThreadCount; i++) {
            final int threadIndex = i;
            readerThreads[i] = new Thread(() -> {
                try {
                    startLatch.await(); // Wait for start signal
                    long endTime = System.currentTimeMillis() + testDurationMs;
                    while (System.currentTimeMillis() < endTime) {