【线程的重要性】【线程和进程的区别】【多线程的运行优势，对比运行时间System.nanoTime()；】

@TOC

2) ***为啥要有线程（线程的重要性）

• 首先, “并发编程” 成为 “刚需”
  单核 CPU 的发展遇到了瓶颈. 要想提高算力, 就需要多核 CPU. 而并发编程（多线程编程）能更充分利用多核 CPU 资源.
  有些任务场景需要 “等待 IO”, 为了让等待 IO 的时间能够去做一些其他的工作, 也需要用到并发编程
• 其次, 虽然多进程也能实现 并发编程, 但是线程比进程更轻量
  创建线程比创建进程更快.
  销毁线程比销毁进程更快.
  调度线程比调度进程更快.
• 最后, 线程虽然比进程轻量, 但是人们还不满足, 于是又有了 “线程池”(ThreadPool) 和 “协程”(Coroutine)

3) ***进程和线程的区别（面试题）

1. 包含
2. 区别（轻量，创建快，销毁快）
3. 优势
4. 优势的原因
   

1.4 多线程的优势-增加运行速度

可以观察多线程在一些场合下是可以提高程序的整体运行效率的。

• 使用 System.nanoTime() 可以记录当前系统的 纳秒 级时间戳.
• serial 串行的完成一系列运算. concurrency 使用两个线程并行的完成同样的运算.

System.nanoTime();

public class ThreadAdvantage {
    // 多线程并不一定就能提高速度，可以观察，count 不同，实际的运行效果也是不同的
    private static final long count = 10_0000_0000;
    public static void main(String[] args) throws InterruptedException {
        // 使用并发方式
        concurrency();
        // 使用串行方式
        serial();
   }
    private static void concurrency() throws InterruptedException {
        long begin = System.nanoTime();
        
        // 利用一个线程计算 a 的值
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                int a = 0;
                for (long i = 0; i < count; i++) {
                    a--;
               }
           }
       });
        thread.start();
        // 主线程内计算 b 的值
        int b = 0;
        for (long i = 0; i < count; i++) {
            b--;
       }
        // 等待 thread 线程运行结束
        thread.join();
        
        // 统计耗时
        long end = System.nanoTime();
        double ms = (end - begin) * 1.0 / 1000 / 1000;
        System.out.printf("并发: %f 毫秒%n", ms);
   }
    private static void serial() {
        // 全部在主线程内计算 a、b 的值
        long begin = System.nanoTime();
        int a = 0;
        for (long i = 0; i < count; i++) {
            a--;
       }
        int b = 0;
        for (long i = 0; i < count; i++) {
            b--;
       }
        long end = System.nanoTime();
        double ms = (end - begin) * 1.0 / 1000 / 1000;
        System.out.printf("串行: %f 毫秒%n", ms);
   }
}

并发: 399.651856 毫秒
串行: 720.616911 毫秒