Managed Objects

<domain>
    ...
    <server>
       <data-sources>
           <data-source>testdb</data-source>
       </data-sources>
       <managed-executor-service>mes1</managed-executor-service>
    </server>

    <resources>
        <managed-executor-service>
            <export-name>mes1</export-name>
            <long-running-task>true</long-running-task>
            <thread-pool>
                <min>10</min>
                <max>20</max>
                <keep-alive-time>60000</keep-alive-time>
                <queue-size>4096</queue-size>
                <stuck-thread-handling>
                    <max-stuck-thread-time>3600000</max-stuck-thread-time>
                    <action-on-stuck-thread>None</action-on-stuck-thread>
                    <stuck-thread-check-period>300000</stuck-thread-check-period>
                </stuck-thread-handling>
            </thread-pool>
        </managed-executor-service>
    </resources>
    ...
</domain>

public class AppServlet extends HTTPServlet implements Servlet {
    // Retrieve our executor instance.
    @Resource(name=mes1”)
    ManagedExecutorService mes;

    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
                 throws ServletException, IOException {
        ArrayList<Callable> builderTasks = new ArrayList<Callable>();
        builderTasks.add(new AccountTask(reqID, accountID));
        builderTasks.add(new InsuranceTask(reqID, accountID));

        // Submit the tasks and wait.
        List<Future<Object>> results = mes.invokeAll(builderTasks);

        AccountInfo accountInfo = (AccountInfo) results.get(0).get();
        InsuranceInfo insInfo = (InsuranceInfo) results.get(1).get();
        // Process the results
    }
}

<domain>
 ...
 <server>
    <data-sources>
       <data-source>testdb</data-source>
    </data-sources>
    <managed-scheduled-executor-service>mses1</managed-scheduled-executor-service>
 </server>
 <resources>
     <managed-scheduled-executor-service>
         <export-name>mses1</export-name>
         <long-running-task>true</long-running-task>
         <thread-pool>
             <min>10</min>
             <max>20</max>
             <keep-alive-time>60000</keep-alive-time>
             <queue-size>4096</queue-size>
             <stuck-thread-handling>
                 <max-stuck-thread-time>3600000</max-stuck-thread-time>
                 <action-on-stuck-thread>None</action-on-stuck-thread>
                 <stuck-thread-check-period>300000</stuck-thread-check-period>
             </stuck-thread-handling>
         </thread-pool>
     </managed-scheduled-executor-service>
 </resources>
 ...
</domain>

public class AppServlet extends HTTPServlet implements Servlet {
    @Resource(name=mses1”)
    ManagedScheduledExecutorService mses;

    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
              throws ServletException, IOException {
        Runnable printTask = new Runnable() {
            @Override
            public void run() {
                System.out.println(System.currentTimeMillis());
            }
        };
        // printTask가 5초마다 주기적으로 실행됨
        mses.schedule(printTask, 5, TimeUnit.SECONDS);
    }
}

<domain>
    ...
    <server>
        <data-sources>
            <data-source>testdb</data-source>
        </data-sources>
        <context-service>cs1</context-service>
    </server>

    <resources>
        <context-service>
            <export-name>cs1</export-name>
        </context-service>
    </resources>
    ...
</domain>

public class AppServlet extends HTTPServlet implements Servlet {
    @Resource(name=cs1”)
    ContextService cs;

    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
                     throws ServletException, IOException {
        // 일반적인 Runnable task
        Runnable simpleTask = new Runnable() {
            @Override
            public void run() {
                int sum = 0;
                for (int i = 0; i < 10; i++) { sum += i; }
                System.out.println(sum);
            }
        };

        // 일반 task를 ContextService를 통해서 Contextual task로 만듦
        cs.createContextualProxy(simpleTask, Runnable.class);

        // SE에서 제공하는 Executor에 Contextual task를 넘김
        ExecutorService es = Executors.newFixedThreadPool(1);
        es.submit(simpleTask);
    }
}

<domain>
    ...
    <server>
        <data-sources>
            <data-source>testdb</data-source>
        </data-sources>
        <managed-thread-factory>mtf1</managed-thread-factory>
    </server>

    <resources>
        <managed-thread-factory>
            <export-name>mtf1</export-name>
            <thread-priority>5</thread-priority>
        </managed-thread-factory>
    </resources>
    ...
</domain>

public class AppServlet extends HTTPServlet implements Servlet {
    // Retrieve our executor instance.
    @Resource(name=mtf1”)
    ManagedThreadFactory mtf;

    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        // 일반적인 Runnable task
        Runnable simpleTask = new Runnable() {
            @Override
            public void run() {
                int sum = 0;
                for (int i = 0; i < 10; i++) { sum += i; }
                System.out.println(sum);
            }
        };

        // simpleTask를 ManagedThreadFactory에서 제공되는 thread에서 실행
        mtf.newThread(simpleTask).start();

        // 혹은 ThreadPoolExecutor의 매개변수로 ThreadFactory를 전달
        Executor e = new ThreadPoolExecutor(5, 10, 6L, TimeUnit.MINUTES,
                        new ArrayBlockingQueue<Runnable>(4096), mtf);
        e.execute(new SimpleTask());
    }
}