org.springframework.boot.context.embedded.EmbeddedServletContainerFactory#org.eclipse.jetty.util.thread.QueuedThreadPool源码实例Demo

@Override
public void afterPropertiesSet() throws Exception {
	String name = this.threadPrefix + "@" + Integer.toHexString(hashCode());
	if (this.executor == null) {
		QueuedThreadPool threadPool = new QueuedThreadPool();
		threadPool.setName(name);
		this.executor = threadPool;
	}
	if (this.byteBufferPool == null) {
		this.byteBufferPool = new MappedByteBufferPool(2048,
				this.executor instanceof ThreadPool.SizedThreadPool
						? ((ThreadPool.SizedThreadPool) executor).getMaxThreads() / 2
						: ProcessorUtils.availableProcessors() * 2);
	}
	if (this.scheduler == null) {
		this.scheduler = new ScheduledExecutorScheduler(name + "-scheduler", false);
	}

	if (this.executor instanceof LifeCycle) {
		((LifeCycle)this.executor).start();
	}
	this.scheduler.start();
}
 

/**
 * Creates and configures a new Jetty instance.
 *
 * @param props the configuration
 */
public JettyServer(final NiFiProperties props) {
    final QueuedThreadPool threadPool = new QueuedThreadPool(props.getWebThreads());
    threadPool.setName("NiFi Web Server");

    // create the server
    this.server = new Server(threadPool);
    this.props = props;

    // enable the annotation based configuration to ensure the jsp container is initialized properly
    final Configuration.ClassList classlist = Configuration.ClassList.setServerDefault(server);
    classlist.addBefore(JettyWebXmlConfiguration.class.getName(), AnnotationConfiguration.class.getName());

    // configure server
    configureConnectors(server);

    // load wars from the nar working directories
    loadWars(locateNarWorkingDirectories());
}
 

@VisibleForTesting
protected Server configureServer() throws IOException, GeneralSecurityException {
    int maxThreads = 250;
    int minThreads = 10;
    int lowThreads = 50;
    int threadsPriority = 9;
    int idleTimeout = new Long(TimeUnit.MINUTES.toMillis(15)).intValue();

    QueuedThreadPool threadPool = new QueuedThreadPool(maxThreads, minThreads, idleTimeout);
    threadPool.setLowThreadsThreshold(lowThreads);
    threadPool.setThreadsPriority(threadsPriority);

    Server server = new Server(threadPool);

    ServerConnector connector = cmd.isSslEnabled() ? getServerConnector(server) : new ServerConnector(server);
    connector.setHost(cmd.getHost());
    connector.setPort(cmd.getPort());

    server.setConnectors(new Connector[] {connector});

    return server;
}
 

public void startJettyContainer() throws Exception {
    jettyServer = new Server(serviceProperties.getServicePort());
    org.eclipse.jetty.util.thread.ThreadPool threadPool = jettyServer.getThreadPool();
    if (threadPool instanceof QueuedThreadPool) {
        ((QueuedThreadPool) threadPool).setMaxThreads(FeatureFlags.getMaxJettyThreads(serviceProperties));
        ((QueuedThreadPool) threadPool).setMinThreads(FeatureFlags.getMinJettyThreads(serviceProperties));
    } else {
        logger.warn("Expected ThreadPool to be instance of QueuedThreadPool, but was {}",
                jettyServer.getThreadPool().getClass().getName());
    }
    JettyComposer.compose(jettyServer);
    jettyServer.start();
    int port = ((ServerConnector) jettyServer.getConnectors()[0]).getLocalPort();
    logger.info("Jetty has started on port {}", port);
    serviceProperties.setServicePort(port);
}
 

private LegacyHttpServer(int port, int threads) {
  this.server = new Server(new QueuedThreadPool(threads));
  server.setHandler(
      new AbstractHandler() {
        @Override
        public void handle(
            String target,
            Request baseRequest,
            HttpServletRequest request,
            HttpServletResponse response)
            throws IOException {
          final String method = baseRequest.getParameter("method");
          if ("helloworld.Greeter/SayHello".equals(method)) {
            baseRequest.setHandled(true);
            sayHello(baseRequest, response);
          }
        }
      });

  final ServerConnector connector = new ServerConnector(server);
  connector.setPort(port);
  server.addConnector(connector);
}
 

private void initHttpServer() {

        final String serverIp = cfg.getServerIp();
        final int serverPort = cfg.getServerPort();

        // 如果IP:PORT已经被占用，则无法继续被绑定
        // 这里说明下为什么要这么无聊加个这个判断，让Jetty的Server.bind()抛出异常不是更好么？
        // 比较郁闷的是，如果这个端口的绑定是"SO_REUSEADDR"端口可重用的模式，那么这个server是能正常启动，但无法正常工作的
        // 所以这里必须先主动检查一次端口占用情况，当然了，这里也会存在一定的并发问题，BUT，我认为这种概率事件我可以选择暂时忽略
        if (isPortInUsing(serverIp, serverPort)) {
            throw new IllegalStateException(format("address[%s:%s] already in using, server bind failed.",
                    serverIp,
                    serverPort
            ));
        }

        httpServer = new Server(new InetSocketAddress(serverIp, serverPort));
        QueuedThreadPool qtp = new QueuedThreadPool();
        // jetty线程设置为daemon，防止应用启动失败进程无法正常退出
        qtp.setDaemon(true);
        qtp.setName("sandbox-jetty-qtp-" + qtp.hashCode());
        httpServer.setThreadPool(qtp);
    }
 

public PitchforkService(final Config config, final ZipkinSpanProcessorFactory processorFactory) {
    this.cfg = HttpConfig.from(config);
    final QueuedThreadPool threadPool = new QueuedThreadPool(cfg.getMaxThreads(), cfg.getMinThreads(), cfg.getIdleTimeout());
    server = new Server(threadPool);

    final ServerConnector httpConnector = new ServerConnector(server, new HttpConnectionFactory(new HttpConfiguration()));
    httpConnector.setPort(cfg.getPort());
    httpConnector.setIdleTimeout(cfg.getIdleTimeout());
    server.addConnector(httpConnector);

    final ServletContextHandler context = new ServletContextHandler(server, "/");
    addResources(context, processorFactory);

    if (cfg.isGzipEnabled()) {
        final GzipHandler gzipHandler = new GzipHandler();
        gzipHandler.setInflateBufferSize(cfg.getGzipBufferSize());
        context.setGzipHandler(gzipHandler);
    }

    server.setStopTimeout(cfg.getStopTimeout());
    logger.info("pitchfork has been initialized successfully !");
}
 

public JettyServer(final NiFiRegistryProperties properties, final CryptoKeyProvider cryptoKeyProvider, final String docsLocation) {
    final QueuedThreadPool threadPool = new QueuedThreadPool(properties.getWebThreads());
    threadPool.setName("NiFi Registry Web Server");

    this.properties = properties;
    this.masterKeyProvider = cryptoKeyProvider;
    this.docsLocation = docsLocation;
    this.server = new Server(threadPool);

    // enable the annotation based configuration to ensure the jsp container is initialized properly
    final Configuration.ClassList classlist = Configuration.ClassList.setServerDefault(server);
    classlist.addBefore(JettyWebXmlConfiguration.class.getName(), AnnotationConfiguration.class.getName());

    try {
        configureConnectors();
        loadWars();
    } catch (final Throwable t) {
        startUpFailure(t);
    }
}
 

/**
 * Configures the embedded jetty server. The values are configured in <b>application.yaml</b>
 * file.
 *
 * @param port jetty server port
 * @param maxThreads thread pool min thread
 * @param minThreads thread pool max thread
 * @param idleTimeout maximum thread idle time
 * @param jmxEnabled true, if jetty jmx is enabled.
 * @return {@link JettyEmbeddedServletContainerFactory}
 */
@Bean
public JettyEmbeddedServletContainerFactory jettyEmbeddedServletContainerFactory(
    @Value("${server.port:8443}") final int port,
    @Value("${jetty.thread-pool.max-threads:200}") final int maxThreads,
    @Value("${jetty.thread-pool.min-threads:8}") final int minThreads,
    @Value("${jetty.thread-pool.idle-timeout:60000}") final int idleTimeout,
    @Value("${jetty.jmx.enabled:true}") final boolean jmxEnabled) {
  log.info("Configuring Jetty server.");
  final JettyEmbeddedServletContainerFactory factory =
      new JettyEmbeddedServletContainerFactory(port);
  factory.addServerCustomizers(
      server -> {
        final QueuedThreadPool threadPool = server.getBean(QueuedThreadPool.class);
        threadPool.setMinThreads(minThreads);
        threadPool.setMaxThreads(maxThreads);
        threadPool.setIdleTimeout(idleTimeout);
        log.info("Server thread pool config:  " + server.getThreadPool());
        // Jetty JMX config.
        if (jmxEnabled) {
          log.info("Exposing Jetty managed beans to the JMX platform server.");
          server.addBean(new MBeanContainer(ManagementFactory.getPlatformMBeanServer()));
        }
      });
  return factory;
}
 

/**
 * Creates the Jetty server instance for the admin Dashboard and configures it with the @Named("DashboardContext").
 * @param port where the service is available
 * @param acceptorThreads no. of acceptors
 * @param maxWorkerThreads max no. of worker threads
 * @return Jetty Server instance
 */
@Named("DashboardJettyServer")
@Provides
@Singleton
Server getDashboardJettyServer(@Named("Dashboard.service.port") int port,
		@Named("Dashboard.service.acceptors") int acceptorThreads,
		@Named("Dashboard.service.selectors") int selectorThreads,
		@Named("Dashboard.service.workers") int maxWorkerThreads,
		@Named("DashboardContext") WebAppContext webappContext) {
	QueuedThreadPool threadPool = new QueuedThreadPool();
       threadPool.setMaxThreads(maxWorkerThreads);
	Server server = new Server(threadPool);
	ServerConnector http = new ServerConnector(server, acceptorThreads, selectorThreads);
	http.setPort(port);
	server.addConnector(http);
	server.setHandler(webappContext);
	server.setStopAtShutdown(true);
	return server;
}
 

/**
 * Creates the Jetty server instance for the admin Dashboard and configures it with the @Named("ExecutionDashboardContext").
 * @param port where the service is available
 * @param acceptorThreads no. of acceptors
 * @param maxWorkerThreads max no. of worker threads
 * @return Jetty Server instance
 */
@Named("ExecutionDashboardJettyServer")
@Provides
@javax.inject.Singleton
Server getExecutionDashboardJettyServer(@Named("ExecutionDashboard.service.port") int port,
                               @Named("ExecutionDashboard.service.acceptors") int acceptorThreads,
                               @Named("ExecutionDashboard.service.selectors") int selectorThreads,
                               @Named("ExecutionDashboard.service.workers") int maxWorkerThreads,
                               @Named("ExecutionDashboardContext") WebAppContext webappContext) {
    QueuedThreadPool threadPool = new QueuedThreadPool();
    threadPool.setMaxThreads(maxWorkerThreads);
    Server server = new Server(threadPool);
    ServerConnector http = new ServerConnector(server, acceptorThreads, selectorThreads);
    http.setPort(port);
    server.addConnector(http);
    server.setHandler(webappContext);
    server.setStopAtShutdown(true);
    return server;
}
 

public JavaNetReverseProxy(File cacheFolder) throws Exception {
    this.cacheFolder = cacheFolder;
    cacheFolder.mkdirs();
    QueuedThreadPool qtp = new QueuedThreadPool();
    qtp.setName("Jetty (JavaNetReverseProxy)");
    server = new Server(qtp);

    ContextHandlerCollection contexts = new ContextHandlerCollection();
    server.setHandler(contexts);

    ServletContextHandler root = new ServletContextHandler(contexts, "/", ServletContextHandler.SESSIONS);
    root.addServlet(new ServletHolder(this), "/");

    ServerConnector connector = new ServerConnector(server);
    server.addConnector(connector);
    server.start();

    localPort = connector.getLocalPort();
}
 

@SuppressWarnings("squid:S2095")
private Server createRedirectorServer() {
  int unsecurePort = conf.get(HTTP_PORT_KEY, HTTP_PORT_DEFAULT);
  String hostname = conf.get(HTTP_BIND_HOST, HTTP_BIND_HOST_DEFAULT);

  QueuedThreadPool qtp = new QueuedThreadPool(25);
  qtp.setName(serverName + "Redirector");
  qtp.setDaemon(true);
  Server server = new LimitedMethodServer(qtp);
  InetSocketAddress addr = new InetSocketAddress(hostname, unsecurePort);
  ServerConnector connector = new ServerConnector(server);
  connector.setHost(addr.getHostName());
  connector.setPort(addr.getPort());
  server.setConnectors(new Connector[]{connector});

  ServletContextHandler context = new ServletContextHandler();
  context.addServlet(new ServletHolder(new RedirectorServlet()), "/*");
  context.setContextPath("/");
  server.setHandler(context);
  return server;
}
 

/**
 * Start Mock Websocket server that acts as backend.
 * @throws Exception exception on websocket server start
 */
private static void startWebsocketServer() throws Exception {

  backendServer = new Server(new QueuedThreadPool(254));
  ServerConnector connector = new ServerConnector(backendServer);
  backendServer.addConnector(connector);

  final WebsocketEchoHandler handler = new WebsocketEchoHandler();

  ContextHandler context = new ContextHandler();
  context.setContextPath("/");
  context.setHandler(handler);
  backendServer.setHandler(context);

  // Start Server
  backendServer.start();

  String host = connector.getHost();
  if (host == null) {
    host = "localhost";
  }
  int port = connector.getLocalPort();
  backendServerUri = new URI(String.format(Locale.ROOT, "ws://%s:%d/ws", host, port));
}
 

protected Server createServer() {
    if (getSettings().getMaxThreads() > 0) {
        int maxThreads = getSettings().getMaxThreads();
        int minThreads = getSettings().getMinThreads();
        if (minThreads == 0) {
            minThreads = JettySettings.DEFAULT_MIN_THREADS;
        }
        int idleTimeout = getSettings().getIdleTimeout();
        if (idleTimeout == 0) {
            idleTimeout = JettySettings.DEFAULT_IDLE_TIMEOUT;
        }

        return new Server(new QueuedThreadPool(maxThreads, minThreads, idleTimeout));
    }

    return new Server();
}
 

/**
 * Create the thread pool with request queue.
 *
 * @return thread pool used by the server
 */
private static ThreadPool createThreadPool(RestConfig config) {
  /* Create blocking queue for the thread pool. */
  int initialCapacity = config.getInt(RestConfig.REQUEST_QUEUE_CAPACITY_INITIAL_CONFIG);
  int growBy = config.getInt(RestConfig.REQUEST_QUEUE_CAPACITY_GROWBY_CONFIG);
  int maxCapacity = config.getInt(RestConfig.REQUEST_QUEUE_CAPACITY_CONFIG);
  log.info("Initial capacity {}, increased by {}, maximum capacity {}.",
          initialCapacity, growBy, maxCapacity);

  BlockingQueue<Runnable> requestQueue =
          new BlockingArrayQueue<>(initialCapacity, growBy, maxCapacity);
  
  return new QueuedThreadPool(config.getInt(RestConfig.THREAD_POOL_MAX_CONFIG),
          config.getInt(RestConfig.THREAD_POOL_MIN_CONFIG),
          requestQueue);
}
 

@Signature
public void __construct(int port, String host) {
    threadPool = new QueuedThreadPool();
    server = new Server(threadPool);

    if (host == null || host.isEmpty()) {
        listen(LongMemory.valueOf(port));
    } else {
        listen(StringMemory.valueOf(host + ":" + port));
    }

    initSessionManager();
}
 

private Server buildServer(final int port) {
    final QueuedThreadPool threadPool = new QueuedThreadPool(4, 2);

    final Server server = new Server(threadPool);

    final ServerConnector connector = new ServerConnector(server);
    connector.setPort(port);
    server.setConnectors(new Connector[] {connector});

    return server;
}
 

private static Server buildServer(final int port) {
    final QueuedThreadPool threadPool = new QueuedThreadPool(10, 2);

    final Server server = new Server(threadPool);

    final ServerConnector connector = new ServerConnector(server);
    connector.setPort(port);
    server.setConnectors(new Connector[] {connector});

    return server;
}
 

@Bean
public JettyServletWebServerFactory provideJettyServletWebServerFactory() {
    final JettyServletWebServerFactory jettyServlet = new JettyServletWebServerFactory(
        new Integer(this.getHttpListenerPort()));
    final List<JettyServerCustomizer> serverCustomizerList = Lists.newArrayList();
    final JettyServerCustomizer serverCustomizer = server -> {
        final QueuedThreadPool threadPool = server.getBean(QueuedThreadPool.class);
        threadPool.setMinThreads(SystemUtils.getNumberOfThreads(MIN_CORE_TO_THREAD_RATIO));
        threadPool.setMaxThreads(SystemUtils.getNumberOfThreads(MAX_CORE_TO_THREAD_RATIO));
    };
    serverCustomizerList.add(serverCustomizer);
    jettyServlet.setServerCustomizers(serverCustomizerList);
    return jettyServlet;
}
 

@Test
public void testThreadPoolStuff() throws Exception {
    ServerCommand cmd = ServerCommand.parse(ServerCommand.class, "-h", "host1", "-p", "3001");
    EmissaryServer server = new EmissaryServer(cmd);
    Server jettyServer = server.configureServer();
    QueuedThreadPool pool = (QueuedThreadPool) jettyServer.getThreadPool();
    assertThat(pool.getMinThreads(), equalTo(10));
    assertThat(pool.getMaxThreads(), equalTo(250));
    assertThat(pool.getLowThreadsThreshold(), equalTo(50));
    assertThat(pool.getIdleTimeout(), equalTo(new Long(TimeUnit.MINUTES.toMillis(15)).intValue()));
    assertThat(pool.getThreadsPriority(), equalTo(9));
}
 

private void startServer() throws Exception {

        log.info("Starting http server on port " + httpPort);
        Server server = new Server(new QueuedThreadPool(threadCount));
        ServerConnector serverConnector = new ServerConnector(server);
        serverConnector.setPort(httpPort);
        if (!Strings.isNullOrEmpty(httpBindAddress)) {
            serverConnector.setHost(httpBindAddress);
        }
        server.setConnectors(new Connector[]{serverConnector});
        ServletContextHandler context = new ServletContextHandler();
        context.setMaxFormContentSize(maxFormContextSizeBytes);
        context.setContextPath("/");

        ServletHolder metricSearchServletHolder = new ServletHolder(metricSearchServlet);
        context.addServlet(metricSearchServletHolder, "/search/*");
        context.addServlet(metricSearchServletHolder, "/ban/*");
        context.addServlet(metricSearchServletHolder, "/multiBan/*");
        context.addServlet(metricSearchServletHolder, "/approve/*");
        context.addServlet(metricSearchServletHolder, "/multiApprove/*");
        context.addServlet(metricSearchServletHolder, "/hide/*");
        context.addServlet(metricSearchServletHolder, "/multiHide/*");

        ServletHolder monitoringServletHolder = new ServletHolder(monitoringServlet);
        context.addServlet(monitoringServletHolder, "/ping");
        context.addServlet(monitoringServletHolder, "/monitoring");

        ServletHolder metricDataServletHolder = new ServletHolder(metricDataServiceServlet);
        context.addServlet(metricDataServletHolder, "/metricData");

        HandlerCollection handlers = new HandlerCollection();
        handlers.setHandlers(new Handler[]{context, new DefaultHandler()});
        server.setHandler(handlers);
        server.start();

        log.info("Web server started on port " + httpPort);
    }
 

private ThreadPool configureThreadPool(final int port) {
	final QueuedThreadPool threadPool = new QueuedThreadPool(threadPoolCapacity);
	threadPool.setMinThreads(minThreadCount);
	threadPool.setMaxThreads(maxThreadCount);
	threadPool.setName("Jetty thread pool [" + port + "]");
	threadPool.setDetailedDump(true);
	return threadPool;
}
 

@Override
public void bindTo(MeterRegistry registry) {
    if (threadPool instanceof SizedThreadPool) {
        SizedThreadPool sizedThreadPool = (SizedThreadPool) threadPool;
        Gauge.builder("jetty.threads.config.min", sizedThreadPool, SizedThreadPool::getMinThreads)
                .description("The minimum number of threads in the pool")
                .tags(tags).register(registry);
        Gauge.builder("jetty.threads.config.max", sizedThreadPool, SizedThreadPool::getMaxThreads)
                .description("The maximum number of threads in the pool")
                .tags(tags).register(registry);
        if (threadPool instanceof QueuedThreadPool) {
            QueuedThreadPool queuedThreadPool = (QueuedThreadPool) threadPool;
            Gauge.builder("jetty.threads.busy", queuedThreadPool, QueuedThreadPool::getBusyThreads)
                    .description("The number of busy threads in the pool")
                    .tags(tags).register(registry);
            Gauge.builder("jetty.threads.jobs", queuedThreadPool, QueuedThreadPool::getQueueSize)
                    .description("Number of jobs queued waiting for a thread")
                    .tags(tags).register(registry);
        }
    }
    Gauge.builder("jetty.threads.current", threadPool, ThreadPool::getThreads)
            .description("The total number of threads in the pool")
            .tags(tags).register(registry);
    Gauge.builder("jetty.threads.idle", threadPool, ThreadPool::getIdleThreads)
            .description("The number of idle threads in the pool").tags(tags)
            .register(registry);
}
 

public void init() throws Exception {
    client = new HttpClient(new SslContextFactory(true));
    client.setFollowRedirects(false);
    client.setCookieStore(new HttpCookieStore.Empty());

    executor = new QueuedThreadPool(conf.getInt(PRE + ".maxThreads", 256));
    client.setExecutor(executor);
    client.setMaxConnectionsPerDestination(conf.getInt(PRE + ".maxConnections", 256));
    client.setIdleTimeout(conf.getLong(PRE + ".idleTimeout", 30000));

    client.setConnectTimeout(conf.getLong(PRE + ".connectTime", 1000));

    if (conf.has(PRE + "requestBufferSize"))
        client.setRequestBufferSize(conf.getInt(PRE + "requestBufferSize"));

    if (conf.has(PRE + "responseBufferSize"))
        client.setResponseBufferSize(conf.getInt(PRE + "responseBufferSize"));

    client.start();

    // Content must not be decoded, otherwise the client gets confused.
    client.getContentDecoderFactories().clear();

    // Pass traffic to the client, only intercept what's necessary.
    ProtocolHandlers protocolHandlers = client.getProtocolHandlers();
    protocolHandlers.clear();
}
 

public JettyHttpServer(URL url, final HttpHandler handler) {
    super(url, handler);
    DispatcherServlet.addHttpHandler(url.getPort(), handler);

    int threads = url.getParameter(Constants.THREADS_KEY, Constants.DEFAULT_THREADS);
    QueuedThreadPool threadPool = new QueuedThreadPool();
    threadPool.setDaemon(true);
    threadPool.setMaxThreads(threads);
    threadPool.setMinThreads(threads);

    server = new Server(threadPool);

    // HTTP connector
    ServerConnector connector = new ServerConnector(server);
    if (!url.isAnyHost() && NetUtils.isValidLocalHost(url.getHost())) {
        connector.setHost(url.getHost());
    }
    connector.setPort(url.getPort());
    // connector.setIdleTimeout(30000);
    server.addConnector(connector);

    ServletHandler servletHandler = new ServletHandler();
    ServletHolder servletHolder = servletHandler.addServletWithMapping(DispatcherServlet.class, "/*");
    servletHolder.setInitOrder(2);

    server.insertHandler(servletHandler);

    try {
        server.start();
    } catch (Exception e) {
        throw new IllegalStateException("Failed to start jetty server on " + url.getAddress() + ", cause: "
                + e.getMessage(), e);
    }
}
 

private GaugeMetricFamily buildGauge(String metric, String help,
    Function<QueuedThreadPool, Integer> metricValueProvider) {
  final GaugeMetricFamily metricFamily = new GaugeMetricFamily(metric, help, LABEL_NAMES);
  queuedThreadPoolMap.forEach((key, value) -> metricFamily.addMetric(
      Collections.singletonList(key),
      metricValueProvider.apply(value)
  ));
  return metricFamily;
}
 

@Override
public void run() {
  Server server = new Server(new QueuedThreadPool(maxThreads, 8, idleTimeout, queue));
  ServerConnector connector = new ServerConnector(server, acceptors, selectors);
  connector.setIdleTimeout(idleTimeout);
  connector.setPort(port);
  connector.setHost(host);
  connector.setName("Continuum Ingress");
  
  server.setConnectors(new Connector[] { connector });

  HandlerList handlers = new HandlerList();
  
  Handler cors = new CORSHandler();
  handlers.addHandler(cors);

  handlers.addHandler(new InfluxDBHandler(url, token));
  
  server.setHandler(handlers);
  
  JettyUtil.setSendServerVersion(server, false);

  try {
    server.start();
  } catch (Exception e) {
    throw new RuntimeException(e);
  }
}
 

/**
 * Creates the Jetty server instance for the Flux API endpoint.
 * @param port where the service is available.
 * @return Jetty Server instance
 */
@Named("APIJettyServer")
@Provides
@Singleton
Server getAPIJettyServer(@Named("Api.service.port") int port,
						 @Named("APIResourceConfig")ResourceConfig resourceConfig,
						 @Named("Api.service.acceptors") int acceptorThreads,
						 @Named("Api.service.selectors") int selectorThreads,
						 @Named("Api.service.workers") int maxWorkerThreads,
						 ObjectMapper objectMapper, MetricRegistry metricRegistry) throws URISyntaxException, UnknownHostException {
	JacksonJaxbJsonProvider provider = new JacksonJaxbJsonProvider();
	provider.setMapper(objectMapper);
	resourceConfig.register(provider);
	QueuedThreadPool threadPool = new QueuedThreadPool();
	threadPool.setMaxThreads(maxWorkerThreads);
	Server server = new Server(threadPool);
	ServerConnector http = new ServerConnector(server, acceptorThreads, selectorThreads);
	http.setPort(port);
	server.addConnector(http);
	ServletContextHandler context = new ServletContextHandler(server, "/*");
	ServletHolder servlet = new ServletHolder(new ServletContainer(resourceConfig));
	context.addServlet(servlet, "/*");

	final InstrumentedHandler handler = new InstrumentedHandler(metricRegistry);
	handler.setHandler(context);
	server.setHandler(handler);

	server.setStopAtShutdown(true);
	return server;
}
 

public void createServer(int maxThreads) {
    
    // Setup Thread pool
    
    QueuedThreadPool threadPool = new QueuedThreadPool();
    threadPool.setMaxThreads(maxThreads);

    server = new Server(threadPool);
    handlers = new HandlerCollection();
    server.setHandler(handlers);
}