98beb777f8
Motivation: In cases when an application is running in a container or is otherwise constrained to the number of processors that it is using, the JVM invocation Runtime#availableProcessors will not return the constrained value but rather the number of processors available to the virtual machine. Netty uses this number in sizing various resources. Additionally, some applications will constrain the number of threads that they are using independenly of the number of processors available on the system. Thus, applications should have a way to globally configure the number of processors. Modifications: Rather than invoking Runtime#availableProcessors, Netty should rely on a method that enables configuration when the JVM is started or by the application. This commit exposes a new class NettyRuntime for enabling such configuraiton. This value can only be set once. Its default value is Runtime#availableProcessors so that there is no visible change to existing applications, but enables configuring either a system property or configuring during application startup (e.g., based on settings used to configure the application). Additionally, we introduce the usage of forbidden-apis to prevent future uses of Runtime#availableProcessors from creeping. Future work should enable the bundled signatures and clean up uses of deprecated and other forbidden methods. Result: Netty can be configured to not use the underlying number of processors, but rather the constrained number of processors.
100 lines
3.6 KiB
Java
100 lines
3.6 KiB
Java
/*
|
|
* Copyright 2012 The Netty Project
|
|
*
|
|
* The Netty Project licenses this file to you under the Apache License,
|
|
* version 2.0 (the "License"); you may not use this file except in compliance
|
|
* with the License. You may obtain a copy of the License at:
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
* License for the specific language governing permissions and limitations
|
|
* under the License.
|
|
*/
|
|
package io.netty.channel;
|
|
|
|
import io.netty.util.NettyRuntime;
|
|
import io.netty.util.concurrent.DefaultThreadFactory;
|
|
import io.netty.util.concurrent.EventExecutorChooserFactory;
|
|
import io.netty.util.concurrent.MultithreadEventExecutorGroup;
|
|
import io.netty.util.internal.SystemPropertyUtil;
|
|
import io.netty.util.internal.logging.InternalLogger;
|
|
import io.netty.util.internal.logging.InternalLoggerFactory;
|
|
|
|
import java.util.concurrent.Executor;
|
|
import java.util.concurrent.ThreadFactory;
|
|
|
|
/**
|
|
* Abstract base class for {@link EventLoopGroup} implementations that handles their tasks with multiple threads at
|
|
* the same time.
|
|
*/
|
|
public abstract class MultithreadEventLoopGroup extends MultithreadEventExecutorGroup implements EventLoopGroup {
|
|
|
|
private static final InternalLogger logger = InternalLoggerFactory.getInstance(MultithreadEventLoopGroup.class);
|
|
|
|
private static final int DEFAULT_EVENT_LOOP_THREADS;
|
|
|
|
static {
|
|
DEFAULT_EVENT_LOOP_THREADS = Math.max(1, SystemPropertyUtil.getInt(
|
|
"io.netty.eventLoopThreads", NettyRuntime.availableProcessors() * 2));
|
|
|
|
if (logger.isDebugEnabled()) {
|
|
logger.debug("-Dio.netty.eventLoopThreads: {}", DEFAULT_EVENT_LOOP_THREADS);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @see MultithreadEventExecutorGroup#MultithreadEventExecutorGroup(int, Executor, Object...)
|
|
*/
|
|
protected MultithreadEventLoopGroup(int nThreads, Executor executor, Object... args) {
|
|
super(nThreads == 0 ? DEFAULT_EVENT_LOOP_THREADS : nThreads, executor, args);
|
|
}
|
|
|
|
/**
|
|
* @see MultithreadEventExecutorGroup#MultithreadEventExecutorGroup(int, ThreadFactory, Object...)
|
|
*/
|
|
protected MultithreadEventLoopGroup(int nThreads, ThreadFactory threadFactory, Object... args) {
|
|
super(nThreads == 0 ? DEFAULT_EVENT_LOOP_THREADS : nThreads, threadFactory, args);
|
|
}
|
|
|
|
/**
|
|
* @see MultithreadEventExecutorGroup#MultithreadEventExecutorGroup(int, Executor,
|
|
* EventExecutorChooserFactory, Object...)
|
|
*/
|
|
protected MultithreadEventLoopGroup(int nThreads, Executor executor, EventExecutorChooserFactory chooserFactory,
|
|
Object... args) {
|
|
super(nThreads == 0 ? DEFAULT_EVENT_LOOP_THREADS : nThreads, executor, chooserFactory, args);
|
|
}
|
|
|
|
@Override
|
|
protected ThreadFactory newDefaultThreadFactory() {
|
|
return new DefaultThreadFactory(getClass(), Thread.MAX_PRIORITY);
|
|
}
|
|
|
|
@Override
|
|
public EventLoop next() {
|
|
return (EventLoop) super.next();
|
|
}
|
|
|
|
@Override
|
|
protected abstract EventLoop newChild(Executor executor, Object... args) throws Exception;
|
|
|
|
@Override
|
|
public ChannelFuture register(Channel channel) {
|
|
return next().register(channel);
|
|
}
|
|
|
|
@Override
|
|
public ChannelFuture register(ChannelPromise promise) {
|
|
return next().register(promise);
|
|
}
|
|
|
|
@Deprecated
|
|
@Override
|
|
public ChannelFuture register(Channel channel, ChannelPromise promise) {
|
|
return next().register(channel, promise);
|
|
}
|
|
}
|