}

	st, err := gridConn.NewStream(ctx, grid.HandlerTrace, payload)
	if err != nil {
		return
	}
	st.Results(func(b []byte) error {
		select {
		case traceCh <- b:
		default:
			// Do not block on slow receivers.
			// Just recycle the buffer.
			grid.PutByteBuffer(b)
		}
		return nil
	})
}

func (client *peerRESTClient) doListen(ctx context.Context, listenCh chan<- []byte, v url.Values) {

    protected String name = "Transport" + id++;
    private volatile Thread thread;
    private volatile TransportException te;

    /**
     * Lock object for synchronizing input operations
     */
    protected final Object inLock = new Object();
    /**
     * Lock object for synchronizing output operations
     */
    protected final Object outLock = new Object();

    /**

        });
  }

  // We call the method only after checking that it's present.
  @IgnoreJRERequirement
  @SuppressWarnings({
    "Java8ApiChecker",
    // This method is a helper, which we call from a `finally` block, as recommended.
    "ReachabilityFenceUsage",
  })
  static void reachabilityFence(@Nullable Object o) {
    if (IS_REACHABILITY_FENCE_METHOD_USABLE) {
      Reference.reachabilityFence(o);
    }
  }

Nur damit es in derselben Datei leben kann, für dieses Beispiel, und Sie es unverändert kopieren und ausführen können. 🥚

///

Mit einem `with`-Block stellen wir sicher, dass das dateiähnliche Objekt geschlossen wird, nachdem die Generatorfunktion (die Funktion mit `yield`) fertig ist. Also nachdem die Response gesendet wurde.

    }

    @Override
    public E element() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.element();
    }

    @Override
    public Iterator<E> iterator() {
      // We explicitly don't lock for iterator()
      assertFalse(Thread.holdsLock(mutex));
      return delegate.iterator();
    }

    @Override
    public int size() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.size();

  protected void shutDown() throws Exception {}

  /**
   * Invoked to request the service to stop.
   *
   * <p>By default this method does nothing.
   *
   * <p>Currently, this method is invoked while holding a lock. If an implementation of this method
   * blocks, it can prevent this service from changing state. If you need to performing a blocking
   * operation in order to trigger shutdown, consider instead registering a listener and

        if (metadataFile.length() == 0) {
            if (!metadataFile.delete()) {
                // sleep for 10ms just in case this is windows holding a file lock
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    // ignore
                }

 * License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License)
 */

    }

    /**
     * Session identifier for the crawling session.
     */
    protected String sessionId;

    /**
     * Atomic counter for tracking active crawler threads without lock contention.
     */
    protected final AtomicInteger activeThreadCount = new AtomicInteger(0);

    /**
     * Atomic counter for tracking the number of accesses made.
     */

	// Max time between client calls before dropping an async cache listing.
	metacacheMaxClientWait = 3 * time.Minute

	// metacacheBlockSize is the number of file/directory entries to have in each block.
	metacacheBlockSize = 5000

	// metacacheSharePrefix controls whether prefixes on dirty paths are always shared.
	// This will make `test/a` and `test/b` share listings if they are concurrent.