}

  /**
   * Checks that the threads do not terminate within the default millisecond delay of {@code
   * timeoutMillis()}.
   */
  void assertThreadsStayAlive(Thread... threads) {
    assertThreadsStayAlive(timeoutMillis(), threads);
  }

  /** Checks that the threads do not terminate within the given millisecond delay. */
  void assertThreadsStayAlive(long millis, Thread... threads) {
    try {

                    def threadGroup = Thread.currentThread().threadGroup
                    println "\\nWorker Executor threads:"
                    def threads = new Thread[threadGroup.activeCount()]
                    threadGroup.enumerate(threads)
                    def executorThreads = threads.findAll { it?.name?.startsWith("${WorkerExecutionQueueFactory.QUEUE_DISPLAY_NAME}") }
                    executorThreads.each { println it }

	m.clear(nextq)
	return m.matched
}

// clear frees all threads on the thread queue.
func (m *machine) clear(q *queue) {
	for _, d := range q.dense {
		if d.t != nil {
			m.pool = append(m.pool, d.t)
		}
	}
	q.dense = q.dense[:0]
}

// step executes one step of the machine, running each of the threads
// on runq and appending new threads to nextq.
// The step processes the rune c (which may be endOfText),

  }

  /**
   * Checks that the threads do not terminate within the default millisecond delay of {@code
   * timeoutMillis()}.
   */
  void assertThreadsStayAlive(Thread... threads) {
    assertThreadsStayAlive(timeoutMillis(), threads);
  }

  /** Checks that the threads do not terminate within the given millisecond delay. */
  void assertThreadsStayAlive(long millis, Thread... threads) {
    try {

        def block3 = write("test 3")

        read(block2) == "test 2"
        read(block3) == "test 3"
        read(block1) == "test 1"
    }

    def "can write blocks and read block from multiple threads"() {
        expect:
        def blocks = new ConcurrentHashMap<Integer, BlockAddress>()
        async {
            10.times { index ->
                start {
                    blocks[index] = write("test $index")

 * since an iteration across all row keys occurs.
 *
 * <p>Note that this implementation is not synchronized. If multiple threads access this table
 * concurrently and one of the threads modifies the table, it must be synchronized externally.
 *
 * <p>See the Guava User Guide article on <a href=

 * since an iteration across all row keys occurs.
 *
 * <p>Note that this implementation is not synchronized. If multiple threads access this table
 * concurrently and one of the threads modifies the table, it must be synchronized externally.
 *
 * <p>See the Guava User Guide article on <a href=

        1 * target.get("key") >> null
        1 * producer.apply("key") >> { throw failure }
        1 * completion.run()
        0 * _
    }

    def "produces value once when requested from multiple threads"() {
        def producer = Mock(Function)

        when:
        def result1
        def result2
        def result3
        def result4
        async {
            start {

     *
     * <p>Note that the caller must call {@link WorkerLeaseRegistry.WorkerLeaseCompletion#leaseFinish()} to mark the completion of the lease and to release the lease for other threads to use.
     *
     * <p>It is generally better to use {@link WorkerThreadRegistry#runAsWorkerThread(Runnable)} instead of this method.</p>
     */
    WorkerLeaseRegistry.WorkerLeaseCompletion startWorker();

    /**

import org.openjdk.jmh.annotations.Threads;
import org.openjdk.jmh.annotations.Warmup;
import org.openjdk.jmh.infra.Blackhole;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.Map;
import java.util.UUID;

@SuppressWarnings("Since15")
@Threads(2)
@Warmup(iterations = 5)