use single static initialization of available metrics monitor registries * This changes the original implementation to work in a similar way to how slf4j selects and loads an implementation. * Uses a single static instance so intialization is done only once. * Doesn't throw IllegalStateException if multiple implementations are found on the classpath. It instead selects and uses the first implementation returned by iterator() * Class left as an iterable to keep the API the same add yammer metrics to examples to allow them to publish metrics publish the number of threads used in an EventLoopGroup see issue #718 * seems like the better place to put this because it sets the default thread count if the MultithreadEventLoopGroup uses super(0,...) * It also happens to be the common parent class amongst all the MultiThreadedEventLoopGroup implementations * Count is reported for io.netty.channel.{*,.local,.socket.aio,.socket.nio} fix cosmetic issues pointed out in pull request and updated notice.txt see https://github.com/netty/netty/pull/780 count # of channels registered in single threaded event loop measure how many times Selector.select return before SELECT_TIME
82 lines
2.6 KiB
Java
82 lines
2.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.monitor.CounterMonitor;
|
|
import io.netty.monitor.MonitorName;
|
|
import io.netty.monitor.MonitorRegistries;
|
|
|
|
import java.util.concurrent.ThreadFactory;
|
|
|
|
/**
|
|
* Abstract base class for {@link EventLoop}'s that execute all its submitted tasks in a single thread.
|
|
*
|
|
*/
|
|
public abstract class SingleThreadEventLoop extends SingleThreadEventExecutor implements EventLoop {
|
|
protected CounterMonitor channelCounter = MonitorRegistries.instance()
|
|
.unique().newCounterMonitor(new MonitorName(getClass(), "total-channels-registered"));
|
|
|
|
/**
|
|
*
|
|
* @see SingleThreadEventExecutor#SingleThreadEventExecutor(EventExecutorGroup, ThreadFactory, ChannelTaskScheduler)
|
|
*/
|
|
protected SingleThreadEventLoop(
|
|
EventLoopGroup parent, ThreadFactory threadFactory, ChannelTaskScheduler scheduler) {
|
|
super(parent, threadFactory, scheduler);
|
|
}
|
|
|
|
@Override
|
|
public EventLoopGroup parent() {
|
|
return (EventLoopGroup) super.parent();
|
|
}
|
|
|
|
@Override
|
|
public EventLoop next() {
|
|
return (EventLoop) super.next();
|
|
}
|
|
|
|
@Override
|
|
public ChannelFuture register(Channel channel) {
|
|
if (channel == null) {
|
|
throw new NullPointerException("channel");
|
|
}
|
|
return register(channel, channel.newPromise());
|
|
}
|
|
|
|
@Override
|
|
public ChannelFuture register(final Channel channel, final ChannelPromise promise) {
|
|
if (isShutdown()) {
|
|
channel.unsafe().closeForcibly();
|
|
promise.setFailure(new EventLoopException("cannot register a channel to a shut down loop"));
|
|
return promise;
|
|
}
|
|
|
|
if (inEventLoop()) {
|
|
channel.unsafe().register(this, promise);
|
|
} else {
|
|
execute(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
channel.unsafe().register(SingleThreadEventLoop.this, promise);
|
|
}
|
|
});
|
|
}
|
|
|
|
channelCounter.increment();
|
|
return promise;
|
|
}
|
|
}
|