The minimum number of threads is equal to the number of available
cores. If all tasks are computation intensive, then this is all we need. Having
more threads will actually hurt in this case because cores would be context
switching between threads when there is still work to do. If tasks are IO
intensive, then we should have more threads.

We can compute the total number of threads we’d need as follows:

  Number of threads = Number of Available Cores / (1 - Blocking Coefficient)

 To determine the number of threads, we need to know two things:
 ? The number of available cores
 ? The blocking coefficient of tasks

 The first one is easy to determine; we can look up that information, even at
 runtime, as we saw earlier. It takes a bit of effort to determine the blocking
 coefficient. We can try to guess it, or we can use profiling tools or the java.
 lang.management API to determine the amount of time a thread spends on
 system/IO operations vs. on CPU-intensive tasks.

package com.bob.testjava.thread;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Created by zhangmingbo on 1/7/17.
 */
public class Stage {

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

        long startTime = System.currentTimeMillis();
        ExecutorService threadPool = null;

        try {
            threadPool = Executors.newFixedThreadPool(Constants.THREAD_SIZE);
            CountDownLatch countDownLatch = new CountDownLatch(Constants.SIZE);

            for (int i = 0; i < Constants.THREAD_SIZE; i++) {
                threadPool.execute(new Worker(countDownLatch));
            }

            countDownLatch.await();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            long endTime = System.currentTimeMillis();

            int cpuCoreNum = Runtime.getRuntime().availableProcessors();
            System.out.println("Number of CPU cores :" + cpuCoreNum);
            System.out.println("Work time (millisecond) :" + Constants.WORK_TIME_MILLISECOND);
            System.out.println("Block time (millisecond) :" + Constants.BLOCK_TIME_MILLISECOND);

            Double blockCoefficient = (Constants.BLOCK_TIME_MILLISECOND * 1d) / (Constants.WORK_TIME_MILLISECOND + Constants.BLOCK_TIME_MILLISECOND);
            System.out.println("Block coefficient :" + blockCoefficient);

            int optimalThreadNum = new Double(cpuCoreNum / (1 - blockCoefficient)).intValue();
            System.out.println("Optimal thread number in theory:" + optimalThreadNum);

            System.out.println("Number of Task :" + Constants.SIZE);
            System.out.println("Number of Thread :" + Constants.THREAD_SIZE);
            System.out.println("Cost Time:" + (endTime - startTime));
            try {
                threadPool.shutdownNow();
            } catch (Exception e) {
            }
        }
    }
}

package com.bob.testjava.thread;

import java.util.concurrent.CountDownLatch;

/**
 * Created by zhangmingbo on 1/7/17.
 */
public class Worker implements Runnable {


    private CountDownLatch countDownLatch;

    public Worker(CountDownLatch countDownLatch) {


        this.countDownLatch = countDownLatch;
    }

    public void run() {


        try {
            while (countDownLatch.getCount() > 0) {

                //do work
                TestUtil.doWorkByTime(Constants.WORK_TIME_MILLISECOND);

                //do block operation
                TestUtil.doBlockOperation(Constants.BLOCK_TIME_MILLISECOND);

                countDownLatch.countDown();
            }
        } catch (InterruptedException e) {
        }

    }
}

package com.bob.testjava.thread;

import java.util.concurrent.TimeUnit;

/**
 * Created by zhangmingbo on 1/10/17.
 */
public class TestUtil {

    public static void doWorkByTime(long millisecond) {
        long startTime = System.currentTimeMillis();

        while (true) {

            long endTime = System.currentTimeMillis();
            long costTime = endTime - startTime;
            if (costTime >= millisecond) {
                return;
            }

        }

    }

    public static void doBlockOperation(long millisecond) throws InterruptedException {
        TimeUnit.MILLISECONDS.sleep(millisecond);
    }

}

package com.bob.testjava.thread;

/**
 * Created by zhangmingbo on 1/7/17.
 */
public class Constants {

    public static final int SIZE = 100;

    public static final int THREAD_SIZE = 8;

    public static final long BLOCK_TIME_MILLISECOND = 5;

    public static final int WORK_TIME_MILLISECOND = 5;

}