### Arquivos e async { #files-and-async }

Na maioria dos casos, objetos semelhantes a arquivo não são compatíveis com async e await por padrão.

Por exemplo, eles não têm `await file.read()`, nem `async for chunk in file`.

E, em muitos casos, lê-los seria uma operação bloqueante (que poderia bloquear o loop de eventos), pois são lidos do disco ou da rede.

/// info | Informação

	g := errgroup.WithNErrs(len(s.sets))
	for index := range s.sets {
		g.Go(func() error {
			storageInfos[index] = s.sets[index].StorageInfo(ctx)
			return nil
		}, index)
	}

	// Wait for the go routines.
	g.Wait()

	for _, lstorageInfo := range storageInfos {
		storageInfo.Disks = append(storageInfo.Disks, lstorageInfo.Disks...)
	}

	return storageInfo
}

            executorService.submit(
                () -> {
                  startLatch.countDown();
                  startLatch.await();
                  callable.call();
                  doneLatch.countDown();
                  return null;
                });
      }
      doneLatch.await();
    } finally {
      executorService.shutdown();
    }
  }

/// note | Detalhes Técnicos

Uma tarefa `async` só pode ser cancelada quando alcança um `await`. Se não houver `await`, o gerador (função com `yield`) não pode ser cancelado adequadamente e pode continuar executando mesmo após o cancelamento ser solicitado.

Como este pequeno exemplo não precisa de nenhuma instrução `await`, adicionamos um `await anyio.sleep(0)` para dar ao event loop a chance de lidar com o cancelamento.

		}

		tries++
		switch {
		case errors.Is(err, errNotFirstDisk):
			// Fresh setup, wait for first server to be up.
			logger.Info("Waiting for the first server to format the drives (elapsed %s)\n", getElapsedTime())
		case errors.Is(err, errFirstDiskWait):
			// Fresh setup, wait for other servers to come up.

				_ = httpStats.toServerHTTPStats(false)
				_ = httpStats.totalS3Requests.Load(false)
				_ = httpStats.currentS3Requests.Load(false)
				time.Sleep(1 * time.Microsecond)
			}
		}(i)
	}
	wg.Wait()

	finalStats := httpStats.toServerHTTPStats(false)
	totalRequests := 0
	for _, v := range finalStats.TotalS3Requests.APIStats {
		totalRequests += v
	}
	if totalRequests == 0 {

この例では `io.BytesIO` によるメモリ内の疑似ファイルなので重要度は高くありませんが、実ファイルの場合は処理後に確実にクローズすることが重要です。

### ファイルと非同期 { #files-and-async }

多くの場合、ファイルライクオブジェクトはデフォルトでは async/await と互換性がありません。

例えば、`await file.read()` や `async for chunk in file` のような操作は提供されていません。

また、多くの場合、ディスクやネットワークから読み出すため、読み取りはブロッキング（イベントループをブロックし得る）処理になります。

/// info | 情報

上記の例は例外で、`io.BytesIO` は既にメモリ上にあるため、読み取りが何かをブロックすることはありません。

		r.writeCond.Broadcast()
	}

	// Unlock the mutex so readers/writers can finish.
	r.mu.Unlock()
	r.wg.Wait()
	r.mu.Lock()
	r.r = 0
	r.w = 0
	r.err = nil
	r.isFull = false
}

// WriteCloser returns a WriteCloser that writes to the ring buffer.
// When the returned WriteCloser is closed, it will wait for all data to be read before returning.
func (r *RingBuffer) WriteCloser() io.WriteCloser {

    legacy_request_state_context_var.reset(contextvar_token)


@app.middleware("http")
async def custom_middleware(
    request: Request, call_next: Callable[[Request], Awaitable[Response]]
):
    response = await call_next(request)
    response.headers["custom"] = "foo"
    return response


@app.get("/user", dependencies=[Depends(set_up_request_state_dependency)])
def get_user():

  cd ..
fi

# SqlServer for Mac M1
if [[ -z $GITHUB_ACTION && -d tests ]]; then
  cd tests
  if [[ $(uname -a) == *" arm64" ]]; then
    MSSQL_IMAGE=mcr.microsoft.com/azure-sql-edge docker compose up -d --wait
    go install github.com/microsoft/go-sqlcmd/cmd/sqlcmd@latest || true
    for query in \
      "IF DB_ID('gorm') IS NULL CREATE DATABASE gorm" \