javax.enterprise.concurrent.ManagedExecutorService Java Examples

private static void doCheck(final ManagedExecutorService es, final ManagedScheduledExecutorService ses, final ManagedThreadFactory tf) {
    assertNotNull(es);
    assertNotNull(ses);
    assertNotNull(tf);

    assertThat(es, instanceOf(ManagedExecutorServiceImpl.class));
    assertEquals(2, pool(es).getCorePoolSize());
    assertEquals(10, pool(es).getMaximumPoolSize());
    assertEquals(4, pool(es).getKeepAliveTime(TimeUnit.MINUTES));

    assertThat(ses, instanceOf(ManagedScheduledExecutorServiceImpl.class));
    assertEquals(12, pool(ses).getCorePoolSize());

    assertThat(tf, instanceOf(ManagedThreadFactoryImpl.class));
    assertEquals("custom-", Reflections.get(tf, "prefix"));
}
 

private static void doCheck(final ManagedExecutorService es, final ManagedScheduledExecutorService ses,
                            final ContextService ces, final ManagedThreadFactory tf) {
    assertNotNull(es);
    assertNotNull(ses);
    assertNotNull(ces);
    assertNotNull(tf);

    assertThat(es, instanceOf(ManagedExecutorServiceImpl.class));
    assertThat(ses, instanceOf(ManagedScheduledExecutorServiceImpl.class));
    assertThat(ces, instanceOf(ContextServiceImpl.class));
    assertThat(tf, instanceOf(ManagedThreadFactoryImpl.class));
}
 

private void add(final JndiConsumer jndi, final DeploymentModule module, final DeploymentModule app, final boolean defaults) {

        // Standard names
        add(jndi.getEnvEntryMap(), new EnvEntry().name("java:module/ModuleName").value(module.getModuleId()).type(String.class));
        add(jndi.getEnvEntryMap(), new EnvEntry().name("java:app/AppName").value(app.getModuleId()).type(String.class));

        // Standard References to built-in objects
        add(jndi.getResourceEnvRefMap(), new ResourceEnvRef().name("java:comp/BeanManager").type(BeanManager.class));
        add(jndi.getResourceEnvRefMap(), new ResourceEnvRef().name("java:comp/Validator").type(Validator.class));
        add(jndi.getResourceEnvRefMap(), new ResourceEnvRef().name("java:comp/ValidatorFactory").type(ValidatorFactory.class));
        add(jndi.getResourceEnvRefMap(), new ResourceEnvRef().name("java:comp/TransactionManager").type(TransactionManager.class));
        add(jndi.getResourceEnvRefMap(), new ResourceEnvRef().name("java:comp/TransactionSynchronizationRegistry").type(TransactionSynchronizationRegistry.class));

        if (defaults) {
            add(jndi.getResourceEnvRefMap(), new ResourceEnvRef().name("java:comp/DefaultManagedExecutorService").type(ManagedExecutorService.class));
            add(jndi.getResourceEnvRefMap(), new ResourceEnvRef().name("java:comp/DefaultManagedScheduledExecutorService").type(ManagedScheduledExecutorService.class));
            add(jndi.getResourceEnvRefMap(), new ResourceEnvRef().name("java:comp/DefaultManagedThreadFactory").type(ManagedThreadFactory.class));
            add(jndi.getResourceEnvRefMap(), new ResourceEnvRef().name("java:comp/DefaultContextService").type(ContextService.class));
            try {
                final ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
                contextClassLoader.loadClass("org.apache.activemq.ActiveMQSslConnectionFactory");
                final ResourceEnvRef ref = new ResourceEnvRef().name("java:comp/DefaultJMSConnectionFactory")
                    .type(contextClassLoader.loadClass("javax.jms.ConnectionFactory"));
                add(jndi.getResourceEnvRefMap(), ref);
            } catch (final ClassNotFoundException | NoClassDefFoundError notThere) {
                // no-op
            }
        }


        // OpenEJB specific feature
        add(jndi.getEnvEntryMap(), new EnvEntry().name("java:comp/ComponentName").value(jndi.getJndiConsumerName()).type(String.class));

    }
 

@Override
public void taskSubmitted(final Future<?> future, final ManagedExecutorService executor, final Object task) {
    this.future = future;
    this.executor = executor;

    if (listener != null) {
        listener.taskSubmitted(future, executor, task);
    }
}
 

@Override
public void taskAborted(final Future<?> future, final ManagedExecutorService executor, final Object task, final Throwable exception) {
    if (listener != null) {
        // use saved values since called with null excepted for the exception
        listener.taskAborted(this.future, this.executor, this.delegate, exception);
    }
}
 

@Override
public void taskAborted(Future<?> future, ManagedExecutorService mes, Object o, Throwable thrwbl) {
    long mili = new Date().getTime();
    LOG.log(Level.INFO, "taskAborted: {0} - Miliseconds since instantiation: {1}", new Object[]{future, mili - instantiationMili});
}
 

private static ThreadPoolExecutor pool(final ManagedExecutorService es) {
    return ThreadPoolExecutor.class.cast(ManagedExecutorServiceImpl.class.cast(es).getDelegate());
}
 

@Override
public void taskStarting(final Future<?> future, final ManagedExecutorService executor, final Object task) {
    // no-op
}
 

@Override
public void taskDone(final Future<?> future, final ManagedExecutorService executor, final Object task, final Throwable exception) {
    // no-op
}
 

@Override
public void taskAborted(final Future<?> future, final ManagedExecutorService executor, final Object task, final Throwable exception) {
    // no-op
}
 

@Override
public void taskSubmitted(final Future<?> future, final ManagedExecutorService executor, final Object task) {
    // no-op
}
 

@Override
public void taskStarting(final Future<?> future, final ManagedExecutorService executor, final Object task) {
    if (listener != null) {
        listener.taskStarting(future, executor, task);
    }
}
 

@Override
public void taskDone(final Future<?> future, final ManagedExecutorService executor, final Object task, final Throwable exception) {
    if (listener != null) {
        listener.taskDone(future, executor, task, exception);
    }
}
 

@Override
public void taskStarting(Future<?> future, ManagedExecutorService executor, Object task) {
    logger.info("Starting " + task);
}
 

@Override
public void taskDone(Future<?> future, ManagedExecutorService executor, Object task, Throwable exception) {
    logger.info("Finished task " + task);
}
 

@Override
public void taskAborted(Future<?> future, ManagedExecutorService executor, Object task, Throwable exception) {
    logger.log(Level.WARNING, "Aborted", exception);
}
 

@Override
public void taskSubmitted(Future<?> future, ManagedExecutorService executor, Object task) {
    logger.info("Submitted " + task);
}
 

default ManagedExecutorService executorService() throws Exception {
    InitialContext ctx = new InitialContext();
    return (ManagedExecutorService) ctx.lookup("java:jboss/ee/concurrency/executor/default");
}
 

@Override
public void taskStarting(Future<?> future, ManagedExecutorService mes, Object o) {
    long mili = new Date().getTime();
    LOG.log(Level.INFO, "taskStarting: {0} - Miliseconds since instantiation: {1}", new Object[]{future, mili - instantiationMili});
}
 

@Override
public void taskDone(Future<?> future, ManagedExecutorService mes, Object o, Throwable thrwbl) {
    long mili = new Date().getTime();
    LOG.log(Level.INFO, "taskDone: {0} - Miliseconds since instantiation: {1}", new Object[]{future, mili - instantiationMili});
}
 

@Override
public void taskSubmitted(Future<?> future, ManagedExecutorService mes, Object o) {
    long mili = new Date().getTime();
    LOG.log(Level.INFO, "taskSubmitted: {0} - Miliseconds since instantiation: {1}", new Object[]{future, mili - instantiationMili});
}
 

/**
 * Constructs a new ManagedJobExecutor with the provided
 * {@link ManagedExecutorService}
 */
public ManagedJobExecutor(final ManagedExecutorService managedExecutorService) {
  this.managedExecutorService = managedExecutorService;
}