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

最新推荐文章于 2023-03-10 07:35:47 发布
最新推荐文章于 2023-03-10 07:35:47 发布
阅读量157 收藏 1
点赞数 1
分类专栏： 并发编程 文章标签： 多线程 thread java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shuai8624/article/details/118066633
版权

一、进程与线程

  • 进程
    进程是资源（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

臭小子帅
关注
专栏目录
多线程线程的优势
春风化雨
02-21 1621
1、发挥多核CPU 的优势 现在的笔记本、台式机乃至商用的应用服务器一般都是2核、4 核、8 核甚至 16 核；如果是单线程的程序，那么在双核 CPU 上就浪费了 50%， 在 4 核CPU 上就浪费了 75%。单核 CPU 上所谓的"多线程"那是假的多线程，同一时间处理器只会处理一段逻辑，只不过线程之间切换得比较快，看着像多个线程"同时"运行罢了。多核CPU 上的多线程才是真正的多线程，能实现多段逻辑同时工作。多线程，可以真正发挥出多核CPU 的优势来，达到充分利用CPU 的目的。 2、防止阻塞 从
Thread的Interrupted()方法
Kslient的博客
01-08 6803
在JDK1.0中，可以用stop方法来终止，但是现在这种方法已经被禁用了，改用interrupt方法。 Thread.interrupt()方法不会中断一个正在运行的线程。它的作用是，在线程受到阻塞时抛出一个中断信号，这样线程就得以退出阻塞的状态。更确切的说，如果线程被Object.wait,Thread.join和Thread.sleep三种方法之一阻塞，那么，它将接收到一个中断异常（Inte
Thread::interrupted() 什么意思？ 如何中断线程?
最新发布
liuruiaaa的博客
03-10 1213
Thread::interrupted() 什么意思？ 如何中断线程?
Thread.interrupted、Thread.isInterrupted、Thread.interrupt
Pelb的博客
12-22 1257
interrupt() 调用线程的interrupt方法，并不能真正中断线程，只是给线程做了中断状态的标志 在一个线程中调用另一个线程的interrupt()方法，即会向那个线程发出信号——线程中断状态已被设置。至于那个线程何去何从，由具体的代码实现决定。 常见现象：“当调用interrupt方法时，调用对象的线程就会抛出InterruptedException异常”，如果检查线程中断状态...
线程中断 interrupted()、interrupt()、isInterrupted()方法用法及详解
qq_45328505的博客
05-25 1225
一、设置标志位 缺点：当try catch中sleep()较长时间时，不能及时中断。 本应该在3秒之后就及时中断，但在程序处于阻塞状态，没有中断 class StopThreadTest1 { private volatile static boolean IS_STOP; public static void main(String[] args) throws InterruptedException { new Thread(()->{
汪文君高并发编程实战视频资源下载.txt
08-08
│ 高并发编程第一阶段05讲、采用多线程方式模拟银行排队叫号.mp4 │ 高并发编程第一阶段06讲、用Runnable接口将线程的逻辑执行单元从控制中抽取出来.mp4 │ 高并发编程第一阶段07讲、策略模式在Thread和Runnable...
汪文君高并发编程实战视频资源全集
08-08
│ 高并发编程第一阶段05讲、采用多线程方式模拟银行排队叫号.mp4 │ 高并发编程第一阶段06讲、用Runnable接口将线程的逻辑执行单元从控制中抽取出来.mp4 │ 高并发编程第一阶段07讲、策略模式在Thread和Runnable...
Go错误处理与并发编程：errors包在多线程中的高级应用
[Go错误处理与并发编程：errors包在多线程中的高级应用](https://user-images.githubusercontent.com/863731/71620291-76d03980-2bc9-11ea-97cb-76c58684eb1e.png) # 1. Go语言并发编程基础 Go语言自其发布起，便以...
多线程与并发编程：提升程序的性能与效率
在计算机编程领域，多线程与并发编程是一种重要的编程模式，它们可以帮助程序更有效地利用计算机资源，提高程序的性能和效率。 多线程是指在同一程序中同时执行多个独立任务的能力，每个任务称为一个线程。多线程...
【Go语言并发编程】：类型断言在多线程环境下的注意事项
[【Go语言并发编程】：类型断言在多线程环境下的注意事项](https://www.sohamkamani.com/golang/mutex/banner.drawio.png?ezimgfmt=ng%3Awebp%2Fngcb1%2Frs%3Adevice%2Frscb1-2) # 1. Go语言并发编程概述 Go语言从...
【有料】线程中断：Thread类中interrupt（）、interrupted（）和 isInterrupted（）方法详解
daobuxinzi的博客
05-25 2233
首先看看官方说明： interrupt（）方法 其作用是中断此线程（此线程不一定是当前线程，而是指调用该方法的Thread实例所代表的线程），但实际上只是给线程设置一个中断标志，线程仍会继续运行。 interrupted（）方法 作用是测试当前线程是否被中断（检查中断标志），返回一个boolean并清除中断状态，第二次再调用时中断状态已经被清除，将返回一个false。 isInterrupted（）方法 作用是只测试此线程是否被中断 ，不清除中断状态 下面我们进..
Thread.interrupted()
以笔为刀的博客
03-30 2860
线程中断 1.线程有自己决定是否中断。其他的线程只能给当前线程设置中断标志位。然后当前线程去检测是否中断。然后自行决定是否中断。 2.Thread.interrupted() 该方法用于检测线程是否中断，以及清除中断标志位。当第二次调用这个方法的时候就会返回false。 3.如果线程被中断，当我们执行Thread.sleep()的时候会抛出中断异常。 Thread thread = new Thread(() -> { while (!Thread.
Thread类的interrupted()方法
gaoxuechao123的博客
01-19 4435
Thread类的interrupted()方法 Thread类的interrupted()方法 1,Thread类的interrupted方法是返回当前线程的被打断状态,同时清除打断状态 我们可以看到这个方法是直接调用isInterrupted方法,传了一个参数为true,意思是返回当前线程被打断状态的同时,清除打断状态,将打断状态置为false; 2,如果一个线程正在睡眠,被其他线程打断了(在其...
Thread类中interrupt（）、interrupted（）和isInterrupted（）方法详解
热门推荐
qq_39682377的博客
08-06 11万+
首先看看官方说明： interrupt（）方法 其作用是中断此线程（此线程不一定是当前线程，而是指调用该方法的Thread实例所代表的线程），但实际上只是给线程设置一个中断标志，线程仍会继续运行。   interrupted（）方法 作用是测试当前线程是否被中断（检查中断标志），返回一个boolean并清除中断状态，第二次再调用时中断状态已经被清除，将返回一个false。   ...
提升--02---线程的打断(interrupt)--线程的结束
时光里的博客
08-23 804
线程的打断(interrupt) interrupt相关的三个方法： interrupt只是设置标志位,并不是真的断开线程 public void interrupt() //t.interrupt() 打断t线程（设置t线程某给标志位f=true，并不是打断线程的运行） public boolean isInterrupted() //t.isInterrupted() 查询打断标志位是否被设置（是不是曾经被打断过） public static boolean int
Thread.interrupted()与Thread.currentThread().isInterrupted()区别
wyz0923的博客
06-19 7107
背景 今天在研究ThreadPoolExecutor源码时，在runWorker（Worker w）的方法中有一个判断条件分别用到了Thread.interrupted()和Thread.currentThread().isInterrupted() 。一之间没有看懂。就写了一个demo研究了一下，这里记录一下。 ThreadPoolExecutor.runWorker(Worker w) 的源码： 因为没有在工作中碰到，不是很明白Thread.interrupted() 和Thread.currentT
Thread中的中断方法interrupted
weixin_45739050的博客
04-20 192
Thread.interrupt（）方法，给线程添加一个中断标志，不是意味着这个线程马上结束，而是对线程起到一种通知的作用。 两种判断中断标志的方法，一种是静态方法interrupted，它可以获取标志，并且把中断标志清除，也就是返回fasle。还有一种方法是isinterrupted，它也可以获取标志，但是不会清楚中断标志。 sleep线程中使用interrupt可能会引起sleepinterr...
线程 interrupted 详细解析
杨坤的博客
05-27 826
目录 1.为什么这个方法值得我写个文章。？ 2.先看下例子 3. 研究下 下面3个方法的jvm层面实现 跟用法 3.1）thread.isInterrupted() 3.2）thread.interrupt(); 3.3）Thread.interrupted() 4.最后代码验证下 1.为什么这个方法值得我写个文章。？ 因为这个方法跟我们的字面意思不太一样。。。。我们想当然的以为 这个就是打断线程。。实际上不是 2.先看下例子 package com....
掌握VC多线程编程：C语言实战项目源码解析
1. 多线程编程概念：文档首先介绍了多线程编程的基本概念，包括线程、进程、同步和并发等。这些是理解多线程编程的基石，有助于读者构建起对多线程开发的初步认识。 2. Windows多线程原理：文档深入探讨了Windows...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

臭小子帅

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值