Examples with DefaultThreadFactory io.netty.util.concurrent.DefaultThreadFactory used on opensource projects

Example 21 with DefaultThreadFactory

use of io.netty.util.concurrent.DefaultThreadFactory in project netty by netty.

the class NioEventLoopTest method testCustomQueue.

@Test
public void testCustomQueue() {
    final AtomicBoolean called = new AtomicBoolean();
    NioEventLoopGroup group = new NioEventLoopGroup(1, new ThreadPerTaskExecutor(new DefaultThreadFactory(NioEventLoopGroup.class)), DefaultEventExecutorChooserFactory.INSTANCE, SelectorProvider.provider(), DefaultSelectStrategyFactory.INSTANCE, RejectedExecutionHandlers.reject(), new EventLoopTaskQueueFactory() {

        @Override
        public Queue<Runnable> newTaskQueue(int maxCapacity) {
            called.set(true);
            return new LinkedBlockingQueue<Runnable>(maxCapacity);
        }
    });
    final NioEventLoop loop = (NioEventLoop) group.next();
    try {
        loop.submit(new Runnable() {

            @Override
            public void run() {
            // NOOP.
            }
        }).syncUninterruptibly();
        assertTrue(called.get());
    } finally {
        group.shutdownGracefully();
    }
}

Example 22 with DefaultThreadFactory

use of io.netty.util.concurrent.DefaultThreadFactory in project netty by netty.

the class LocalTransportThreadModelTest method testStagedExecution.

@Test
@Timeout(value = 5000, unit = TimeUnit.MILLISECONDS)
public void testStagedExecution() throws Throwable {
    EventLoopGroup l = new DefaultEventLoopGroup(4, new DefaultThreadFactory("l"));
    EventExecutorGroup e1 = new DefaultEventExecutorGroup(4, new DefaultThreadFactory("e1"));
    EventExecutorGroup e2 = new DefaultEventExecutorGroup(4, new DefaultThreadFactory("e2"));
    ThreadNameAuditor h1 = new ThreadNameAuditor();
    ThreadNameAuditor h2 = new ThreadNameAuditor();
    ThreadNameAuditor h3 = new ThreadNameAuditor(true);
    Channel ch = new LocalChannel();
    // With no EventExecutor specified, h1 will be always invoked by EventLoop 'l'.
    ch.pipeline().addLast(h1);
    // h2 will be always invoked by EventExecutor 'e1'.
    ch.pipeline().addLast(e1, h2);
    // h3 will be always invoked by EventExecutor 'e2'.
    ch.pipeline().addLast(e2, h3);
    l.register(ch).sync().channel().connect(localAddr).sync();
    // Fire inbound events from all possible starting points.
    ch.pipeline().fireChannelRead("1");
    ch.pipeline().context(h1).fireChannelRead("2");
    ch.pipeline().context(h2).fireChannelRead("3");
    ch.pipeline().context(h3).fireChannelRead("4");
    // Fire outbound events from all possible starting points.
    ch.pipeline().write("5");
    ch.pipeline().context(h3).write("6");
    ch.pipeline().context(h2).write("7");
    ch.pipeline().context(h1).writeAndFlush("8").sync();
    ch.close().sync();
    // Wait until all events are handled completely.
    while (h1.outboundThreadNames.size() < 3 || h3.inboundThreadNames.size() < 3 || h1.removalThreadNames.size() < 1) {
        if (h1.exception.get() != null) {
            throw h1.exception.get();
        }
        if (h2.exception.get() != null) {
            throw h2.exception.get();
        }
        if (h3.exception.get() != null) {
            throw h3.exception.get();
        }
        Thread.sleep(10);
    }
    String currentName = Thread.currentThread().getName();
    try {
        // Events should never be handled from the current thread.
        assertFalse(h1.inboundThreadNames.contains(currentName));
        assertFalse(h2.inboundThreadNames.contains(currentName));
        assertFalse(h3.inboundThreadNames.contains(currentName));
        assertFalse(h1.outboundThreadNames.contains(currentName));
        assertFalse(h2.outboundThreadNames.contains(currentName));
        assertFalse(h3.outboundThreadNames.contains(currentName));
        assertFalse(h1.removalThreadNames.contains(currentName));
        assertFalse(h2.removalThreadNames.contains(currentName));
        assertFalse(h3.removalThreadNames.contains(currentName));
        // Assert that events were handled by the correct executor.
        for (String name : h1.inboundThreadNames) {
            assertTrue(name.startsWith("l-"));
        }
        for (String name : h2.inboundThreadNames) {
            assertTrue(name.startsWith("e1-"));
        }
        for (String name : h3.inboundThreadNames) {
            assertTrue(name.startsWith("e2-"));
        }
        for (String name : h1.outboundThreadNames) {
            assertTrue(name.startsWith("l-"));
        }
        for (String name : h2.outboundThreadNames) {
            assertTrue(name.startsWith("e1-"));
        }
        for (String name : h3.outboundThreadNames) {
            assertTrue(name.startsWith("e2-"));
        }
        for (String name : h1.removalThreadNames) {
            assertTrue(name.startsWith("l-"));
        }
        for (String name : h2.removalThreadNames) {
            assertTrue(name.startsWith("e1-"));
        }
        for (String name : h3.removalThreadNames) {
            assertTrue(name.startsWith("e2-"));
        }
        // Assert that the events for the same handler were handled by the same thread.
        Set<String> names = new HashSet<String>();
        names.addAll(h1.inboundThreadNames);
        names.addAll(h1.outboundThreadNames);
        names.addAll(h1.removalThreadNames);
        assertEquals(1, names.size());
        names.clear();
        names.addAll(h2.inboundThreadNames);
        names.addAll(h2.outboundThreadNames);
        names.addAll(h2.removalThreadNames);
        assertEquals(1, names.size());
        names.clear();
        names.addAll(h3.inboundThreadNames);
        names.addAll(h3.outboundThreadNames);
        names.addAll(h3.removalThreadNames);
        assertEquals(1, names.size());
        // Count the number of events
        assertEquals(1, h1.inboundThreadNames.size());
        assertEquals(2, h2.inboundThreadNames.size());
        assertEquals(3, h3.inboundThreadNames.size());
        assertEquals(3, h1.outboundThreadNames.size());
        assertEquals(2, h2.outboundThreadNames.size());
        assertEquals(1, h3.outboundThreadNames.size());
        assertEquals(1, h1.removalThreadNames.size());
        assertEquals(1, h2.removalThreadNames.size());
        assertEquals(1, h3.removalThreadNames.size());
    } catch (AssertionError e) {
        System.out.println("H1I: " + h1.inboundThreadNames);
        System.out.println("H2I: " + h2.inboundThreadNames);
        System.out.println("H3I: " + h3.inboundThreadNames);
        System.out.println("H1O: " + h1.outboundThreadNames);
        System.out.println("H2O: " + h2.outboundThreadNames);
        System.out.println("H3O: " + h3.outboundThreadNames);
        System.out.println("H1R: " + h1.removalThreadNames);
        System.out.println("H2R: " + h2.removalThreadNames);
        System.out.println("H3R: " + h3.removalThreadNames);
        throw e;
    } finally {
        l.shutdownGracefully();
        e1.shutdownGracefully();
        e2.shutdownGracefully();
        l.terminationFuture().sync();
        e1.terminationFuture().sync();
        e2.terminationFuture().sync();
    }
}

Example 23 with DefaultThreadFactory

use of io.netty.util.concurrent.DefaultThreadFactory in project netty by netty.

the class LocalTransportThreadModelTest3 method testConcurrentAddRemove.

private static void testConcurrentAddRemove(boolean inbound) throws Exception {
    EventLoopGroup l = new DefaultEventLoopGroup(4, new DefaultThreadFactory("l"));
    EventExecutorGroup e1 = new DefaultEventExecutorGroup(4, new DefaultThreadFactory("e1"));
    EventExecutorGroup e2 = new DefaultEventExecutorGroup(4, new DefaultThreadFactory("e2"));
    EventExecutorGroup e3 = new DefaultEventExecutorGroup(4, new DefaultThreadFactory("e3"));
    EventExecutorGroup e4 = new DefaultEventExecutorGroup(4, new DefaultThreadFactory("e4"));
    EventExecutorGroup e5 = new DefaultEventExecutorGroup(4, new DefaultThreadFactory("e5"));
    final EventExecutorGroup[] groups = { e1, e2, e3, e4, e5 };
    try {
        Deque<EventType> events = new ConcurrentLinkedDeque<EventType>();
        final EventForwarder h1 = new EventForwarder();
        final EventForwarder h2 = new EventForwarder();
        final EventForwarder h3 = new EventForwarder();
        final EventForwarder h4 = new EventForwarder();
        final EventForwarder h5 = new EventForwarder();
        final EventRecorder h6 = new EventRecorder(events, inbound);
        final Channel ch = new LocalChannel();
        if (!inbound) {
            ch.config().setAutoRead(false);
        }
        ch.pipeline().addLast(e1, h1).addLast(e1, h2).addLast(e1, h3).addLast(e1, h4).addLast(e1, h5).addLast(e1, "recorder", h6);
        l.register(ch).sync().channel().connect(localAddr).sync();
        final LinkedList<EventType> expectedEvents = events(inbound, 8192);
        Throwable cause = new Throwable();
        Thread pipelineModifier = new Thread(new Runnable() {

            @Override
            public void run() {
                Random random = new Random();
                while (true) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        return;
                    }
                    if (!ch.isRegistered()) {
                        continue;
                    }
                    // EventForwardHandler forwardHandler = forwarders[random.nextInt(forwarders.length)];
                    ChannelHandler handler = ch.pipeline().removeFirst();
                    ch.pipeline().addBefore(groups[random.nextInt(groups.length)], "recorder", UUID.randomUUID().toString(), handler);
                }
            }
        });
        pipelineModifier.setDaemon(true);
        pipelineModifier.start();
        for (EventType event : expectedEvents) {
            switch(event) {
                case EXCEPTION_CAUGHT:
                    ch.pipeline().fireExceptionCaught(cause);
                    break;
                case MESSAGE_RECEIVED:
                    ch.pipeline().fireChannelRead("");
                    break;
                case MESSAGE_RECEIVED_LAST:
                    ch.pipeline().fireChannelReadComplete();
                    break;
                case USER_EVENT:
                    ch.pipeline().fireUserEventTriggered("");
                    break;
                case WRITE:
                    ch.pipeline().write("");
                    break;
                case READ:
                    ch.pipeline().read();
                    break;
            }
        }
        ch.close().sync();
        while (events.peekLast() != EventType.UNREGISTERED) {
            Thread.sleep(10);
        }
        expectedEvents.addFirst(EventType.ACTIVE);
        expectedEvents.addFirst(EventType.REGISTERED);
        expectedEvents.addLast(EventType.INACTIVE);
        expectedEvents.addLast(EventType.UNREGISTERED);
        for (; ; ) {
            EventType event = events.poll();
            if (event == null) {
                assertTrue(expectedEvents.isEmpty(), "Missing events:" + expectedEvents);
                break;
            }
            assertEquals(event, expectedEvents.poll());
        }
    } finally {
        l.shutdownGracefully();
        e1.shutdownGracefully();
        e2.shutdownGracefully();
        e3.shutdownGracefully();
        e4.shutdownGracefully();
        e5.shutdownGracefully();
        l.terminationFuture().sync();
        e1.terminationFuture().sync();
        e2.terminationFuture().sync();
        e3.terminationFuture().sync();
        e4.terminationFuture().sync();
        e5.terminationFuture().sync();
    }
}

Example 24 with DefaultThreadFactory

use of io.netty.util.concurrent.DefaultThreadFactory in project grpc-java by grpc.

the class AltsHandshakerTest method setup.

@Before
public void setup() throws Exception {
    // create new EventLoopGroups to avoid deadlock at server side handshake negotiation, e.g.
    // happens when handshakerServer and testServer child channels are on the same eventloop.
    handshakerServer = grpcCleanup.register(NettyServerBuilder.forPort(0).bossEventLoopGroup(new NioEventLoopGroup(0, new DefaultThreadFactory("test-alts-boss"))).workerEventLoopGroup(new NioEventLoopGroup(0, new DefaultThreadFactory("test-alts-worker"))).channelType(NioServerSocketChannel.class).addService(new AltsHandshakerTestService()).build()).start();
    startAltsServer();
    ChannelCredentials channelCredentials = AltsChannelCredentials.newBuilder().enableUntrustedAltsForTesting().setHandshakerAddressForTesting("localhost:" + handshakerServer.getPort()).build();
    channel = grpcCleanup.register(Grpc.newChannelBuilderForAddress("localhost", testServer.getPort(), channelCredentials).build());
}

Example 25 with DefaultThreadFactory

use of io.netty.util.concurrent.DefaultThreadFactory in project grpc-java by grpc.

the class Utils method configureNetty.

private static NettyChannelBuilder configureNetty(NettyChannelBuilder builder, Transport transport, int flowControlWindow) {
    builder.flowControlWindow(flowControlWindow);
    DefaultThreadFactory tf = new DefaultThreadFactory("client-elg-", true);
    switch(transport) {
        case NETTY_NIO:
            builder.eventLoopGroup(new NioEventLoopGroup(0, tf)).channelType(NioSocketChannel.class);
            break;
        case NETTY_EPOLL:
            // These classes only work on Linux.
            builder.eventLoopGroup(new EpollEventLoopGroup(0, tf)).channelType(EpollSocketChannel.class);
            break;
        case NETTY_UNIX_DOMAIN_SOCKET:
            // These classes only work on Linux.
            builder.eventLoopGroup(new EpollEventLoopGroup(0, tf)).channelType(EpollDomainSocketChannel.class);
            break;
        default:
            // Should never get here.
            throw new IllegalArgumentException("Unsupported transport: " + transport);
    }
    return builder;
}