org.apache.camel.spi.ThreadPoolProfile Java Examples

@Override
protected RouteBuilder createRouteBuilder() throws Exception {
    return new RouteBuilder() {
        @Override
        public void configure() throws Exception {
            // register a custom thread pool profile
            ThreadPoolProfile custom = createCustomProfile();
            context.getExecutorServiceManager().registerThreadPoolProfile(custom);

            from("direct:start")
                // use the bigPool profile for creating the thread pool to be used
                .threads().executorServiceRef("bigPool")
                .to("log:foo")
                .to("mock:result");
        }
    };
}
 

@Test
public void testThreadPool() throws Exception {
    ThreadPoolProfile dpp = context.getExecutorServiceManager().getDefaultThreadPoolProfile();
    Assert.assertNotNull(dpp);
    Assert.assertEquals("default", dpp.getId());
    Assert.assertEquals(5, dpp.getPoolSize().intValue());
    Assert.assertEquals(10, dpp.getMaxPoolSize().intValue());
    Assert.assertEquals(20, dpp.getMaxQueueSize().intValue());
    Assert.assertEquals(ThreadPoolRejectedPolicy.DiscardOldest, dpp.getRejectedPolicy());

    ThreadPoolProfile sp = context.getExecutorServiceManager().getThreadPoolProfile("smallPool");
    Assert.assertNotNull(sp);
    Assert.assertEquals("smallPool", sp.getId());
    Assert.assertEquals(2, sp.getPoolSize().intValue());
    Assert.assertEquals(10, sp.getMaxPoolSize().intValue());
    Assert.assertEquals(20, sp.getMaxQueueSize().intValue());
    Assert.assertEquals(ThreadPoolRejectedPolicy.Abort, sp.getRejectedPolicy());

    ThreadPoolProfile bp = context.getExecutorServiceManager().getThreadPoolProfile("bigPool");
    Assert.assertNotNull(bp);
    Assert.assertEquals("bigPool", bp.getId());
    Assert.assertEquals(20, bp.getPoolSize().intValue());
    Assert.assertEquals(50, bp.getMaxPoolSize().intValue());
    Assert.assertEquals(500, bp.getMaxQueueSize().intValue());
    Assert.assertEquals(ThreadPoolRejectedPolicy.DiscardOldest, bp.getRejectedPolicy());
}
 

@Override
protected RouteBuilder createRouteBuilder() throws Exception {
    return new RouteBuilder() {
        @Override
        public void configure() throws Exception {
            // register a custom thread pool profile
            ThreadPoolProfile custom = createCustomProfile();
            context.getExecutorServiceManager().registerThreadPoolProfile(custom);

            from("direct:start")
                // use the bigPool profile for creating the thread pool to be used
                .threads().executorServiceRef("bigPool")
                .to("log:foo")
                .to("mock:result");
        }
    };
}
 

@Override
public void configure() throws Exception {
    ThreadPoolProfile customThreadPoolProfile =
        new ThreadPoolProfileBuilder("customThreadPoolProfile").poolSize(5).maxQueueSize(100).build();
    ModelCamelContext context = getContext();
    context.getExecutorServiceManager().registerThreadPoolProfile(customThreadPoolProfile);

    from("direct:in")
        .log("Received ${body}:${threadName}")
        .threads().executorServiceRef("customThreadPoolProfile")
        .log("Processing ${body}:${threadName}")
        .transform(simple("${threadName}"))
        .to("mock:out");
}
 

@Override
public ScheduledExecutorService newScheduledThreadPool(ThreadPoolProfile profile, ThreadFactory threadFactory) {
    RejectedExecutionHandler rejectedExecutionHandler = profile.getRejectedExecutionHandler();
    if (rejectedExecutionHandler == null) {
        rejectedExecutionHandler = new ThreadPoolExecutor.CallerRunsPolicy();
    }

    ScheduledThreadPoolExecutor answer = new RejectableScheduledThreadPoolExecutor(
        profile.getPoolSize(), managedThreadFactory, rejectedExecutionHandler);

    if (profile.getMaxPoolSize() > 0) {
        return new SizedScheduledExecutorService(answer, profile.getMaxQueueSize());
    } else {
        return answer;
    }
}
 

@Bean
public ThreadPoolProfile threadPool(CamelContext camelContext, CamelThreadPoolConfigurationProperties tp) {
    // okay we have all properties set so we should be able to create thread pool profiles and register them on camel
    ThreadPoolProfile defaultProfile = camelContext.getExecutorServiceManager().getDefaultThreadPoolProfile();
    final ThreadPoolProfile dp = new ThreadPoolProfileBuilder("default", defaultProfile)
            .poolSize(tp.getPoolSize())
            .maxPoolSize(tp.getMaxPoolSize())
            .keepAliveTime(tp.getKeepAliveTime(), tp.getTimeUnit())
            .maxQueueSize(tp.getMaxQueueSize())
            .allowCoreThreadTimeOut(tp.getAllowCoreThreadTimeOut())
            .rejectedPolicy(tp.getRejectedPolicy()).build();

    tp.getConfig().forEach((k, v) -> {
        ThreadPoolProfileBuilder builder = new ThreadPoolProfileBuilder(k, dp);
        final ThreadPoolProfile tpp = builder.poolSize(v.getPoolSize())
                .maxPoolSize(v.getMaxPoolSize())
                .keepAliveTime(v.getKeepAliveTime(), v.getTimeUnit())
                .maxQueueSize(v.getMaxQueueSize())
                .allowCoreThreadTimeOut(v.getAllowCoreThreadTimeOut())
                .rejectedPolicy(v.getRejectedPolicy()).build();
        if (!tpp.isEmpty()) {
            camelContext.getExecutorServiceManager().registerThreadPoolProfile(tpp);
        }
    });

    if (!dp.isEmpty()) {
        dp.setDefaultProfile(true);
        camelContext.getExecutorServiceManager().setDefaultThreadPoolProfile(dp);
    }

    // need to return something
    return dp;
}
 

public ThreadPoolProfile createCustomProfile() {
    // create a custom thread pool profile with the name bigPool
    return new ThreadPoolProfileBuilder("bigPool")
        .maxPoolSize(200)
        .rejectedPolicy(ThreadPoolRejectedPolicy.DiscardOldest)
        .build();
}
 

public ThreadPoolProfile createCustomProfile() {
    // create a custom thread pool profile with the name bigPool
    ThreadPoolProfile profile = new ThreadPoolProfile("bigPool");
    profile.setMaxPoolSize(200);
    profile.setRejectedPolicy(ThreadPoolRejectedPolicy.DiscardOldest);
    return profile;
}
 

@Override
public ExecutorService newThreadPool(ThreadPoolProfile profile, ThreadFactory factory) {
    boolean allow = profile.getAllowCoreThreadTimeOut() != null?profile.getAllowCoreThreadTimeOut().booleanValue():false;
    return this.newThreadPool(profile.getPoolSize().intValue(),
                              profile.getMaxPoolSize().intValue(),
                              profile.getKeepAliveTime().longValue(),
                              profile.getTimeUnit(),
                              profile.getMaxQueueSize().intValue(),
                              allow,
                              profile.getRejectedExecutionHandler(),
                              managedThreadFactory);
}