一、进程和线程

进程

在大多数操作系统中都可以创建多个进程(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()