* thread) the subscriber is actually called when an event is dispatched to it.
 *
 * @author Colin Decker
 */
abstract class Dispatcher {

  /**
   * Returns a dispatcher that queues events that are posted reentrantly on a thread that is already
   * dispatching an event, guaranteeing that all events posted on a single thread are dispatched to

  }

  /**
   * Causes this thread to call the named method, and asserts that this thread becomes blocked on
   * the lock-like object. The lock-like object must have a method equivalent to {@link
   * java.util.concurrent.locks.ReentrantLock#hasQueuedThread(Thread)}.
   */
  public void callAndAssertBlocks(String methodName, Object... arguments) throws Exception {

        }
      }
    } finally {
      if (interrupted) {
        Thread.currentThread().interrupt();
      }
    }
  }

  /** Invokes {@code toJoin.}{@link Thread#join() join()} uninterruptibly. */
  @J2ktIncompatible
  @GwtIncompatible // concurrency
  public static void joinUninterruptibly(Thread toJoin) {
    boolean interrupted = false;
    try {
      while (true) {
        try {

     *       observing a null thread does not mean the object is safe to reuse.
     *   <li>If this field's value is some other thread object, we know that it's not our thread.
     *   <li>If this field's value == null because it originally belonged to another thread and that
     *       thread cleared it, we still know that it's not associated with our thread

            int nextValue = counter + 1;
            Thread.yield();
            counter = nextValue;
            return counter;
          }
        };

    int numThreads = 10;
    int iterations = 1000;
    Thread[] threads = new Thread[numThreads];
    for (int i = 0; i < numThreads; i++) {
      threads[i] =
          new Thread() {
            @Override
            public void run() {

            int nextValue = counter + 1;
            Thread.yield();
            counter = nextValue;
            return counter;
          }
        };

    int numThreads = 10;
    int iterations = 1000;
    Thread[] threads = new Thread[numThreads];
    for (int i = 0; i < numThreads; i++) {
      threads[i] =
          new Thread() {
            @Override
            public void run() {

public class BuildThreadFactory implements ThreadFactory {
    private final AtomicInteger id = new AtomicInteger();

    private static final String PREFIX = "BuilderThread";

    @Override
    public Thread newThread(Runnable r) {
        return new Thread(r, String.format("%s-%d", PREFIX, id.getAndIncrement()));
    }

So we have a dedicated thread for every socket that just reads frames and dispatches them.

The reader thread must never run application-layer code. Otherwise one slow stream can hold up the entire connection.

    }

    /**
     * Test thread safety of read/write operations
     */
    @Test
    @DisplayName("Test thread safety of operations")
    public void testThreadSafety() throws InterruptedException {
        // Given
        smbComTreeDisconnect = new SmbComTreeDisconnect(config);
        byte[] buffer = new byte[1000];
        int numThreads = 10;
        Thread[] threads = new Thread[numThreads];

    assertEquals(0, ticker.read());
    assertEquals(10, ticker.read());
    assertEquals(20, ticker.read());
  }

  public void testAutoIncrementStep_millis() {
    FakeTicker ticker = new FakeTicker().setAutoIncrementStep(1, MILLISECONDS);
    assertEquals(0, ticker.read());
    assertEquals(1000000, ticker.read());
    assertEquals(2000000, ticker.read());
  }