Java并发包线程池ThreadPoolExecutor的实现

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0 ));

private static final int COUNT_BITS = Integer.SIZE - 3 ;

private static final int CAPACITY   = ( 1 << COUNT_BITS) - 1 ;

// runState is stored in the high-order bits

private static final int RUNNING    = - 1 << COUNT_BITS;

private static final int SHUTDOWN   =   0 << COUNT_BITS;

private static final int STOP       =   1 << COUNT_BITS;

private static final int TIDYING    =   2 << COUNT_BITS;

private static final int TERMINATED =   3 << COUNT_BITS;

public class MyRunnable implements Runnable {

    @Override

    public void run() {

        System.out.println( "我要一个教练" );

        try {

            Thread.sleep( 2000 );

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        System.out.println( "教练来了： " + Thread.currentThread().getName());

        System.out.println( "教我游泳,交完后，教练回到了游泳池" );

    }

}

public class ThreadPoolDemo {

    public static void main(String[] args) {

        // 创建线程池对象

        ExecutorService service = Executors.newFixedThreadPool( 2 ); //包含2个线程对象

        // 创建Runnable实例对象

        MyRunnable r = new MyRunnable();

        //自己创建线程对象的方式

        // Thread t = new Thread(r);

        // t.start(); ---> 调用MyRunnable中的run()

        // 从线程池中获取线程对象,然后调用MyRunnable中的run()

        service.submit(r);

        // 再获取个线程对象，调用MyRunnable中的run()

        service.submit(r);

        service.submit(r);

        // 注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。

        // 将使用完的线程又归还到了线程池中

        // 关闭线程池

        //service.shutdown();

    }

}

public class ThreadPoolDemo2 {

    public static void main(String[] args) throws Exception {

        // 创建线程池对象

      ExecutorService service = Executors.newFixedThreadPool( 2 ); //包含2个线程对象

        // 创建Runnable实例对象

        Callable<Double> c = new Callable<Double>() {

            @Override

            public Double call() throws Exception {

                return Math.random();

            }

        };

        // 从线程池中获取线程对象,然后调用Callable中的call()

        Future<Double> f1 = service.submit(c);

        // Futur 调用get() 获取运算结果

        System.out.println(f1.get());

        Future<Double> f2 = service.submit(c);

        System.out.println(f2.get());

        Future<Double> f3 = service.submit(c);

        System.out.println(f3.get());

    }

}

public class Demo04 {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        ExecutorService pool = Executors.newFixedThreadPool( 3 );

        SumCallable sc = new SumCallable( 100 );

        Future<Integer> fu = pool.submit(sc);

        Integer integer = fu.get();

        System.out.println( "结果: " + integer);

        SumCallable sc2 = new SumCallable( 200 );

        Future<Integer> fu2 = pool.submit(sc2);

        Integer integer2 = fu2.get();

        System.out.println( "结果: " + integer2);

        pool.shutdown();

    }

}

public class SumCallable implements Callable<Integer> {

    private int n;

    public SumCallable( int n) {

        this .n = n;

    }

    @Override

    public Integer call() throws Exception {

        // 求1-n的和?

        int sum = 0 ;

        for ( int i = 1 ; i <= n; i++) {

            sum += i;

        }

        return sum;

    }

}