* atomic unless otherwise noted.
 *
 * <p>Instances of this class are serializable if the keys are serializable.
 *
 * <p><b>Note:</b> If your values are always positive and less than 2^31, you may wish to use a
 * {@link com.google.common.collect.Multiset} such as {@link
 * com.google.common.collect.ConcurrentHashMultiset} instead.
 *

	}

	err := lockFileEx(fd, flags, 1, 0, &syscall.Overlapped{})
	if err == nil || err == errLockViolation {
		return nil
	}
	if err.Error() == "The process cannot access the file because another process has locked a portion of the file." {
		return ErrAlreadyLocked
	}
	return err
}

func lockFileEx(h syscall.Handle, flags, locklow, lockhigh uint32, ol *syscall.Overlapped) (err error) {
	reserved := uint32(0)

  private HostAndPort(String host, int port, boolean hasBracketlessColons) {
    this.host = host;
    this.port = port;
    this.hasBracketlessColons = hasBracketlessColons;
  }

  /**
   * Returns the portion of this {@code HostAndPort} instance that should represent the hostname or
   * IPv4/IPv6 literal.
   *
   * <p>A successful parse does not imply any degree of sanity in this field. For additional

    CacheTesting.checkValidState(cache);
  }

  /**
   * With an unlimited-size cache with maxWeight of 0, entries weighing 0 should still be cached.
   * Entries with positive weight should not be cached (nor dump existing cache).
   */
  public void testEviction_maxWeight_zero() {
    CountingRemovalListener<Integer, Integer> removalListener = countingRemovalListener();

            // When: Getting max transmission values
            int maxRecv = handle.getMaxRecv();
            int maxXmit = handle.getMaxXmit();

            // Then: Should return positive values
            assertTrue(maxRecv > 0);
            assertTrue(maxXmit > 0);
        }
    }

        ndrBuffer.reset();
        ndrBuffer.enc_ndr_referent(obj1, 2);
        assertEquals(4, ndrBuffer.getIndex());
        int referent1 = Encdec.dec_uint32le(buffer, 0);
        assertTrue(referent1 > 0); // Should be a positive referent ID

        ndrBuffer.reset();
        ndrBuffer.enc_ndr_referent(obj1, 2); // Same object, should get same referent
        assertEquals(4, ndrBuffer.getIndex());

                        allocations.incrementAndGet();

                        assertNotNull(buffer, "Buffer should not be null");
                        assertTrue(buffer.length > 0, "Buffer should have positive length");

                        // Test release performance
                        long releaseStart = System.nanoTime();
                        BufferCache.releaseBuffer(buffer);

Par opposition à une « **image de conteneur** » qui correspond aux contenus statiques stockés, un « **conteneur** » fait normalement référence à l'instance en cours d'exécution, la chose qui est **exécutée**.

 *
 * @author Dimitris Andreou
 * @author Kurt Alfred Kluever
 * @since 11.0
 */
public abstract class HashCode {
  HashCode() {}

  /** Returns the number of bits in this hash code; a positive multiple of 8. */
  public abstract int bits();

  /**
   * Returns the first four bytes of {@linkplain #asBytes() this hashcode's bytes}, converted to an
   * {@code int} value in little-endian order.
   *

                if (coreMultiplier <= 0.0f) {
                    throw new IllegalArgumentException("Invalid threads core multiplier value: '" + threadConfiguration
                            + "'. Value must be positive.");
                }

                int procs = Runtime.getRuntime().availableProcessors();
                int threads = (int) (coreMultiplier * procs);
                return threads == 0 ? 1 : threads;