并发编程1_初步认识多线程

Posted 2022-02-02 臭小子帅

一、进程与线程

• 进程
  进程是资源（CPU、内存等）分配的基本单位，它是程序执行时的一个实例。程序运行时系统就会创建一个进程，并为它分配资源，然后把该进程放入进程就绪队列，进程调度器选中它的时候就会为它分配CPU时间，程序开始真正运行。

• 线程
  线程是一条执行路径，是程序执行时的最小单位，它是进程的一个执行流，是CPU调度和分派的基本单位，一个进程可以由很多个线程组成，线程间共享进程的所有资源，每个线程有自己的堆栈和局部变量。线程由CPU独立调度执行，在多CPU环境下就允许多个线程同时运行。同样多线程也可以实现并发操作，每个请求分配一个线程来处理。

一个正在运行的软件(如迅雷)就是一个进程，一个进程可以同时运行多个任务( 迅雷软件可以同时下载多个文件，每个下载任务就是一个线程), 可以简单的认为进程是线程的集合。

线程是一条可以执行的路径。

对于单核CPU而言：多线程就是一个CPU在来回的切换，在交替执行。
对于多核CPU而言：多线程就是同时有多条执行路径在同时(并行)执行，每个核执行一个线程，多个核就有可能是一块同时执行的。

3. 进程与线程的关系
   一个程序就是一个进程，而一个程序中的多个任务则被称为线程。进程是表示资源分配的基本单位，又是调度运行的基本单位。，亦即执行处理机调度的基本单位。 进程和线程的关系：

一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。线程是操作系统可识别的最小执行和调度单位。

资源分配给进程，同一进程的所有线程共享该进程的所有资源。同一进程中的多个线程共享代码段(代码和常量)，数据段(全局变量和静态变量)，扩展段(堆存储)。但是每个线程拥有自己的栈段，栈段又叫运行时段，用来存放所有局部变量和临时变量，即每个线程都有自己的堆栈和局部变量。

处理机分给线程，即真正在处理机上运行的是线程。

线程在执行过程中，需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。

有了进程以后，为什么还会发明线程呢？

1. 在多核 CPU 中，利用多线程可以实现真正意义上的并行执行

2. 在一个应用进程中，会存在多个同时执行的任务，如果其中一个任务被阻塞，将会引起不依赖该任务的任务也被阻塞。通过对不同任务创建不同的线程去处理，可以提升程序处理的实时性

3. 线程可以认为是轻量级的进程，所以线程的创建、销毁比进程更快

二、如何创建多线程

继承 Thread 类、实现 Runnable 接口、实现Callable接口/FutureTask 、线程池

• 继承Thread类重写run()

  /**
   * 继承Thread类，重写run()
   * 
   */
  public class MyThread extends Thread
      @Override
      public void run() 
          System.out.println("MyThread run...");
          System.out.println(Thread.currentThread().getName());
      
  
      public static void main(String[] args) 
          MyThread myThread = new MyThread();
          //设置线程名称
          //myThread.setName("myThread");
          myThread.start();
      
  
  

  缺点： 如果自己的类已经 extends 另一个类，就无法直接 继承Thread类来实现了

• 实现Runnable接口

  /**
   * 实现Runnable接口
   */
  public class MyRunnable implements Runnable
      @Override
      public void run() 
          System.out.println("MyRunnable run...");
      
  
      public static void main(String[] args) 
          new Thread(new MyRunnable()).start();
          //自定义线程名称
          new Thread(new MyRunnable(),"threadName").start();
          //java8直接写
          new Thread(()->
              System.out.println("run...");
          ,"ThreadName").start();
      
  
  

• 实现 Callable 接口通过 FutureTask 包装器来创建 Thread 线程

/**
 * 带返回值的线程
 */
public class MyCallable implements Callable<String> 
    @Override
    public String call() throws Exception 
        int a = 1;
        int b = 1;
        return "执行结果:" + (a+b);
    

    public static void main(String[] args) throws ExecutionException, InterruptedException 
        // 将Callable包装成FutureTask，FutureTask也是一种Runnable
        MyCallable callable = new MyCallable();
        FutureTask<String> futureTask = new FutureTask<>(callable);
        new Thread(futureTask).start();

        // get方法会阻塞调用的线程
        String sum = futureTask.get();
        System.out.println(sum);
    

三、线程的生命周期（状态）

java 线程既然能够创建，那么也势必会被销毁，所以线程是存在生命周期的，那么我们接下来从线程的生命周期开始去了解线程

线程一共有 6 种状态（NEW、RUNNABLE、BLOCKED、WAITING、TIME_WAITING、TERMINATED）

源码Thread.java类中有个State枚举类，里面定义了这六种状态以及一些英文注释，你们可以自己看下。

• NEW

  初始状态，线程被构建，但是还没有调用 start 方法

• RUNNABLE

  运行状态，JAVA 线程把操作系统中的就绪和运行两种状态统一称为“运行中”。

• BLOCKED

  阻塞状态，表示线程进入等待状态,也就是线程因为某种原因放弃了 CPU 使用权，阻塞也分为几种情况

  • 等待阻塞： 运行的线程执行 wait 方法，jvm 会把当前线程放入到等待队列

  • 同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被其他线程锁占用了，那么 jvm 会把当前的线程

    放入到锁池中

  • 其他阻塞：运行的线程执行 Thread.sleep 或者 t.join 方法，或者发出了 I/O 请求时，JVM 会把当前线程设置

    为阻塞状态，当 sleep 结束、join 线程终止、io 处理完毕则线程恢复

• WAITING

  等待状态

• TIME_WAITING

  超时等待状态，超时以后自动返回

• TERMINATED

  终止状态，表示当前线程执行完毕

  
  ps： 该图片来自《Java并发编程的艺术》，强烈推荐阅读

四、线程的启动

为什么我们调用 start() 方法时会执行 run() 方法，为什么我们不能直接调用 run() 方法？

new 一个 Thread，线程进入了新建状态。调用 start()方法，会启动一个线程并使线程进入了就绪状态，当分配到时间片后就可以开始运行了。 start() 会执行线程的相应准备工作，然后自动执行 run() 方法的内容，这是真正的多线程工作。 但是，直接执行 run() 方法，会把 run() 方法当成一个 main 线程下的普通方法去执行，并不会在某个线程中执行它，所以这并不是多线程工作。

总结： 调用 start() 方法方可启动线程并使线程进入就绪状态，直接执行 run() 方法的话不会以多线程的方式执行。

五、线程的终止和复位

线程的终止，并不是简单的调用 stop 命令去停止。

虽然 api 仍然可以调用，但是和其他的线程控制方法如 suspend、resume 一样都是过期了的不建议使用，

就拿 stop 来说，stop 方法在结束一个线程时并不会保证线程的资源正常释放，因此会导致程序可能出现一些不确定的状态（相当于kii -9）。

如何优雅的停止线程？

interrupt()

通过isInterrupted()可以判断 当前线程是否被中断，默认false

调用interrupt()方法，将 isInterrupted()的值改为了true

当其他线程通过调用当前线程的 interrupt 方法，表示向当前线程打个招呼，告诉他可以中断线程的执行了，至于什么时候中断，取决于当前线程自己。

线程通过检查是否被中断来进行相应业务处理，可以通过isInterrupted()来判断是否被中断

通过下面这个例子，来实现了线程终止的逻辑

public class InterceptorDemo 

    private static int i = 0;

    public static void main(String[] args) throws InterruptedException 

        Thread threadA = new Thread(() -> 
            while (!Thread.currentThread().isInterrupted()) 
                //如果当前线程没有被中断
                i++;
            
            System.out.println("执行结束：" + i);
        );
        threadA.start();
        Thread.sleep(3);
        //中断threadA线程
        threadA.interrupt();
    

可以自己试下加不加 threadA.interrupt(); 的效果

线程复位

上面的案例中，通过 interrupt，设置了一个标识告诉线程可 以 终 止 了 ， 线 程 中 还 提 供 了 静 态 方 法

Thread.interrupted()对设置中断标识的线程复位，即将 isInterrupted()的值改为了false

1. interrupted() 复位

interrupted()对设置中断标识的线程复位，即将 isInterrupted()的值改为了false

实例演示如下：

public class InterceptorDemo 

    private static int i = 0;

    public static void main(String[] args) 
        Thread threadA = new Thread(() -> 
            while (Thread.currentThread().isInterrupted()) 
                System.out.println("执行1：" + Thread.currentThread().isInterrupted());
                //对线程进行复位，由 true 变成 false
                Thread.interrupted();
                System.out.println("执行2：" + Thread.currentThread().isInterrupted());
            
        );
        threadA.start();
        //中断threadA线程
        threadA.interrupt();
    

2. InterruptedException

除了通过 Thread.interrupted 方法对线程中断标识进行复位 以 外 ， 还 有 一 种 被 动 复 位 的 场 景 ， 就 是 对 抛 出InterruptedException

异 常 的 方 法 ， 在InterruptedException 抛出之前，JVM 会先把线程的中断标识位清除，然后才会抛出 InterruptedException，这个时

候如果调用 isInterrupted 方法，将会返回 false

换句话说就是，当阻塞方法收到中断请求的时候就会抛出InterruptedException异常，在抛出异常之前，JVM 会先把线程的中断标识位清除；

抛出InterruptedException异常阻塞方法：Thread.sleep()、Object.wait()、Thread.join()

实例演示如下：

public class InterceptorDemo 

    public static void main(String[] args) throws InterruptedException 
        Thread threadA = new Thread(() -> 
            try 
                TimeUnit.SECONDS.sleep(1);
             catch (InterruptedException e) 
                e.printStackTrace();
            
            System.out.println(Thread.currentThread().isInterrupted());//false
        );
        threadA.start();
        //中断threadA线程
        threadA.interrupt();
        System.out.println(threadA.isInterrupted());//true
    

为什么 Object.wait、Thread.sleep 和 Thread.join 都 会 抛 出InterruptedException?

---

你会发现这几个方法有一个共同 点，都是属于阻塞的方法，而阻塞方法的释放会取决于一些外部的事件，但是阻塞方法可能因为等不到外部的触发事件而导致无法终止，所以它允许一个线程请求自己来停止它正在做的事情。

当一个方法抛出 InterruptedException 时，它是在告诉调用者如果执行该方法的线程被中断，它会尝试停止正在做的事情

并且通过抛出 InterruptedException 表示提前返回。所以，这个异常的意思是表示一个阻塞被其他线程中断了。

然 后 ， 由 于 线 程 调 用 了 interrupt() 中 断 方 法 ， 那 么Object.wait、Thread.sleep 等被阻塞的线程被唤醒以后会

通过 is_interrupted 方法判断中断标识的状态变化，如果发现中断标识为 true，则先清除中断标识，然后抛出InterruptedException需要注意的是，InterruptedException 异常的抛出并不意味着线程必须终止，而是提醒当前线程有中断的操作发生，

至于接下来怎么处理取决于线程本身，比如

1. 直接捕获异常不做任何处理
2. 将异常往外抛出
3. 停止当前线程，并打印异常信息

参考

[0] https://blog.csdn.net/vbirdbest/article/details/81282163