一、进程和线程

进程

在大多数操作系统中都可以创建多个进程（Process）。进程是一个程序运行的基本单位。当一个程序启动时，即会为程序执行的任务创建一个进程，并允许它们同时运行。当一个进程因IO或网络请求而被阻塞时，其它进程还可以继续运行，这样就增加了资源利用率。但是，按照这种方式创建每个进程要付出一定的代价：设置一个进程要占用相当一部分处理器时间和内存资源。而且，大多数操作系统不允许进程访问其他进程的内存空间。因此，进程间的通信很不方便，并且也不会将它自己提供给容易的编程模型。

线程

线程（Thread）也称为轻型进程（LWP）。因为线程只能在单个进程的作用域内活动，所以创建线程很简单。且线程允许协作和数据交换，在计算资源方面非常廉价。线程需要操作系统的支持，而JVM天然支持线程。
在Java中，JVM作为外部操作系统的一个进程而存在，而线程则作为JVM内部的一个个任务。

二、时间片与调度

并发与并行

并发：多个线程共用一个（份）CPU（核心或资源）（其实就是共用进程所占据的CPU资源），在不同时间片内轮流执行。
并行：不同的线程使用不同的CPU执行。
JVM作为应用程序，无法干涉操作系统的资源调度方式，因此不能确定JVM内部的线程究竟是并发的还是并行的。但无论是并发还是并行，都不会影响Java多线程代码的运行速度。

时间片与线程调度

时间片是线程占据CPU资源的一段时间。有以下两种主要的线程调度策略：
时间片轮转：所有线程轮流占据CPU资源，平均分配占据CPU的时间。
抢占式调度：根据线程优先级，优先级高的线程更有可能抢先占据CPU资源。优先级相同，则是随机的。这也是JVM的线程调度方式。

三、线程

创建和启动

（一）主线程

JVM会在一开始，在类加载到方法区后，便会创建和调用主线程（main）执行程序。而主线程默认执行main()方法，故Java程序都是从main方法开始执行的。在主线程的进行过程中，程序可以创建线程对象，执行自定义线程指定的代码。当没有创建其它线程时，程序从始至终都只有一个线程——main线程。
线程在Java中也是一个对象，创建了线程对象便创建了一个线程。线程只有启动后，JVM才会为其分配相应的资源（CPU、内存和磁盘等）。当然，新的线程在启动后，启动新线程的线程也不会等待新线程执行完毕，或终止自身的执行，而是两个线程并发或并行执行。
线程会在启动后拥有自己的虚拟机栈、本地方法栈和程序计数器；所有的线程共用同一个方法区和堆。启动后的main线程会执行main方法，其它线程会执行run方法。

（二）使用Thread类创建线程

可以定义一个类继承Thread类，并重写父类的run()方法，run方法中的代码便是线程要执行的代码（run方法需要抛异常或使用try-catch块包裹）。然后创建一个这个类的对象（便创建了一个线程），调用start()方法便启动了这个线程（而调用run方法只会调用当前线程执行）。

  1. class MyThread extends Thread { // 定义一个类继承Thread
  2.     @Override
  3.     public void run() { /*要执行的代码和方法*/ }
  4. }
  5. class Test {
  6.     main() {
  7.         Thread t = new MyThread(); // 这里用了多态
  8.         t.start(); // 调用了Thread 0线程执行run方法
  9.         t.run(); // 如果这样写，则是调用了main线程执行run方法
  10.     }
  11. }

也可以使用匿名内部类和lambda表达式继承。当然，这样的方法太过麻烦，并且强行让一个类去继承Thread类，使得这个类失去了继承其它类的机会。故Java提供了Runnable接口。

（三）使用Runnable接口创建线程

使用Thread的构造方法传入一个Runnable接口的实现类对象，以生成一个Thread对象，并调用start()方法便启动了这个线程。

  1. class MyThread implements Runnable {
  2.     @Override
  3.     public void run() { /*要执行的代码和方法*/ }
  4. }
  5. class Test {
  6.     main() {
  7.         Thread t = new Thread(new MyThread());
  8.         t.start(); // 调用了Thread 0线程执行run方法
  9.     }
  10. }

Runnable接口可以把相同的任务交给不同的线程去执行，让线程和执行代码相对独立。同样地，也可以使用匿名内部类和lambda表达式实现。

  1. class Test {
  2.     main() {
  3.         new Thread(new Runnable() { // 使用匿名内部类
  4.             @Override
  5.             public void run() { /*要执行的代码和方法*/ }
  6.         }, "LambdaThread").start(); // 将线程命名为LambdaThread并启动
  7.     }
  8. }

名字

要获取线程的名字，可以使用Thread.currentThread().getName()方法。其中Thread.currentThread()能够获取当前进程对象。从main线程创建的线程的默认名字为Thread-num（num为线程序号，从0开始）。
如上例所述，可以使用Thread构造方法的第二个参数对线程进行命名。也可以使用线程对象的setName()方法在线程启动之前为线程命名。

分类

线程分为两类：前台线程（执行线程或用户线程）和后台线程（守护线程或精灵线程）。默认创建的新线程是前台线程。可以在线程启动前使用setDaemon(true)方法将线程设为后台线程。
前台线程地位较高，而后台线程为前台线程提供良好的运行环境和类加载环境等。
无论后台线程有没有执行完，当所有前台线程执行完毕后，JVM就会停止运行。

优先级

线程的优先级使得高优先级的线程更有可能抢先占据CPU资源，优先运行，但并不是一定能够抢到。线程的优先级默认为5，最低为1，最高为10。
可以通过getPriority()方法获取线程优先级，通过setPriority()方法设置线程优先级。

线程组

可以将线程组成一组，以便了解组内线程的各种情况，对组内线程进行操作，如查看运行数量、终结数量等。当然，线程组（java.lang.ThreadGroup）也是一个对象。JVM默认将main线程以及main线程创建的线程放入main线程组中。当然，子线程默认放入父线程的线程组中。可以通过Thread构造方法设置一个线程的线程组。

  1. ThreadGroup tp = Thread.currentThread().getThreadGroup(); // 获取当前线程的线程组对象
  2. tp.getName(); // 获取当前线程组的名字
  3. tp.maxPriority(); // 获取线程组中线程最大优先级
  4. ThreadGroup group = new ThreadGroup("group1"); // 新建名为group1的线程组
  5. Thread t = new Thread(group, new Runnable() {
  6.             @Override
  7.             public void run() { /*要执行的代码和方法*/ }
  8.         }, "Thread1"); // 新建线程Thread1加入线程组group1
  9. int a = t.activeCount(); // 获取线程组当前的活跃线程数
  10. Thread[] ts = new Thread[a];
  11. t.enumerate(ts); // 将当前的活跃线程放入ts中

四、线程的状态

这是线程中较为重要的章节，主要描述了线程的各种状态和状态的转换。

状态的种类

在java.util.Thread中，线程主要有6种不同的状态：新建（New）、可运行（Runnable）、锁阻塞（Blocked）、无限期等待（Waiting）、有限期等待（Timed-waiting）和终止（Terminated）。其中的可运行的状态还可分为就绪（Runnable）和运行中（Running）两种；Timed-waiting、Waiting和Blocked是三种不同的等待/阻塞状态，此时线程不执行代码，也不参与CPU时间片的争夺。

状态 说明
新建
New		 线程刚被创建，还没调用start方法；或者刚刚调用了start方法，但线程还未完全启动
可运行
Runnable		 就绪
Runnable		 线程尝试抢占CPU资源，但未抢占到
运行
Running		 线程抢占到了CPU资源正在运行
等待/
阻塞		 有限期等待
Timed-waiting		 等待一段时间，待时间期限结束后恢复可运行状态
无限期等待
Waiting		 等待一段未知的时间，待其它线程将其唤醒进入可运行状态
锁阻塞
Blocked		 有线程正在执行并上了锁，需要等待解锁后才能进入就绪状态
终止
Terminated		 线程的run方法运行结束，线程终止

线程的状态的对象（State）可以通过getState()方法获取。

状态的转换

（一）最简单的线程生命周期

最简单的一个线程的历程就是：线程在创建后通过start()方法被执行，通过多次抢到CPU执行权，“断断续续”把run方法执行完成，最终终止运行。 进程和线程 - 图1

（二）暂停一下

当线程之间出现数据交换、因IO等原因需要暂停、执行某些原子操作时，一些线程就会被阻塞。
线程之间的转换主要是Runnable和三种阻塞状态之间的转换。线程之间的转换主要依赖各种方法的手动执行和JVM自动执行。以下是等待和运行状态之间转换的方法：

  • Thread.sleep(time)：该静态方法可以让当前执行的线程暂时休眠指定的time毫秒。线程会从Runnable状态进入Timed-waiting状态。
  • thread.join()：让当前线程从Runnable状态进入Waiting状态，等待thread线程执行结束后再恢复。
    • thread.join(time)：让当前线程从Runnable状态进入Timed-waiting状态，让thread线程执行至多time毫秒后恢复。
  • thread.interrupt()：打断thread线程的Timed-waiting状态或Waiting状态，让其恢复为Runnable的就绪状态。

    当某个正处于等待状态线程被打断后，会抛出InterruptedException异常。如果这部分代码被try-catch块包裹，则会跳到catch块，不会执行try块的后续代码，这点需要注意。

当线程处于等待状态时，会时刻监控着打断标识。打断标识默认为false；当标识置true时，系统会抛出异常并打断等待状态，然后将标识置回false。
当调用了某个线程对象的interrupt方法后，interrupt方法会调用interrupt0()的本地方法将打断标识置true。可以调用线程对象的isInterrupted()方法获取该线程的打断标识；可以调用Thread.interrupted()静态方法获取当前线程的打断标识，并将其置false。isInterrupted方法和Thread.interrupted方法都调用了isInterrupted(boolean)的本地方法，当参数为true时，会将打断标识置false；否则不改变打断标识的值。

如果在其它线程（如main线程）调用一个线程对象的interrupted()方法将该线程打断，随后再使用该线程对象的isInterrupted()方法查看打断标识，因为两个线程获得时间片的先后顺序不一，即： 有可能是①被main线程调用的interrupted()打断 -> ②打断标识置true、抛异常 -> ③main线程抢到时间片、执行isInterrupted()方法返回true -> ④打断标识置false 也可能是①被main线程调用的interrupted()打断 -> ②打断标识置true、抛异常 -> ③打断标识置false -> ④main线程抢到时间片、执行isInterrupted()方法返回false 所以返回的有可能是true，也有可能是false。

线程安全

在多线程环境中，如果有多个线程并发访问堆区中同一个对象中的数据（即对象的属性和方法），或访问方法区的同一项数据（即类的静态成员和静态方法），并进行了修改操作，那么这个数据可能会出现和预期结果不符的情况，即这个线程是不安全的。
为了避免这种情况，可以为操作添加锁，当执行这段操作的代码时，该线程的时间片即使被其它线程抢占，其它线程会因处于锁阻塞状态而让回时间片，相当于时间片不被抢占，使得该操作具有原子性。使用synchronized修饰符可以为代码块或方法添加锁，实现线程同步。具有synchronized的代码块被称为同步代码块。
锁也是一种对象，任何对象都可以充当锁。

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         Object o = new Object();
  4.         List<Integer> list = new ArrayList<>();
  5.         Thread t1 = new Thread("t1") {
  6.             public void run() {
  7.                 synchronized (o) { // 这里的锁对象是o
  8.                     for i in range(10) { // 借用Python的伪代码😂
  9.                         list.add(i);
  10.                         System.out.println(Thread.currentThread().getName() + ": " + i);
  11.                     }
  12.                 }
  13.             }
  14.         };
  15.         Thread t2 = new Thread("t2") {
  16.             public void run() {
  17.                 synchronized (o) { // t2的锁对象和t1相同，都是o
  18.                     for i in range(100, 110) { // 再次借用Python的伪代码
  19.                         list.add(i);
  20.                         System.out.println(Thread.currentThread().getName() + ": " + i);
  21.                     }
  22.                 }
  23.             }
  24.         };
  25.         t1.start();
  26.         t2.start();
  27.     }
  28. }
  • 当多个代码块或方法使用了同一个锁对象时，当这些代码的其中一个代码执行时，正在执行的代码会拿到锁对象；其它代码在抢占到CPU时间片后因没有锁对象而进入锁阻塞状态，将时间片让回。反之，若使用的锁对象不一样，则操作不具有原子性。
  • 当为线程加锁时，线程的信息会被写入锁对象中。其它线程即使拿到锁，由于具有其它线程的信息，因此处于Blocked状态。当加锁的线程执行完毕后，会将锁对象的中的线程信息擦除。
  • 为一个方法添加synchronized关键字，相当于方法体被synchronized修饰的代码块所包裹。若方法为非静态方法，则锁对象为this；否则为当前类的类对象。

锁会在代码块或方法执行完毕后释放。锁也可以通过锁对象的wait()方法释放：

  1. synchronized (o) {
  2.     for i in range(10) {
  3.         list.add(i);
  4.         if(i == 5) {
  5.             o.wait(); // 当i循环到5时，释放锁对象，当前线程进入线程等待池
  6.         }
  7.         System.out.println(Thread.currentThread().getName() + ": " + i);
  8.     }
  9. }

当持有锁的线程的锁对象被释放后，线程会进入线程等待池，同时进入Waiting状态。也可以使用有参的wait(long time)方法进入Time-waiting状态，时间结束或被提前唤醒则进入Blocked状态。可以通过锁对象的notify()方法从线程等待池中随机唤醒一个线程，使其有可能持有锁；也可以使用notifyAll()方法唤醒线程等待池中的全部线程。
这三个方法是Object定义的非静态方法。只有一个对象作为锁对象时，且在被synchronized修饰的代码块中才可以调用这三个方法。
join方法也可以实现线程安全，但具有局限性，只能让进程按特定的顺序被执行，且具有被打断的风险。

Thread.yield()：？？？

总结

image.png
image.png

  • thread.start()
  • Thread.sleep(long time)
  • thread.join()
  • thread.join(long time)
  • thread.interrupt()
  • synchronized(object){}
  • object.wait()
  • object.wait(long time)
  • object.notify()
  • object.notifyAll()