Java多线程的简单实现以及耗时操作的效率对比

public class ThreadDemo {

    public static void main(String[] args) {
        MyRunnable command = new MyRunnable();
        long start = System.currentTimeMillis();
        int executeCount = 10;
        command.setEndListener(new MyRunnable.EndListener() {
            private int count = 0;

            @Override
            public void end() {
                count++;
                if (count == executeCount) {
                    long end = System.currentTimeMillis();
                    System.out.println("全部请求执行完毕，耗时:" + (end - start) + "毫秒");
                }
            }
        });
        System.out.println("开始请求");

        singleThread(command,executeCount);
//        multiThread(command, executeCount, 100);
    }

    /**
     * 单线程运行
     *
     * @param runnable     run
     * @param executeCount 运行次数
     */
    public static void singleThread(MyRunnable runnable, int executeCount) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();//单一后台线程
        for (int i = 0; i < executeCount; i++) {
            executorService.execute(runnable);
        }
    }

    /**
     * 多线程运行
     *
     * @param runnable        run
     * @param executeCount    运行次数
     * @param coreThreadCount 核心线程数量
     */
    public static void multiThread(MyRunnable runnable, int executeCount, int coreThreadCount) {
        BlockingQueue<Runnable> queue = new LinkedBlockingQueue<Runnable>();
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(coreThreadCount, 200, 2000, TimeUnit.SECONDS, queue);
        for (int i = 0; i < executeCount; i++) {
            threadPool.execute(runnable);
        }
    }

    public static class MyRunnable implements Runnable {
        private EndListener listener;
        private int count;

        @Override
        public void run() {
            try {
                int currentCount = 0;
                synchronized (MyRunnable.class) {
                    currentCount = count++;
                    System.out.println("线程：" + Thread.currentThread().getName() + "进行第" + currentCount + "次请求");
                }
                Thread.sleep(100);
                System.out.println("线程：" + Thread.currentThread().getName() + "第" + currentCount + "次请求完成");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            listener.end();
        }

        public void setEndListener(EndListener listener) {
            this.listener = listener;
        }

        interface EndListener {
            void end();
        }
    }
}

运行结果

singleThread(command,executeCount);
开始请求
线程：pool-1-thread-1进行第0次请求
线程：pool-1-thread-1第0次请求完成
线程：pool-1-thread-1进行第1次请求
线程：pool-1-thread-1第1次请求完成
线程：pool-1-thread-1进行第2次请求
线程：pool-1-thread-1第2次请求完成
线程：pool-1-thread-1进行第3次请求
线程：pool-1-thread-1第3次请求完成
线程：pool-1-thread-1进行第4次请求
线程：pool-1-thread-1第4次请求完成
线程：pool-1-thread-1进行第5次请求
线程：pool-1-thread-1第5次请求完成
线程：pool-1-thread-1进行第6次请求
线程：pool-1-thread-1第6次请求完成
线程：pool-1-thread-1进行第7次请求
线程：pool-1-thread-1第7次请求完成
线程：pool-1-thread-1进行第8次请求
线程：pool-1-thread-1第8次请求完成
线程：pool-1-thread-1进行第9次请求
线程：pool-1-thread-1第9次请求完成
全部请求执行完毕，耗时:1132毫秒

 multiThread(command, executeCount, 100);
开始请求
线程：pool-1-thread-1进行第0次请求
线程：pool-1-thread-2进行第1次请求
线程：pool-1-thread-3进行第2次请求
线程：pool-1-thread-4进行第3次请求
线程：pool-1-thread-5进行第4次请求
线程：pool-1-thread-6进行第5次请求
线程：pool-1-thread-7进行第6次请求
线程：pool-1-thread-8进行第7次请求
线程：pool-1-thread-9进行第8次请求
线程：pool-1-thread-10进行第9次请求
线程：pool-1-thread-1第0次请求完成
线程：pool-1-thread-2第1次请求完成
线程：pool-1-thread-3第2次请求完成
线程：pool-1-thread-5第4次请求完成
线程：pool-1-thread-6第5次请求完成
线程：pool-1-thread-4第3次请求完成
线程：pool-1-thread-7第6次请求完成
线程：pool-1-thread-10第9次请求完成
线程：pool-1-thread-9第8次请求完成
线程：pool-1-thread-8第7次请求完成
全部请求执行完毕，耗时:121毫秒

从以上运行的结果可知，当需要进行重复的耗时操作（比如网络请求），使用多线程能大大提高运行效率

---

附几个常用的线程池方法：

 Executors.newCachedThreadPool()（无界线程池，可以进行自动线程回收）;
 Executors.newFixedThreadPool(int)（固定大小线程池）;
 Executors.newSingleThreadExecutor()（单个后台线程）;