// we launched a new worker.
		if mainWorker && len(h.logCh) > cap(h.logCh)/2 {
			nWorkers := h.workers.Load()
			if nWorkers < h.maxWorkers {
				if time.Since(h.lastStarted).Milliseconds() > 10 {
					h.lastStarted = time.Now()
					go h.startQueueProcessor(ctx, false)
				}
			}
		}

		var err error
		if !isDirQueue {

import static java.util.Arrays.asList;
import static java.util.concurrent.Executors.newSingleThreadExecutor;
import static java.util.concurrent.Executors.newSingleThreadScheduledExecutor;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.NANOSECONDS;
import static java.util.concurrent.TimeUnit.SECONDS;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;

import static java.util.Arrays.asList;
import static java.util.concurrent.Executors.newSingleThreadExecutor;
import static java.util.concurrent.Executors.newSingleThreadScheduledExecutor;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.NANOSECONDS;
import static java.util.concurrent.TimeUnit.SECONDS;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;

      .isEqualTo(TimeUnit.MILLISECONDS.toNanos(456))
  }

  @Test
  fun timeoutWritingRequest() {
    server.enqueue(MockResponse())
    val request =
      Request
        .Builder()
        .url(server.url("/"))
        .post(sleepingRequestBody(500))
        .build()
    val call = client.newCall(request)
    call.timeout().timeout(250, TimeUnit.MILLISECONDS)
    assertFailsWith<IOException> {

}
```

### 3.2 Handle Capabilities
```java
public class Smb2HandleCapabilities {
    // Durable handle flags
    public static final int SMB2_DHANDLE_FLAG_PERSISTENT = 0x00000002;
    
    // Timeout values (milliseconds)
    public static final long DEFAULT_DURABLE_TIMEOUT = 120000;  // 2 minutes
    public static final long MAX_DURABLE_TIMEOUT = 300000;      // 5 minutes

    queue.schedule("task", TimeUnit.MILLISECONDS.toNanos(100)) {
      log.put("failing task running")
      throw RuntimeException("boom!")
    }

    queue.schedule("task", TimeUnit.MILLISECONDS.toNanos(200)) {
      log.put("normal task running")
      return@schedule -1L
    }

    queue.idleLatch().await(500, TimeUnit.MILLISECONDS)

    assertThat(log.take()).isEqualTo("failing task running")

        public TimeOfDayInfo() {
        }

        /**
         * The time elapsed since 00:00:00, January 1, 1970 GMT.
         */
        public int elapsedt;
        /**
         * The number of milliseconds from the start of the current second.
         */
        public int msecs;
        /**
         * The current hour (0-23).
         */
        public int hours;
        /**

        /**
         * Indicates if the search results are partial.
         */
        protected boolean partial;
        /**
         * The time taken for the search query in milliseconds.
         */
        protected long queryTime;
        /**
         * The search query string.
         */
        protected String searchQuery;
        /**

        .build()

    // Copy to customize OkHttp for this request.
    val client1 =
      client
        .newBuilder()
        .readTimeout(500, TimeUnit.MILLISECONDS)
        .build()
    try {
      client1.newCall(request).execute().use { response ->
        println("Response 1 succeeded: $response")
      }
    } catch (e: IOException) {

        .build();

    // Copy to customize OkHttp for this request.
    OkHttpClient client1 = client.newBuilder()
        .readTimeout(500, TimeUnit.MILLISECONDS)
        .build();
    try (Response response = client1.newCall(request).execute()) {
      System.out.println("Response 1 succeeded: " + response);
    } catch (IOException e) {