// Load the "normal" copy of SettableFuture and related classes.
    SettableFuture<?> unused = SettableFuture.create();
    // Hack to load AbstractFuture et. al. in a new classloader so that it re-reads the cancellation
    // cause system property.  This allows us to run with both settings of the property in one jvm
    // without resorting to even crazier hacks to reset static final boolean fields.

    public T get() {
      // Another variant of Double Checked Locking.
      //
      // We use two volatile reads. We could reduce this to one by
      // putting our fields into a holder class, but (at least on x86)
      // the extra memory consumption and indirection are more
      // expensive than the extra volatile reads.
      long nanos = expirationNanos;
      long now = System.nanoTime();
      if (nanos == 0 || now - nanos >= 0) {

            } catch (Exception e) {
                exceptions.add(e);
            } finally {
                endLatch.countDown();
            }
        });

        // Thread 2: Continuously reads trees
        executor.submit(() -> {
            try {
                for (int i = 0; i < iterations; i++) {
                    // This would cause ConcurrentModificationException with ArrayList

            // Arrange
            String uuidWithExtra = VALID_UUID_STRING + "EXTRA";

            // Act
            UUID uuid = new UUID(uuidWithExtra);

            // Assert - The implementation only reads what it needs
            assertEquals(TIME_LOW, uuid.time_low);
            assertEquals(TIME_MID, uuid.time_mid);
            assertEquals(TIME_HI_AND_VERSION, uuid.time_hi_and_version);

	"Path": "/ref/mem"
}-->

<style>
p.rule {
  font-style: italic;
}
</style>

<h2 id="introduction">Introduction</h2>

<p>
The Go memory model specifies the conditions under which
reads of a variable in one goroutine can be guaranteed to
observe values produced by writes to the same variable in a different goroutine.
</p>


<h3 id="advice">Advice</h3>

<p>

		"Cluster object size distribution", "range")
	usageVersionsDistributionMD = NewGaugeMD(usageVersionCountDistribution,
		"Cluster object version count distribution", "range")
)

// loadClusterUsageObjectMetrics - reads cluster usage metrics.
//
// This is a `MetricsLoaderFn`.
func loadClusterUsageObjectMetrics(ctx context.Context, m MetricValues, c *metricsCache) error {
	dataUsageInfo, err := c.dataUsageInfo.Get()
	if err != nil {

      return ByteStreams.copy(in, out);
    } catch (Throwable e) {
      throw closer.rethrow(e);
    } finally {
      closer.close();
    }
  }

  /**
   * Reads the full contents of this byte source as a byte array.
   *
   * @throws IOException if an I/O error occurs while reading from this source
   */
  public byte[] read() throws IOException {

   * [RequestBody.writeTo] after that method returns. For duplex requests bodies that condition is
   * lifted. Such writes occur on an application-provided thread and may occur concurrently with
   * reads of the [ResponseBody]. For duplex request bodies, [writeTo] should return
   * quickly, possibly by handing off the provided request body to another thread to perform
   * writing.
   *

   * concurrently readable hash table. The map supports non-blocking reads and concurrent writes
   * across different segments.
   *
   * The page replacement algorithm's data structures are kept casually consistent with the map. The
   * ordering of writes to a segment is sequentially consistent. An update to the map and recording
   * of reads may not be immediately reflected on the algorithm's data structures. These structures

                0x00, 0x00, 0x00, 0x00, 0x00, 0x01, // authority
                0x00, 0x00, 0x00, 0x00 // sub-authority 1
        };
        PacDataInputStream pdis = createInputStream(data);
        SID sid = pdis.readSid();
        assertEquals("S-1-1-0", sid.toString());
    }

    @Test
    public void testSkipBytes() throws IOException {
        byte[] data = new byte[] { 0x01, 0x02, 0x03, 0x04 };