Refine search
@Override protected void doOpen() throws Throwable { FilterChainBuilder filterChainBuilder = FilterChainBuilder.stateless(); filterChainBuilder.add(new TransportFilter()); filterChainBuilder.add(new GrizzlyCodecAdapter(getCodec(), getUrl(), this)); filterChainBuilder.add(new GrizzlyHandler(getUrl(), this)); TCPNIOTransportBuilder builder = TCPNIOTransportBuilder.newInstance(); ThreadPoolConfig config = builder.getWorkerThreadPoolConfig(); config.setPoolName(SERVER_THREAD_POOL_NAME).setQueueLimit(-1); String threadpool = getUrl().getParameter(Constants.THREADPOOL_KEY, Constants.DEFAULT_THREADPOOL); if (Constants.DEFAULT_THREADPOOL.equals(threadpool)) { int threads = getUrl().getPositiveParameter(Constants.THREADS_KEY, Constants.DEFAULT_THREADS); config.setCorePoolSize(threads).setMaxPoolSize(threads) .setKeepAliveTime(0L, TimeUnit.SECONDS); } else if ("cached".equals(threadpool)) { int threads = getUrl().getPositiveParameter(Constants.THREADS_KEY, Integer.MAX_VALUE); config.setCorePoolSize(0).setMaxPoolSize(threads) .setKeepAliveTime(60L, TimeUnit.SECONDS); } else { throw new IllegalArgumentException("Unsupported threadpool type " + threadpool); } builder.setKeepAlive(true).setReuseAddress(false) .setIOStrategy(SameThreadIOStrategy.getInstance()); transport = builder.build(); transport.setProcessor(filterChainBuilder.build()); transport.bind(getBindAddress()); transport.start(); }
public static void main(String[] args) throws Exception { System.out.println("Jersey performance test web service application"); final String jaxRsApp = args.length > 0 ? args[0] : null; //noinspection unchecked final ResourceConfig resourceConfig = ResourceConfig .forApplicationClass((Class<? extends Application>) Class.forName(jaxRsApp)); URI baseUri = args.length > 1 ? URI.create(args[1]) : BASE_URI; int selectors = args.length > 2 ? Integer.parseInt(args[2]) : DEFAULT_SELECTORS; int workers = args.length > 3 ? Integer.parseInt(args[3]) : DEFAULT_WORKERS; final HttpServer server = GrizzlyHttpServerFactory.createHttpServer(baseUri, resourceConfig, false); final TCPNIOTransport transport = server.getListener("grizzly").getTransport(); transport.setSelectorRunnersCount(selectors); transport.setWorkerThreadPoolConfig(ThreadPoolConfig.defaultConfig().setCorePoolSize(workers).setMaxPoolSize(workers)); server.start(); System.out.println(String.format("Application started.\nTry out %s\nHit Ctrl-C to stop it...", baseUri)); while (server.isStarted()) { Thread.sleep(600000); } } }
private int maxThreadPoolSize() { Collection<NetworkListener> listeners = this.httpServer.getListeners(); if (listeners.size() == 0) { return -1; } return listeners.iterator().next().getTransport() .getWorkerThreadPoolConfig().getMaxPoolSize(); }
ThreadPoolConfig threadPoolConfig = ThreadPoolConfig.defaultConfig() .setCorePoolSize(nHandlerThreads) .setMaxPoolSize(nHandlerThreads) .setQueueLimit(-1);
@Override public ThreadPoolConfig createDefaultWorkerPoolConfig(final Transport transport) { final ThreadPoolConfig config = ThreadPoolConfig.defaultConfig().copy(); final int selectorRunnerCount = ((NIOTransport) transport).getSelectorRunnersCount(); config.setCorePoolSize(selectorRunnerCount * 2); config.setMaxPoolSize(selectorRunnerCount * 2); config.setMemoryManager(transport.getMemoryManager()); return config; }
@Override public ThreadPoolConfig createDefaultWorkerPoolConfig(final Transport transport) { final ThreadPoolConfig config = ThreadPoolConfig.defaultConfig().copy(); final int coresCount = Runtime.getRuntime().availableProcessors(); config.setPoolName("Grizzly-worker"); config.setCorePoolSize(coresCount * 2); config.setMaxPoolSize(coresCount * 2); config.setMemoryManager(transport.getMemoryManager()); return config; }
/** * Creates a new {@link ExecutorService} */ protected ExecutorService newThreadPool(int threadCount) { if (threadCount == 0){ return null; } final ThreadPoolConfig tpc = ThreadPoolConfig.defaultConfig() .setPoolName("RCM_" + threadCount) .setCorePoolSize(1) .setMaxPoolSize(threadCount); return GrizzlyExecutorService.createInstance(tpc); }
protected ThreadPoolConfig configureThreadPoolConfig(final NetworkListener networkListener, final ThreadPool threadPool) { final int maxQueueSize = threadPool.getMaxQueueSize() == null ? Integer.MAX_VALUE : Integer.parseInt(threadPool.getMaxQueueSize()); final int minThreads = Integer.parseInt(threadPool.getMinThreadPoolSize()); final int maxThreads = Integer.parseInt(threadPool.getMaxThreadPoolSize()); final int timeout = Integer.parseInt(threadPool.getIdleThreadTimeoutSeconds()); final ThreadPoolConfig poolConfig = ThreadPoolConfig.defaultConfig(); poolConfig.setPoolName(networkListener.getName()); poolConfig.setCorePoolSize(minThreads); poolConfig.setMaxPoolSize(maxThreads); poolConfig.setQueueLimit(maxQueueSize); // we specify the classloader that loaded this class to ensure // we present the same initial classloader no matter what mode // GlassFish is being run in. // See http://java.net/jira/browse/GLASSFISH-19639 poolConfig.setInitialClassLoader(this.getClass().getClassLoader()); poolConfig.setKeepAliveTime(timeout < 0 ? Long.MAX_VALUE : timeout, TimeUnit.SECONDS); if (transactionTimeoutMillis > 0 && !Utils.isDebugVM()) { poolConfig.setTransactionTimeout(delayedExecutor, transactionTimeoutMillis, TimeUnit.MILLISECONDS); } return poolConfig; }
public AbstractThreadPool(ThreadPoolConfig config) { if (config.getMaxPoolSize() < 1) { throw new IllegalArgumentException("poolsize < 1"); if (config.getInitialMonitoringConfig().hasProbes()) { monitoringConfig.addProbes(config.getInitialMonitoringConfig().getProbes()); if (config.getThreadFactory() == null) { config.setThreadFactory(getDefaultThreadFactory()); transactionTimeoutMillis = config.getTransactionTimeout(TimeUnit.MILLISECONDS); final DelayedExecutor transactionMonitor = transactionTimeoutMillis > 0 ? config.getTransactionMonitor() : null;
@Test public void testWorkerThreadPoolConfiguration() throws Exception { LOGGER.log(Level.INFO, "Running: testWorkerThreadPoolConfiguration ({0})", transport.getName()); ThreadPoolConfig config = ThreadPoolConfig.defaultConfig(); config.setCorePoolSize(1); config.setMaxPoolSize(1); config.setPoolName("custom"); transport.setWorkerThreadPoolConfig(config); transport.setIOStrategy(WorkerThreadIOStrategy.getInstance()); ThreadPoolConfig underTest = transport.getWorkerThreadPoolConfig(); assertEquals(1, underTest.getCorePoolSize()); assertEquals(1, underTest.getMaxPoolSize()); assertEquals("custom", underTest.getPoolName()); }
org.glassfish.tyrus.client.ThreadPoolConfig clientThreadPoolConfig = (org.glassfish.tyrus.client.ThreadPoolConfig) threadPoolConfig; ThreadPoolConfig grizzlyThreadPoolConfig = ThreadPoolConfig.defaultConfig(); grizzlyThreadPoolConfig.setMaxPoolSize(clientThreadPoolConfig.getMaxPoolSize()) .setCorePoolSize(clientThreadPoolConfig.getCorePoolSize()) .setPriority(clientThreadPoolConfig.getPriority()) .setDaemon(clientThreadPoolConfig.isDaemon()) .setKeepAliveTime(clientThreadPoolConfig.getKeepAliveTime(TimeUnit.MILLISECONDS), TimeUnit.MILLISECONDS) .setInitialClassLoader(clientThreadPoolConfig.getInitialClassLoader()) .setPoolName(clientThreadPoolConfig.getPoolName()) .setQueue(clientThreadPoolConfig.getQueue()) .setQueueLimit(clientThreadPoolConfig.getQueueLimit()) .setThreadFactory(clientThreadPoolConfig.getThreadFactory()); return grizzlyThreadPoolConfig; } else if (threadPoolConfig instanceof ThreadPoolConfig) {
@Test public void testWorkerThreadPoolConfiguration2() throws Exception { LOGGER.log(Level.INFO, "Running: testWorkerThreadPoolConfiguration2 ({0})", transport.getName()); ThreadPoolConfig config = ThreadPoolConfig.defaultConfig(); config.setCorePoolSize(1); config.setMaxPoolSize(1); config.setPoolName("custom"); transport.setWorkerThreadPoolConfig(config); transport.setIOStrategy(SameThreadIOStrategy.getInstance()); assertNull(transport.getWorkerThreadPoolConfig()); assertNull(transport.getWorkerThreadPool()); }
/** * * @return {@link GrizzlyExecutorService} */ public static GrizzlyExecutorService createInstance() { return createInstance(ThreadPoolConfig.defaultConfig()); }
public FixedThreadPool(ThreadPoolConfig config) { super(config); this.workQueue = config.getQueue() != null ? (BlockingQueue<Runnable>) config.getQueue() : (BlockingQueue<Runnable>) config.setQueue( new LinkedTransferQueue<>()).getQueue(); int poolSize = config.getMaxPoolSize(); synchronized (stateLock) { while (poolSize-- > 0) { doStartWorker(); } } ProbeNotifier.notifyThreadPoolStarted(this); super.onMaxNumberOfThreadsReached(); }
/** * Added for http://java.net/jira/browse/GRIZZLY-1435. * @throws Exception */ @Test public void testThreadPoolCoreThreadInitialization() throws Exception { final ThreadPoolConfig config = ThreadPoolConfig.defaultConfig(); config.setCorePoolSize(5); config.setMaxPoolSize(5); Field workers = AbstractThreadPool.class.getDeclaredField("workers"); workers.setAccessible(true); final SyncThreadPool syncThreadPool = new SyncThreadPool(config); assertEquals("Pool did not properly initialize threads based on core pool size configuration.", 5, ((Map) workers.get(syncThreadPool)).size()); config.setQueue(new ArrayBlockingQueue<Runnable>(5)); final FixedThreadPool fixedThreadPool = new FixedThreadPool(config); assertEquals("Pool did not properly initialize threads based on core pool size configuration.", 5, ((Map) workers.get(fixedThreadPool)).size()); }
/** * */ public SyncThreadPool(ThreadPoolConfig config) { super(config); if (config.getKeepAliveTime(TimeUnit.MILLISECONDS) < 0) { throw new IllegalArgumentException("keepAliveTime < 0"); } workQueue = config.getQueue() != null ? config.getQueue() : config.setQueue(new LinkedList<Runnable>()).getQueue(); this.maxQueuedTasks = config.getQueueLimit(); final int corePoolSize = config.getCorePoolSize(); while (currentPoolSize < corePoolSize) { startWorker(new SyncThreadWorker(true)); } ProbeNotifier.notifyThreadPoolStarted(this); }
protected <T extends NIOTransport> T configureDefaultThreadPoolConfigs( final T transport) { transport.setKernelThreadPoolConfig(ThreadPoolConfig.defaultConfig()); transport.setWorkerThreadPoolConfig(ThreadPoolConfig.defaultConfig()); return transport; }
public ThreadPoolConfig setTransactionTimeout( final DelayedExecutor transactionMonitor, final long transactionTimeout, final TimeUnit timeunit) { this.transactionMonitor = transactionMonitor; return setTransactionTimeout(transactionTimeout, timeunit); }
/** * Sets the {@link ThreadPoolConfig} * @param config * @return returns {@link GrizzlyExecutorService} */ public GrizzlyExecutorService reconfigure(ThreadPoolConfig config) { synchronized (statelock) { //TODO: only create new pool if old one cant be runtime config // for the needed state change(s). final AbstractThreadPool oldpool = this.pool; if (config.getQueue() == oldpool.getQueue()) { config.setQueue(null); } setImpl(config); AbstractThreadPool.drain(oldpool.getQueue(), this.pool.getQueue()); oldpool.shutdown(); } return this; }
listener.getTransport().getWorkerThreadPoolConfig().setThreadFactory(new ThreadFactoryBuilder() .setNameFormat("grizzly-http-server-%d") .setUncaughtExceptionHandler(new JerseyProcessingUncaughtExceptionHandler())