assertEquals(3L, countDownLatch.getCount());

    list.execute();

    // Verify that all of the runnables execute in a reasonable amount of time.
    assertTrue(countDownLatch.await(1L, TimeUnit.SECONDS));
  }

  public void testExecute_idempotent() {
    final AtomicInteger runCalled = new AtomicInteger();
    list.add(
        new Runnable() {
          @Override

                }
            }

            leaseAcquiredLatch.await()

            // release the first queue to submit its work
            synchronized (release) {
                release.notify()
            }

            // Wait for all worker leases to be utilized running work
            runningLatch.await()
            fullyUtilizedLatch.countDown()
        }

        where:

    override fun isDone(): Boolean = result != null

    override fun get(): T {
        outcomeLatch.await()
        return getOrThrow()
    }

    override fun get(timeout: Long, unit: TimeUnit): T =
        if (outcomeLatch.await(timeout, unit)) getOrThrow()
        else throw TimeoutException()

    private
    fun getOrThrow() = (result as Result<T>).getOrThrow()

                        case Idle:
                        case Busy:
                            LOGGER.debug("daemon is running. Sleeping until state changes.");
                            condition.await();
                            break;
                        case Canceled:
                            LOGGER.debug("cancel requested.");
                            DaemonStopState state = cancelNow();

        def threads = 5
        def startSignal = new CountDownLatch(1)
        def doneSignal = new CountDownLatch(threads)

        when:
        threads.times {
            new Thread({
                startSignal.await()
                def spawnedProject = ProjectBuilder.builder().build()
                try {
                    doneSignal.countDown()
                } finally {

# 동시성과 async / await

*경로 작동 함수*에서의 `async def` 문법에 대한 세부사항과 비동기 코드, 동시성 및 병렬성에 대한 배경

## 바쁘신 경우

<strong>요약</strong>

다음과 같이 `await`를 사용해 호출하는 제3의 라이브러리를 사용하는 경우:

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

다음처럼 *경로 작동 함수*를 `async def`를 사용해 선언하십시오:

```Python hl_lines="2"
@app.get('/')
async def read_results():
    results = await some_library()
    return results
```

!!! note "참고"

  // CHECK: [[recv_future:%.*]] = tf_mlrt.async_executeop.device([[device]]){{.*}}op: \22Recv\22
  // CHECK: [[recv:%.*]] = tf_mlrt.await [[recv_future]]
  // CHECK: [[rendezvous_key_base:%.*]], [[result_future:%.*]] = tf_mlrt_tpu.compile_and_execute([[recv]])
  // CHECK: tf_mlrt.await [[result_future]]

                    def workQueue2 = submit(ParallelWorkAction.class, [ "item3" ])

                    signal("submitted")

                    workQueue1.await()

                    signal("finished")
                }
            }
        """

        def started = blockingHttpServer.expectConcurrentAndBlock("item1", "item2", "item3", "submitted")

            workItems.add(workerExecutor.submitWork(workActionClass, parameterAction, spec, workerFactory));
        }

        @Override
        public void await() throws WorkerExecutionException {
            workerExecutor.await(workItems);
        }
    }

func (w Waitmsg) ExitStatus() int {
	if len(w.Msg) == 0 {
		// a normal exit returns no message
		return 0
	}
	return 1
}

//sys	await(s []byte) (n int, err error)

func Await(w *Waitmsg) (err error) {
	var buf [512]byte
	var f [5][]byte

	n, err := await(buf[:])

	if err != nil || w == nil {
		return
	}

	nf := 0
	p := 0
	for i := 0; i < n && nf < len(f)-1; i++ {