_ = data[i]
	}
}

// Test that sender synchronizes with receiver even if the sender was blocked.
func TestNoRaceBlockedSendSync(t *testing.T) {
	c := make(chan *int, 1)
	c <- nil
	go func() {
		i := 42
		c <- &i
	}()
	// Give the sender time to actually block.
	// This sleep is completely optional: race report must not be printed
	// regardless of whether the sender actually blocks or not.

{!../../../docs_src/events/tutorial003.py!}
```

Der erste Teil der Funktion, vor dem `yield`, wird ausgeführt **bevor** die Anwendung startet.

Und der Teil nach `yield` wird ausgeführt, **nachdem** die Anwendung beendet ist.

### Asynchroner Kontextmanager

Wie Sie sehen, ist die Funktion mit einem `@asynccontextmanager` versehen.

Dadurch wird die Funktion in einen sogenannten „**asynchronen Kontextmanager**“ umgewandelt.

    public List<? extends UnboundRule> process() {
        List<UnboundRule> unboundRules = new ArrayList<UnboundRule>();
        for (RuleBinder binder : binders) {
            UnboundRule.Builder builder = UnboundRule.descriptor(String.valueOf(binder.getDescriptor()));

            ModelBinding subjectBinding = binder.getSubjectBinding();
            // Only report subject binding if target state is after node creation

        "invokeMethod(sender, receiver, methodName, arguments, false, false)" | { instance.metaClass.invokeMethod(getClass(), instance, "test", [].toArray(), false, false) } | true        | false

        // These should not be intercepted because of isCallToSuper and fromInsideClass

	if cr.err != nil {
		return
	}
	cr.n, cr.err = parseHexUint(line)
	if cr.err != nil {
		return
	}
	// A sender who sends one byte per chunk will send 5 bytes of overhead
	// for every byte of data. ("1\r\nX\r\n" to send "X".)
	// We want to allow this, since streaming a byte at a time can be legitimate.
	//
	// A sender can use chunk extensions to add arbitrary amounts of additional

# release notes.
releaseNotes:
- |
  **Improved** compatibility with minimal host OSses like Talos OS (without nsenter binary). Changes Network namespaces with internal go routines.

    const val MAX_CONCURRENT_STREAMS = 4

    /** HTTP/2: Size in bytes of the largest frame payload the sender will accept. */
    const val MAX_FRAME_SIZE = 5

    /** HTTP/2: Advisory only. Size in bytes of the largest header list the sender will accept. */
    const val MAX_HEADER_LIST_SIZE = 6

    /** Window size in bytes. */
    const val INITIAL_WINDOW_SIZE = 7

	go func() {
		defer close(errch)
		sentErr := false
		sendErr := func(err error) {
			if !sentErr {
				errch <- err
				sentErr = true
			}
		}

		// Copy our data to gzipWriter, which compresses it to
		// gzipWriter, which feeds it to bodyReader.
		if _, err := io.Copy(gzipWriter, dataReader); err != nil && err != io.ErrClosedPipe {
			sendErr(err)
		}

errors.document_not_found=URL der Dokument-ID nicht gefunden: {0}
errors.not_load_from_server=Konnte nicht vom Server geladen werden: {0}
errors.failed_to_start_job=Start der Aufgabe {0} fehlgeschlagen.
errors.failed_to_stop_job=Beenden der Aufgabe {0} fehlgeschlagen.
errors.failed_to_download_synonym_file=Download der Synonym-Datei fehlgeschlagen.
errors.failed_to_upload_synonym_file=Upload der Synonym-Datei fehlgeschlage.

			}
			return true, false
		}
		// The channel has been closed, but the channel's buffer have data.
	} else {
		// Just found waiting sender with not closed.
		if sg := c.sendq.dequeue(); sg != nil {
			// Found a waiting sender. If buffer is size 0, receive value
			// directly from sender. Otherwise, receive from head of queue
			// and add sender's value to the tail of the queue (both map to