【摘要】进程、线程和程序
所谓程序，即代码编译打包之后生成的可执行文件，是存在于硬盘中的一个静态文件而已。当执行某个程序，操作系统会将这个程序加载到内存当中，为其分配所需的资源，此时它称为一个进程，是动态的。而一个进程中可能会同时进行多个任务，它们称为线程，多个线程共享进程的资源。几乎任何一本操作系统的书籍都会告诉你，进程是操作系统分配资源的基本单位，线程是CPU调度的基…

进程、线程和程序

所谓程序，即代码编译打包之后生成的可执行文件，是存在于硬盘中的一个静态文件而已。当执行某个程序，操作系统会将这个程序加载到内存当中，为其分配所需的资源，此时它称为一个进程，是动态的。而一个进程中可能会同时进行多个任务，它们称为线程，多个线程共享进程的资源。几乎任何一本操作系统的书籍都会告诉你，进程是操作系统分配资源的基本单位，线程是CPU调度的基本单位。但其实，线程和进程在本质上是相同的。在Linux操作系统中，一个进程通过调用fork()函数得到一个子进程，这个子进程共享其资源，这个子进程其实就是线程。通俗地说，线程即一个进程不同的执行路径。

线程之间的切换

线程是通过获取CPU的时间片在CPU上执行的，一个CPU核同一个时刻只能执行一个线程。如下图所示，CPU由运算器ALU、控制器OC、寄存器Register和缓存Cache等部分组成。线程A在CPU上执行时，寄存器中存放了程序执行的位置以及操作数等相关数据。当CPU从线程A切换到线程B时，先要将寄存器Register中的数据保存到缓存Cache当中，再执行线程B。这样做的目的是从线程B切换回线程A的时候，可以回到线程A之前执行的地方。这就是线程之间的切换，也称为CPU上下文切换。在这里插入图片描述

线程数量

多线程的意义在于压榨CPU的计算能力，使其不会闲下来。当一个线程等待IO的时候，CPU可以执行其他线程的运算逻辑。那么，是不是线程数量越多越好呢？其实不然。CPU在上下文切换的时候，也是需要时间开销的。当CPU频繁地进行上下文切换，会导致其上下文切换的时间过长，导致程序执行效率降低。而线程数设置太少，又无法最大化地利用CPU性能。所以，根据如下公式，可得到一个合理的线程数，N_Thread = N_cpu * U_cpu * (1 + W / C)。N_cpu表示CPU的总核数，U_cpu表示期望的CPU利用率，W表示线程等待的时间，C表示线程在CPU上执行的时间。假设CPU核数为1，期望的CPU利用率是100%，线程等待时间和执行时间之比W/C为1 : 1，可得出2为比较合理的线程数。那么问题来了，如何知道程序W和C的比值呢？严谨一点的话，肯定要在程序部署运行之后，通过统计数据才能得出结论。一般可以使用Jprofiler或Arthas进行分析，也可以在代码中通过日志的方式记录代码各部分的执行时间。

如何创建线程

从形式上来说，Java提供了多种创建线程的方式。但是从本质上来说，它们都属于同一种方法。

方式1：继承Thread类

public class TestThread { public static void main(String[] args) { MyThread myThread = new MyThread(); myThread.start(); }
}

class MyThread extends Thread { @Override public void run() { System.out.println("Hello world !"); }
}

  
 
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13

方式2：实现Runnable接口

public class TestThread { public static void main(String[] args) { MyRunnable myRunnable = new MyRunnable(); new Thread(myRunnable).start(); }
}

class MyRunnable implements Runnable { @Override public void run() { System.out.println("Hello world !"); }
}

  
 
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13

方式3：Lambda表达式

public class TestThread { public static void main(String[] args) { new Thread( () -> System.out.println("Hello world !") ).start(); }
}

  
 
  1
  2
  3
  4
  5
  6
  7

方式4：线程池

public class TestThread { public static void main(String[] args) { ExecutorService service = Executors.newCachedThreadPool(); service.execute(new MyRunnable()); service.shutdown(); }
}

  
 
  1
  2
  3
  4
  5
  6
  7

方式4：通过Callable接口实现带返回值的线程创建

public class TestThread { public static void main(String[] args) throws ExecutionException, InterruptedException { ExecutorService service = Executors.newCachedThreadPool(); Future<String> f = service.submit(new MyCallable()); String result = f.get(); System.out.println(result); service.shutdown(); }
}

class MyCallable implements Callable<String> { @Override public String call() throws Exception { return "success"; }
}

  
 
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16

方式5：构建FutureTask对象

在方式4中，Callable对象只能通过线程池执行。如果不用线程池，可以通过构造FutureTask对象来实现。

public class TestThread { public static void main(String[] args) throws ExecutionException, InterruptedException { FutureTask<String> task = new FutureTask<>(new MyCallable()); new Thread(task).start(); String result = task.get(); System.out.println(result); }
}

  
 
  1
  2
  3
  4
  5
  6
  7
  8