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

喜欢ヅ旅行 2022-10-08 05:40 191阅读 0赞

## 一、进程与线程 ##

*  进程  
    进程是资源（CPU、内存等）分配的基本单位，它是程序执行时的一个实例。程序运行时系统就会创建一个进程，并为它分配资源，然后把该进程放入进程就绪队列，进程调度器选中它的时候就会为它分配CPU时间，程序开始真正运行。
 *  线程  
    线程是一条执行路径，是程序执行时的最小单位，它是进程的一个执行流，是CPU调度和分派的基本单位，一个进程可以由很多个线程组成，线程间共享进程的所有资源，每个线程有自己的堆栈和局部变量。线程由CPU独立调度执行，在多CPU环境下就允许多个线程同时运行。同样多线程也可以实现并发操作，每个请求分配一个线程来处理。

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

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

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

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

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

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

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

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

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

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
    
    终止状态，表示当前线程执行完毕
    
    ![image-20210618175238584][]  
    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

[image-20210618175238584]: /images/20221005/9b1a8e87b83b4415b9286df9ed14adce.png