}

  /**
   * Creates a {@code Striped<Lock>} with eagerly initialized, strongly referenced locks. Every lock
   * is reentrant.
   *
   * @param stripes the minimum number of stripes (locks) required
   * @return a new {@code Striped<Lock>}
   */
  public static Striped<Lock> lock(int stripes) {
    return custom(stripes, PaddedLock::new);
  }

  /**

  }

  /**
   * Creates a {@code Striped<Lock>} with eagerly initialized, strongly referenced locks. Every lock
   * is reentrant.
   *
   * @param stripes the minimum number of stripes (locks) required
   * @return a new {@code Striped<Lock>}
   */
  public static Striped<Lock> lock(int stripes) {
    return custom(stripes, PaddedLock::new);
  }

  /**

    for (Striped<?> striped : allImplementations()) {
      assertBasicInvariants(striped);
    }
  }

  private static void assertBasicInvariants(Striped<?> striped) {
    Set<Object> observed = Sets.newIdentityHashSet(); // for the sake of weakly referenced locks.
    // this gets the stripes with #getAt(index)
    for (int i = 0; i < striped.size(); i++) {
      Object object = striped.getAt(i);
      assertNotNull(object);

    for (Striped<?> striped : allImplementations()) {
      assertBasicInvariants(striped);
    }
  }

  private static void assertBasicInvariants(Striped<?> striped) {
    Set<Object> observed = Sets.newIdentityHashSet(); // for the sake of weakly referenced locks.
    // this gets the stripes with #getAt(index)
    for (int i = 0; i < striped.size(); i++) {
      Object object = striped.getAt(i);
      assertNotNull(object);

                    producing.notifyAll();
                }
            }
        }
    }

    private static class StripedProducerGuard<T> extends ProducerGuard<T> {
        private final Striped<Lock> locks = Striped.lock(Runtime.getRuntime().availableProcessors() * 4);

        @Override
        public <V> V guardByKey(T key, Supplier<V> supplier) {
            Lock lock = locks.get(key);
            lock.lock();

                        }
                    })
                }
            }
        }

        then:
        calls.get() == 100

        where:
        guard << [ProducerGuard.serial(), ProducerGuard.striped(), ProducerGuard.adaptive()]
    }

    def "does not call factories with the same key concurrently"() {
        def concurrentCalls = new AtomicInteger()

        when:
        async {
            100.times {

}
table.striped {
    border-collapse: collapse;
    border: 1px solid var(--table-border-color);
}
table.striped > thead {
    background-color: var(--subnav-background-color);
}
table.striped > thead > tr > th, table.striped > thead > tr > td {
    border: 1px solid var(--table-border-color);
}
table.striped > tbody > tr:nth-child(even) {

            virtualFileSystem.invalidateAll();
        }
    }

    private static class StripedProducerGuard<T> {
        private final Striped<Lock> locks = Striped.lock(Runtime.getRuntime().availableProcessors() * 4);

        public <V> V guardByKey(T key, Supplier<V> supplier) {
            Lock lock = locks.get(key);
            lock.lock();
            try {

        }
    }

    String getOptionsAsHtml() {
        StringBuilder sb = new StringBuilder(512);
        boolean odd = true;
        sb.append(
                "<table border='1' class='zebra-striped'><tr class='a'><th><b>Options</b></th><th><b>Description</b></th></tr>");
        for (Option option : new CLIManagerExtension().getOptions()) {
            odd = !odd;
            sb.append("<tr class='");

	for _, numKeys := range []int{1 << 8, 1 << 12, 1 << 16} {
		b.Run(fmt.Sprintf("Simple/keys=%d", numKeys), func(b *testing.B) {
			benchmarkCache(newSimpleCache(clock.RealClock{}), b, numKeys)
		})
		b.Run(fmt.Sprintf("Striped/keys=%d", numKeys), func(b *testing.B) {
			benchmarkCache(newStripedCache(32, fnvHashFunc, func() cache { return newSimpleCache(clock.RealClock{}) }), b, numKeys)
		})
	}
}

func TestStripedCache(t *testing.T) {