## HTTP/2 Connections

The HttpURLConnection API is a blocking API. You make a blocking write to send a request, and a blocking read to receive the response.

#### Blocking APIs

# Blocking vs Non-blocking

The default behavior of the ring buffer is non-blocking, 
meaning that reads and writes will return immediately with an error if the operation cannot be completed.
If you want to block when reading or writing, you must enable it:

```go
	rb := ringbuffer.New(1024).SetBlocking(true)
```

## ty

If ty is available, use it to check types.

## Asyncer

When needing to run blocking code inside of async functions, or async code inside of blocking functions, suggest using Asyncer.

Prefer it over AnyIO or asyncio.

Install:

```bash
uv add asyncer
```

Run blocking sync code inside of async with `asyncify()`:

```python
from asyncer import asyncify
from fastapi import FastAPI

        assertThrows(ExecutionException.class, () -> getDone(task));
    assertThat(executionException).hasCauseThat().isEqualTo(e);
  }

  @J2ktIncompatible
  @GwtIncompatible // blocking wait
  public void testCancel_interrupted() throws Exception {
    AtomicBoolean interruptedExceptionThrown = new AtomicBoolean();
    CountDownLatch enterLatch = new CountDownLatch(1);

{* ../../docs_src/stream_data/tutorial002_py310.py ln[30:34] hl[31] *}

/// tip

If you need to call blocking code from inside of an async function, or an async function from inside of a blocking function, you could use [Asyncer](https://asyncer.tiangolo.com), a sibling library to FastAPI.

///

        assertThrows(ExecutionException.class, () -> getDone(task));
    assertThat(executionException).hasCauseThat().isEqualTo(e);
  }

  @J2ktIncompatible
  @GwtIncompatible // blocking wait
  public void testCancel_interrupted() throws Exception {
    AtomicBoolean interruptedExceptionThrown = new AtomicBoolean();
    CountDownLatch enterLatch = new CountDownLatch(1);

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package lock

import (
	"os"
	"syscall"
)

// Internal function implements support for both
// blocking and non blocking lock type.
func lockedOpenFile(path string, flag int, perm os.FileMode, lockType int) (*LockedFile, error) {
	switch flag {
	case syscall.O_RDONLY:
		lockType |= syscall.LOCK_SH
	case syscall.O_WRONLY:

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3

import okio.IOException

/**
 * Returns the trailers that follow an HTTP response, blocking if they aren't ready yet.
 * Implementations of this interface should respond to [Call.cancel] by immediately throwing an
 * [IOException].
 *

	}()

	select {
	case <-locked:
		t.Error("unexpected unblocking")
	case <-time.After(100 * time.Millisecond):
	}

	// unlock
	if err = dupl.Close(); err != nil {
		t.Fatal(err)
	}

	// the previously blocked routine should be unblocked
	select {
	case <-locked:
	case <-time.After(1 * time.Second):
		t.Error("unexpected blocking")
	}

)

_T = TypeVar("_T")


@asynccontextmanager
async def contextmanager_in_threadpool(
    cm: AbstractContextManager[_T],
) -> AsyncGenerator[_T, None]:
    # blocking __exit__ from running waiting on a free thread
    # can create race conditions/deadlocks if the context manager itself
    # has its own internal pool (e.g. a database connection pool)