カウンタークラス
package jp.co.yourcompany.education.concurrent;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * 非同期用カウンタークラス
 */
public class SummaryCounter {

    private AtomicInteger counter = new AtomicInteger( 0 );

    /**
     * カウンターをインクリメントし、
     * その値を呼び出し元に戻す。
     * @return
     */
    public synchronized int inclrement( ){
        return counter.getAndIncrement();
    }
}
					

Runnable実装例
package jp.co.yourcompany.education.concurrent;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * concurrent用学習用taskに与える処理
 * @raita.kuwabara
 */
public class RunnableSample implements Runnable {

    /**
     * private
     */
    private int id = 0;

    // 0.5秒周期
    private static final long SLEEP_MILLIONS = TimeUnit.MILLISECONDS.convert( 1000, TimeUnit.MILLISECONDS);

    /**
     * スレッド別カウンター
     */
    private AtomicInteger counter = new AtomicInteger(0);

    /**
     * カウンターオブジェクト
     */
    private SummaryCounter summaryCounter = null;

    /**
     * コンストラクタ
     */
    public RunnableSample(SummaryCounter summaryCounter, int id) {
        this.summaryCounter = summaryCounter;
        this.id = id;
    }

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep( SLEEP_MILLIONS );
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            increment();
            int summaryCount = summaryIncrement();
            outputCounter(summaryCount);
        }
    }

    /**
     * それぞれのカウントをインクリメント
     */
    private void increment() {
        counter.incrementAndGet();
    }

    /**
     * SampleThreadクラスの全インスタンスのループ総数をインクリメントする。 インクリメントした数を出力する。
     */
    private int summaryIncrement() {
        return summaryCounter.inclrement();
    }

    /**
     * 出力
     */
    private void outputCounter(int summaryCount) {
        System.out.println(Thread.currentThread().getName() + ":id[ " + id + " ] counter:" + counter);
        System.out.println(Thread.currentThread().getName() + ":id[ " + id + " ] summaryCounter:" + summaryCount);
    }

}
					

newSingleThreadExecutor実装例
    /**
     * newSingleThreadExecutorを確認するサンプル
     * @param factory ThreadFactory(ワーカースレッドを変更したい場合引き渡す。) 

     *         null 指定時には、デフォルトのワーカースレッドが利用されます。
     */
    public void execSingleThreadExecutor( ThreadFactory factory ) {
        ExecutorService executorService = null;
        log.info("newSingleThreadExecutor START");

        //サイズ制限のない１つのThreadExecutor();
        if( factory == null){
            executorService = Executors.newSingleThreadExecutor();
        } else {
            executorService = Executors.newSingleThreadExecutor( factory );
        }

        SummaryCounter summaryCounter = new SummaryCounter();

        for ( int i = 0 ; i < 100 ; i++ ){
            executorService.execute( new RunnableSample( summaryCounter , i ) );
        }
        log.info("newSingleThreadExecutor runnable");

        //taskが残存していない事を確認してサービスの終了
        if( executorService.isTerminated() ){
            executorService.shutdown();
            log.info("newSingleThreadExecutor ShutDown");
        }
        log.info("newSingleThreadExecutor END");
    }
					

上記メソッドの実行方法
    public static final void main ( String[] args){
        ExecutorsSample sample = new ExecutorsSample();
        sample.execSingleThreadExecutor ( null );
    }
					

newFixedThreadPool実装例
    /**
     * newFixedThreadPool確認用メソッド
     * スレッド数は、threadCountで変更して下さい。
     * @param factory ThreadFactory(ワーカースレッドを変更したい場合引き渡す。) 

     *         null 指定時には、デフォルトのワーカースレッドが利用されます。
     */
    public void execNewFixedThreadPool( ThreadFactory threadFactory) {
        ExecutorService executorService = null;
        log.info("execnewFixedThreadPool START");

        final int  threadCount = 5;

        if( threadFactory == null ){
            executorService = Executors.newFixedThreadPool( threadCount );
        } else {
            executorService = Executors.newFixedThreadPool( threadCount, threadFactory );
        }

        SummaryCounter summaryCounter = new SummaryCounter();
        for ( int i = 0 ; i < 100 ; i++ ){
            executorService.execute( new RunnableSample( summaryCounter , i ) );
        }

        log.info("newSingleThreadExecutor runnable");

        //taskが残存していない事を確認してサービスの終了
        if( executorService.isTerminated() ){
            executorService.shutdown();
            log.info("newSingleThreadExecutor ShutDown");
        }
        log.info("newSingleThreadExecutor END");
    }
			    	

上記メソッドの実行方法
    public static final void main ( String[] args){
        ExecutorsSample sample = new ExecutorsSample();
        sample.execNewFixedThreadPool ( null );
    }
					

newScheduledThreadPool実装例
    /**
     * newScheduledThreadPool確認用メソッド
     * @param threadFactory
     */
    public void execScheduledExecutorService( ThreadFactory threadFactory) {
        ScheduledExecutorService scheduledExecutorService = null;

        log.info("execScheduledExecutorService START");

        final int  threadCount = 2;

        if( threadFactory == null ){
            scheduledExecutorService = Executors.newScheduledThreadPool( threadCount );
        } else {
            scheduledExecutorService = Executors.newScheduledThreadPool( threadCount, threadFactory );
        }

        SummaryCounter summaryCounter = new SummaryCounter();

        //３，６、９、１２、１５・・・３０秒の待機時間のタスク
        for ( int i = 0 ; i < 10 ; i++  ) {
            int waitSeconds = 3 * ( 1 + i );
            scheduledExecutorService.schedule( new RunnableSample( summaryCounter , i ), waitSeconds ,  TimeUnit.SECONDS );
        }
        log.info("execScheduledExecutorService runnable");

        if( scheduledExecutorService.isTerminated() ){
            scheduledExecutorService.shutdown();
            log.info("execScheduledExecutorService ShutDown");
        }
        log.info("execScheduledExecutorService END");

    }
					

newCachedThreadPool実装例
    /**
     * cachedTreadPool
     * @param threadFactory
     */
    private void execCachedThreadPool( ThreadFactory threadFactory ){
        ExecutorService cachedThreadPool = null;
        log.info("execCachedThreadPool START");

        if( threadFactory == null ){
            cachedThreadPool = Executors.newCachedThreadPool( );
        } else {
            cachedThreadPool = Executors.newCachedThreadPool( threadFactory );
        }

        SummaryCounter summaryCounter = new SummaryCounter();

        for ( int i = 0 ; i < 3 ; i++  ) {
            cachedThreadPool.execute( new RunnableSample( summaryCounter , i ) );
        }

        try {
            //ここの間隔が、60秒以上だとThreadは常に作成される。
            Thread.sleep( 61000 );
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        for ( int i = 0 ; i < 3 ; i++  ) {
            cachedThreadPool.execute( new RunnableSample( summaryCounter , i ) );
        }
        log.info("execCachedThreadPool runnable");

        if( cachedThreadPool.isTerminated() ){
            cachedThreadPool.shutdown();
            log.info("execCachedThreadPool ShutDown");
        }
        log.info("execCachedThreadPool END");
    }