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) {

        // Use single channel for small reads
        normalRead(buffer, offset, length);
        return;
    }
    
    // Split large read across multiple channels
    ChannelManager channelManager = session.getChannelManager();
    List<ChannelInfo> channels = channelManager.getHealthyChannels();
    int channelCount = Math.min(channels.size(), 4);  // Max 4 parallel reads
    
    int chunkSize = length / channelCount;

        assertEquals(TransPeekNamedPipeResponse.STATUS_LISTENING, response.getStatus());
        // Middle bytes were read but not used
    }

    @Test
    @DisplayName("Test consecutive reads update state correctly")
    void testConsecutiveReads() {
        // First read
        byte[] buffer1 = new byte[10];
        SMBUtil.writeInt2(100, buffer1, 0);
        SMBUtil.writeInt2(0, buffer1, 2);

     * just to be safe.
     *
     * The real purpose of this test is to produce a TSAN failure if MapIteratorCache is unsafe for
     * reads from multiple threads -- unsafe, in fact, even in the absence of a concurrent write.
     * The specific problem we had was unsafe reads of lastEntryReturnedBySomeIterator. (To fix the
     * problem, we've since marked that field as volatile.)
     *

    }

    @Override
    // TODO: b/227335009 - Maybe change interruption behavior, but it requires thought.
    @SuppressWarnings("Interruption")
    public void run() {
      // If either of these reads return null then we must be after a successful cancel or another
      // call to this method.
      TimeoutFuture<V> timeoutFuture = timeoutFutureRef;
      if (timeoutFuture == null) {
        return;
      }

import jcifs.Configuration;

@ExtendWith(MockitoExtension.class)
class BufferCacheImplTest {

    @Mock
    Configuration cfg;

    // Verifies constructor that accepts Configuration reads the expected values and uses them
    @Test
    @DisplayName("Constructor(Configuration) uses cache size and maximum buffer size from config")
    void constructorUsesConfigurationAndAllocatesWithConfiguredSize() {

        update(sequence, 0, sequence.length);
        index += 8;
        if (response.command == ServerMessageBlock.SMB_COM_READ_ANDX) {
            /* SmbComReadAndXResponse reads directly from the stream into separate byte[] b.
             */
            final SmbComReadAndXResponse raxr = (SmbComReadAndXResponse) response;
            final int length = response.length - raxr.dataLength;

		"Count of online drives")
	driveCountMD = NewGaugeMD(driveCount,
		"Count of all drives")

	// iostat related
	driveReadsPerSecMD = NewGaugeMD(driveReadsPerSec,
		"Reads per second on a drive",
		allDriveLabels...)
	driveReadsKBPerSecMD = NewGaugeMD(driveReadsKBPerSec,
		"Kilobytes read per second on a drive",
		allDriveLabels...)
	driveReadsAwaitMD = NewGaugeMD(driveReadsAwait,

	return
}

func newDriveMetricsCache() *cachevalue.Cache[storageMetrics] {
	var (
		// prevDriveIOStats is used to calculate "per second"
		// values for IOStat related disk metrics e.g. reads/sec.
		prevDriveIOStats            map[string]madmin.DiskIOStats
		prevDriveIOStatsMu          sync.RWMutex
		prevDriveIOStatsRefreshedAt time.Time
	)

        }
        SMBUtil.writeInt8(this.sessionId, dst, dstIndex + 40);

        return Smb2Constants.SMB2_HEADER_LENGTH;
    }

    /**
     * Reads the SMB2 header from the wire format.
     *
     * @param buffer the buffer to read from
     * @param bufferIndex the starting position in the buffer
     * @return number of bytes read
     */