docs: @Override
      public void updateConfig(Map<String, Object> props) {
          final long maxMS = TimeUnit.NANOSECONDS.toMillis(Long.MAX_VALUE);
  
          Object v;
          int u_expedite = (Integer) props.get("expedite");
          int u_max = null == (v = props.get("max")) ? Integer.MAX_VALUE : (Integer) v;
          MaxPolicy u_maxPolicy = MaxPolicy.valueOf((String) props.get("maxPolicy"));
          int u_maxQueueSize = null == (v = props.get("maxQueueSize")) ? Integer.MAX_VALUE : (Integer) v;
          long u_maxWaitForEnqueue = (Long) props.get("maxWaitForEnqueue");
          boolean u_runIfQueueFull = (Boolean) props.get("runIfQueueFull");
          long u_startTimeout = null == (v = props.get("startTimeout")) ? -1l : (Long) v;
  
          // Validation that cannot be performed by metatype:
          if (u_expedite > u_max)
              throw new IllegalArgumentException("expedite: " + u_expedite + " > max: " + u_max);
  
          if (u_maxWaitForEnqueue < 0 || u_maxWaitForEnqueue > maxMS)
              throw new IllegalArgumentException("maxWaitForEnqueue: " + u_maxWaitForEnqueue);
  
          if (u_startTimeout < -1 || u_startTimeout > maxMS)
              throw new IllegalArgumentException("startTimeout: " + u_startTimeout);
  
          for (long current = maxWaitForEnqueueNS.get(); current != -1; current = maxWaitForEnqueueNS.get())
              if (maxWaitForEnqueueNS.compareAndSet(current, TimeUnit.MILLISECONDS.toNanos(u_maxWaitForEnqueue)))
                  break;
  
          maxPolicy = u_maxPolicy;
          runIfQueueFull = u_runIfQueueFull;
          startTimeout = u_startTimeout == -1 ? -1 : TimeUnit.MILLISECONDS.toNanos(u_startTimeout);
  
          int a, queueCapacityAdded;
          synchronized (configLock) {
              a = expeditesAvailable.addAndGet(u_expedite - expedite);
              expedite = u_expedite;
  
              int increase = u_max - maxConcurrency;
              if (increase > 0)
                  maxConcurrencyConstraint.release(increase);
              else if (increase < 0)
                  maxConcurrencyConstraint.reducePermits(-increase);
              maxConcurrency = u_max;
  
              queueCapacityAdded = u_maxQueueSize - maxQueueSize;
              if (queueCapacityAdded > 0)
                  maxQueueSizeConstraint.release(queueCapacityAdded);
              else if (queueCapacityAdded < 0)
                  maxQueueSizeConstraint.reducePermits(-queueCapacityAdded);
              maxQueueSize = u_maxQueueSize;
          }
  
          if (queueCapacityAdded < 0) {
              Callback callback = cbQueueSize.get();
              if (callback != null
                  && maxQueueSizeConstraint.availablePermits() < callback.threshold
                  && cbQueueSize.compareAndSet(callback, null)) {
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                      Tr.debug(this, tc, "callback: queue capacity < " + callback.threshold, callback.runnable);
                  globalExecutor.submit(callback.runnable);
              }
          }
  
          // Expedite as many of the remaining tasks as the available maxConcurrency permits and increased expedites
          // will allow. We are choosing not to revoke GlobalPoolTasks that have already been enqueued as non-expedited,
          // which means we do not guarantee an increase in expedites to fully go into effect immediately.
          // Any reduction to expedites is handled gradually, as expedited GlobalPoolTasks complete.
          while (withheldConcurrency.get() > 0 && maxConcurrencyConstraint.tryAcquire()) {
              decrementWithheldConcurrency();
              if (a-- > 0 && acquireExpedite() > 0)
                  expediteGlobal(new GlobalPoolTask());
              else
                  enqueueGlobal(new GlobalPoolTask());
          }
      }