你真的懂Thread吗?深入理解java多线程基础知识之thread核心概念精讲

已于 2024-08-18 22:48:33 修改
阅读量876 收藏 9
点赞数 11
分类专栏： 多线程知识 文章标签： java 开发语言
于 2024-08-18 22:14:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zypqqgc/article/details/141304815
版权

很多开发者在初学多线程的时候.比较关注同步原语,线程池,future等api.这当然没有错,然而当你想要深入理解一种技术的时候,必须把最基础,最核心的概念弄清楚.不然的话上层知识的堆砌都是无本之源。java多线程是一个很复杂的知识体系和话题。可以写成书籍，市面上也有不少介绍多线程知识的书籍。本篇文章主要讲解与thread相关的基础概念。帮助读者更加深入理解这个基础的api相关的概念。

1. 进程和线程

  • 进程是运行着的程序

程序是是指令和数据的集合

    • 线程是"轻量级"的进程,是计算机可以调度的的最小单元.线程不能单独存在,必须依附于进程,一个进程可以包含多个线程
      计算机多线程,多进程模型示意图
      多线程/进程模型示意

1.1 为什么要使用多进程/多线程?

为什么使用多线程/多进程模型,可以说出很多东西,总结起来一句话,那就是为了充分利用现代计算机核心/线程资源,达到提升应用程序计算效率的目的.通俗的讲,就是让程序跑的更快.

1.2 多进程/多线程创建方式及对应Linux C API

  • 启动多个进程
  • 使用fork函数创建进程
  • 使用pthread_create函数创建线程

在windows平台下,谷歌浏览器就是一个典型的多进程应用程序,当然同时也使用有多线程技术
多进程应用chrome

1.3典型多进程模式编程语言

python
虽然python也有线程api，但是由于gil的存在致使python无法真正在同一时刻并行执行任务。因此多线程api就显得比较鸡肋，在python中更多的是使用进程api

1.4典型多线程编程模式语言

JAVA,C#

当然可能还有其它的语言也是多线程模式语言，笔者并不太了解。这里仅仅以笔者用过的语言举例

2.java线程API

2.1 线程的创建

  1. 创建一个类,实现Runnable接口
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("hello,world");
    }
}
public static void main(String[] args) {
    Thread t=new Thread(new MyRunnable());
}
  1. 创建一个类,继承Thread类
public class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("hello,world");
    }
}
public static void main(String[] args) {
    MyThread myThread=new MyThread();
}
  1. Java8 通过Lambda创建
Thread t1=new Thread(()->{
    System.out.println("hello,world");
});

2.11线程创建建议

通过new Thread(Runnable对象,函数名)创建,不要通过new子类创建.

2.12创建线程的高级方法

public Thread(ThreadGroup group, Runnable target, String name,
long stackSize)

  • stackSize为0含义

stackSize值为0是默认行为，即使用通过xss设置的值

  • stackSize是否可以是任意long范围内的正整数?
    可否任意大,最大值受什么影响?
    ulimit

JAVA线程中可以设置任意值,即long范围内的任意值，这可能跟你想的不一样,但是不管如何java程序都是要运行的，在linux上不能超过Linux对进程的限制。如上图通过ulimit -a可以看到stack size值，我使用的是centos 7.6，默认是8M，即不能超过8M。当然这个值是可以调整的

还可以通过在程序启动时通过Xss指定栈大小
虽然程序中可以设置任意小,但是不能通过-Xss设置过小的值,否则会报错
为什么?因为这里是对进程的全局设置,值太小可能会导致程序无法正常运行
在这里插入图片描述

我们在启动时通过指定xss将值设置为500M再看看效果
在这里插入图片描述
通过命令查看，值确实好像是生效了。
在这里插入图片描述
这是否意味着真的设置生效了呢。答案是否定的，前面也说了java程序要运行在操作系统上。不管是windows还是linux都有栈大小限制。

以下是结论：

虽然Flag设置成功了,但是值会被忽略
通过-Xss设置的值过大时会被忽略
详细信息请查看openjdk bug报告

On Linux we do check if -Xss/ThreadStackSize is larger than ulimit value.
If ThreadStackSize exceeds the system limit, the stack size is quietly
reduced to ulimit value

2.2 线程的启动

public static void main(String[] args) {
    Thread t1=new Thread(()-> System.out.println("hello,world"));
    t1.run();
    t1.start();
}

run方法无法启动线程,会像普通函数调用一样同步执行,不会创建线程

2.21线程start是否是线程安全的?

public static void main(String[] args) {
    Thread t1=new Thread(()-> System.out.println("hello,world"));
    for (int i = 0; i < 3; i++) {
       t1.start();
    }
}

答案是肯定的，为什么，看源码可以看到start方法是被synchronized修饰的。thread其它相关的很多api也都有synchronized修饰。其实想一想就会明白。如果线程的创建、停止，暂停都无法保证安全，程序的可靠性将受到很大挑战。

2.22调用线程start方法是否会马上执行代码

Java里Thread start方法注释Causes this thread to begin execution;

在这里插入图片描述

在英语里面，带to的往往不代表正在进行，而是将要进行。

实际上在linux上，java创建线程是通过调用pthread_create 创建的

pthread_t thread;
int ret = pthread_create(&thread, NULL, &thread_function, NULL);

由于计算机资源的有限性，不可能所有的请求来了linux马上都为你创建一个线程。linux收到请求后将根据自己的调度策略在合适的时间为请求者创建线程。

2.23 一个java进程可以启动多少个线程,受哪些因素影响?

通过前面介绍可以知道，计算机为用户进程分配的资源都是有限的，并且计算机本身的资源也是有限的。因此不可能无限创建。但是线程创建的个数受哪些因素影响呢？

Linux用户进程最大栈尺寸限制

这个前面已经介绍过了。程序启动的时候可以以通过xss设置栈大小。创建thread对象时也可以指定栈大小。由于最大栈尺寸的限制，线程占用的栈空间越大，可创建的线程数量就越少

Linux最大进程数限制

通过pid_max可以查看linux最大进程数量是多少

看到这里很多同学可能会懵逼。我创建的是线程，为什么会受到linux最大进程数量的限制呢？其实了解了linux线程pid分配机制后就会明白了。比如一个进程的id是10.进程启动后创建的10个线程，那么这些线程的id就会顺着进程id递增分配。分别是11，12，13，14…也就是说，创建一个线程就会消耗一个linux进程pid 由于pid总量是有限制的，因此总的线程数不能超过linux pid max限制

public static void main(String[] args) {
    for (int i = 0; i < 20; i++) {
        Thread t=new Thread(()->{
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        t.start();
    }
}

在这里插入图片描述
我们的demo程序创建的10个线程。通过jps看到程序运行的进程id是25747
我们通过top -H -p查看java demo程序里的子线程。可以看到线程的id是顺着25747依次再分配的

2.24线程的阻塞以及如何获取线程执行结果

@Data
public class Student {
    private String name;
}
public static void main(String[] args) throws Exception{
    Student student=new Student();
    Thread t=new Thread(()->{
        //do some work
        student.setName("Baidu");
    });
    t.start();
    t.join();
    System.out.println(student.getName());
}

以上我们通过thread.join阻塞当前线程直到子线程运行完成，后面就可以输出结果了

2.25封装自己的Future

public interface MyCallable<T> {
    T call();
}
public class MyFuture<T> extends Thread{
    T result=null;
    private MyCallable<T> task;

    public MyFuture(MyCallable<T> task){
        this.task = task;
    }
    @Override
    public void run() {
        //do someWork
      result= task.call();
    }

    public T myGet(){
        try {
            this.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return result;
    }
}
public static void main(String[] args) throws Exception{
    MyFuture<String> myFuture=new MyFuture<>(()->"hello,world");
    myFuture.start();
    String s1 = myFuture.myGet();
}

前面我们也说过，在设计上尽量不要继承Thread，下面展示一个改进版

public class MyFutureV2<T> implements Runnable{
    T result=null;
    private MyCallable<T> task;
    public MyFutureV2(MyCallable<T> task){
        this.task=task;
    }
    @SneakyThrows
    @Override
    public void run() {
        result= task.call();
        synchronized (this){
            notify();
        }
    }

    @SneakyThrows
    public T myGet() {
        synchronized (this){
            wait();
        }
        return result;
    }
}
public static void main(String[] args) throws Exception{
    MyFutureV2<String> myFuture=new MyFutureV2<>(()->"hello,world");
    Thread t=new Thread(myFuture);
    t.start();
    String s = myFuture.myGet();
}

不继承thread对象，我们就没有join方法可以使用了。这里我们使用的是对象的wait和notify机制。

我们封装很多高级的api都离不开基础知识，只有理解并掌握他们了才能灵活运用。

2.3线程的终止

2.31为什么线程的stop方法被弃用了

Java Thread stop方法的注释:Forces the thread to stop executing.翻译成人话就是强制终止当前运行的线程，太过暴力
thread stop导致线程不安全示例

public class StopThread extends Thread{
   
      private int i=0;
   
      private int j=0;
   
      @Override
      public void run(){
         synchronized (this) {//增加同步锁，确保线程安全
            ++i;
            try {
               //休眠5秒,模拟耗时操作
               Thread.sleep(5000);
            } catch (InterruptedException e) {
               e.printStackTrace();
            }
            ++j;
         }
      }
      /**
       * 打印i和j
       */
      public void print(){
         System.out.println("i="+i+" j="+j);
      }
   }
   public static void main(String[] args) throws Exception{
    StopThread thread=new StopThread();
    thread.start();
    try {
        //休眠1秒，确保i变量自增成功
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    //终止线程
    thread.stop();
    while(thread.isAlive()){//确保线程已经终止
    }
    //输出结果
    thread.print();
}

在这里插入图片描述
我们强制线上程序，最终导致程序执行状态不正确，这是很严重的问题！

在这里插入图片描述
在这里插入图片描述
正在做的事情要让它做完，不然后果很严重。

2.32interrupt方法无法中断线程

public class MyThreadInterruptable implements Runnable {
    
    @Override
    public void run() {
       while (true){
           System.out.println("正在运行中");
       }
    }
}
 
  public static void main(String[] args) throws InterruptedException {
 
        MyThreadInterruptable myThread = new MyThreadInterruptable();
        Thread thread = new Thread(myThread);
        thread.start();
        // 为了使效果更明显，使当前线程休眠一秒
        Thread.sleep(1000);
        // 中断线程
        thread.interrupt();
    }

interrupt方法只是发出中断信号，本身并不能终止线程执行大家切不可望文生义

2.33线程终止正确姿势1

    @Override
    public void run() {
       while (true){
           // 判断线程是否被中断
           if(Thread.interrupted()){
               break;
           }
           System.out.println("正在运行中");
       }
    }
 
 
    public static void main(String[] args) throws InterruptedException {
 
        MyThreadInterruptable myThread = new MyThreadInterruptable ();
        Thread thread = new Thread(myThread);
        thread.start();
        // 为了使效果更明显，使当前线程休眠一秒
        Thread.sleep(1000);
        // 中断线程
        thread.interrupt();
    }

public class MyThreadInterruptable implements Runnable{
    @Override
    public void run() {
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            System.out.println("sleep is interrupted");
            e.printStackTrace();
        }
    }
}
public static void main(String[] args) throws Exception{
    MyThreadInterruptable myThread = new MyThreadInterruptable ();
    Thread thread = new Thread(myThread);
    thread.start();
    // 中断线程
    thread.interrupt();
}

第一种是写个死循环查看interrupt状态是否改变。第二种是catch住InterruptedException异常。thread.interrupt()会抛出中断信号

> 网上有不少示例都是一大抄。使用while死循环来监听状态改变，这并不是一件有趣的事。为了响应中断写个死循环，拜拜浪费cpu资源。

多线程技术应用

3.1 idea线程调试thread断点模式

public static void main(String[] args) throws Exception{
    for (int i = 0; i < 3; i++) {
        Thread t=new Thread(()->{
            while (true){
                System.out.println(Thread.currentThread().getName());
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"t"+i);
        t.start();
    }
    SpringApplication.run(ConcurrentdemoApplication.class, args);
}

在这里插入图片描述
什么意思呢。有时候我们调度多线程程序的时候，断点老是补干扰，一次执行还没完，断点又来了。使用thread模式就可以解决这种苦恼，专注于调度单个线程内的执行逻辑。

3.2快速定位失去响应代码

有时候我们的程序在启动的时候一直卡着不动，日志也不输出了，到底问题出在了哪里呢？

@RestController()
@RequestMapping("/slow")
public class SlowController {
    @RequestMapping("/slowTest")
    public void slowTest(){
        try {
            Thread.sleep(1500000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

@Override
public void afterPropertiesSet() throws Exception {
    URL url = new URL("http://localhost:7001/slow/slowTest");
    URLConnection urlConnection = url.openConnection();
    HttpURLConnection httpUrlConnection = (HttpURLConnection) urlConnection;
    InputStream inputStream = httpUrlConnection.getInputStream();
}

以上模拟一个耗时很长的接口，我们在另一个程序启动的时候调用这个接口

程序好像卡住了
在这里插入图片描述

调试模式下点击暂停应用按钮,程序断在当前正在执行的行

在这里插入图片描述
切到调试面板,找到当前应用程序内执行的方法

在这里插入图片描述
最终通过堆栈分析，我们定位到失去响应的代码

在这里插入图片描述

3.3 CPU负载过高分析示例

public class HeavWorkTask implements Runnable {
    private int index;

    public HeavWorkTask(int i) {
        this.index = i;
    }

    @Override
    public void run() {
        while (true) {
            if (index != 0) {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
public static void main(String[] args) throws Exception{
    for (int i = 0; i < 10; i++) {
        Thread t=new Thread(new HeavWorkTask(i));
        t.start();
    }
    SpringApplication.run(ConcurrentdemoApplication.class, args);
}

在这里插入图片描述
我们先通过jps拿到java进程id，然后通过 pidstat -t -p 来查看分析哪个线程占用cpu资源过高。我们看到thread_0 cpu占用达到了101。

下面我们看一下java堆栈信自的内容是什么样子的

在这里插入图片描述
可以看到最前面是线程名称。我们可以通过cpu过高线程thread-0名称来过滤

在这里插入图片描述

也可以通过拿到线程的id然后转成十六进制根据tid一栏来搜索。根据id结果更精确。但是需要注意的是这里的id 是线程的nativeid，并不是java程序给线程分配的id。

3.4.2根据线程Native Id过滤堆栈信息

将线程Native Id转为十六进制显示形式,CPU占用高的线程ID18094对应的十六进制为46ae

在这里插入图片描述

国通快递驿站
关注
  • 11
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java多线程实战精讲-带你一次搞明白Java多线程高并发
07-07
本文将深入探讨Java多线程的相关知识点，帮助你全面理解并掌握这一核心概念。 1. **线程基础** - **线程定义**：线程是操作系统分配CPU时间的基本单位，每个进程至少包含一个线程。 - **线程创建**：Java提供了两...
Java多线程技术精讲
08-11
Java多线程技术是Java编程中的重要组成部分，它允许程序同时执行多个任务，...在实际开发中，结合《Java多线程编程核心技术_完整版 带书签目录.pdf》这样的学习资料，辅以实践，将有助于你更好地驾驭Java多线程的世界。
JAVA基础知识精讲，深入浅出
08-04
本精讲将深入浅出地探讨Java的基础知识，旨在为初学者提供一个全面且易理解的学习路径。 1. **Java简介**：Java是由Sun Microsystems（现为Oracle Corporation）于1995年发布的，它的设计目标是“一次编写，到处...
JAVA核心知识点整理.zip
10-23
6. **多线程**：Java提供了丰富的多线程支持，包括Thread类、Runnable接口和并发包（java.util.concurrent）。学习如何创建和管理线程，以及同步机制（如synchronized关键字、锁对象和wait/notify机制）是多线程编程...
java知识精讲+500+面试题.zip
10-26
6. **多线程**：Java提供了强大的多线程支持，如Thread类和Runnable接口，理解线程的同步和互斥，熟悉synchronized关键字、wait()、notify()等方法对于编写并发程序非常重要。 7. **反射机制**：Java反射API允许...
Java基础（6）- Java代码笔记3
weixin_47062560的博客
08-30 1372
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。
浅析synchronized锁升级的原理与实现 1
最新发布
水w的博客
09-01 864
浅析synchronized锁升级的原理与实现
《深入理解 Java 中的适配器模式》
面团到油条的成长日记
08-29 7027
在软件开发的广阔领域中，不同接口之间不匹配的问题时常像个棘手的难题困扰着开发者。而适配器模式就像是一位得力的助手，专门用来解决这类问题。它的关键作用在于把一个类的接口有效地转化为客户端所期望的另一种接口，让原本因接口不相符而不能一起工作的两个类可以共同协作，学习本文希望你能有所收获
Java设计模式之建造者模式详细讲解和案例示范
weixin_39996520的博客
08-28 5472
建造者模式是一种创建型设计模式，允许用户通过一步步地构造复杂对象的方式来避免直接使用大量的构造函数或复杂的初始化过程。它通过将对象的创建过程分解为多个步骤，并允许这些步骤以链式调用的方式来执行，最终生成一个完全构建的对象。首先，我们定义一个Order类，该类包括了多个字段，如订单ID、客户信息、商品列表、配送地址等。// Getter方法省略...在这个例子中，类提供了构建Order对象所需的各个方法，每个方法返回实例，以便进行链式调用。
深度解读并发安全集合的原理及源码
DougLiang的博客
09-01 1024
本节主要介绍J.U.C包中的几种并发安全集合：ConcurrentHashMap,ConcurrentLinkedQueue,和ConcurrentLinkedDeque。所谓并发安全集合，相对于普通集合来说，能够保证在多线程环境下向集合中添加数据时的线程安全性。主要讲ConcurrentHashMap在实现线程安全性方面对性能和安全性的合理平衡。
C++的内存模型
qhu1600417010的博客
08-28 1124
C++ 的内存模型包含了程序运行时如何分配、访问、管理内存的规则，涵盖了多线程环境下的数据一致性、内存对齐、以及虚拟内存管理等内容。掌握这些概念对于编写高效、安全的 C++ 程序至关重要。
优秀的开源项目
猪猪
08-28 572
目录热key多线程并行秒级百G级日志工具ES操作工具消息推送平台HTTP 客户端业务层的分布式限流组件企业级微服务解决方案hotkey: 京东App后台中间件，毫秒级探测热点数据，毫秒级推送至服务器集群内存，大幅降低热key对数据层查询压力asyncTool: 解决任意的多线程并行、串行、阻塞、依赖、回调的并行框架，可以任意组合各线程的执行顺序，带全链路执行结果回调。多线程编排一站式解决方案。来自于京东主App后台。asyncTool: 解决任意的多线程并行、串行、阻塞、依赖、回调的并行框架，可以任意组合各
输入三个正整数，找出不大不小的值
laocooon的博客
08-30 886
/ 找出最大值，找出最小值，然后不是最大值也不是最小值的。// 2、输入三个正整数，找出不大不小的值。
spring-data-redis中RedisRepository仓储
OceanSky的专栏
08-27 498
Id@RedisHash注解的value属性和@Id注解指定键值的命名空间，组合成user:id；@RedisHash的属性timeToLive属性指定键值的超时时间。CrudRepository接口中默认定义实现了save、saveAll、findById、existsById、findAll、findAllById、count、deleteById、delete、deleteAllById、deleteAll等方法，基本满足了对redis操作的需求；如果有特殊需求可以自定义实现。
SpringBoot日常：扩展接口之CommandLineRunner和ApplicationRunner
qq_32590535的博客
08-28 512
日常开发中我们可能经常会遇到这样的场景，像启动容器完成后需要去执行一些业务逻辑，SpringBoot给我们提供了两个接口来帮助我们实现这种需求，两个启动加载接口分别是CommandLineRunner和ApplicationRunner。本文简单介绍如何使用该扩展点实现业务。
JVM 内存参数
iOS逆向与安全
08-29 2024
它屏蔽了与具体操作系统平台相关的信息，使Java程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在各种平台上不加修改的运行。‌例如，‌可以将最小堆内存设置为2GB（‌-Xms2048m）‌，‌最大堆内存设置为4GB（‌-Xmx4096m）‌。如果初始化的高水位线设置过低，会频繁的触发Full GC，高水位线会被多次调整。一般来说，垃圾回收器都会有默认的对象晋升到老年代的年龄参数阈值，CMS默认是6，G1默认是15，不过这参数值也不是一成不变的，它会根据动态年龄判断规则来重新被赋值。
Java并发编程 进程与线程
m0_56369671的博客
08-28 1022
操作系统中有一个组件叫做任务调度器，将 cpu 的时间片（windows下时间片最小约为 15 毫秒）分给不同的程序使用，只是由于 cpu 在线程间（时间片很短）的切换非常快，人类感觉是 同时运行的。但如果是四核 cpu，各个核心分别使用线程 1 执行计算 1，线程 2 执行计算 2，线程 3 执行计算 3，那么 3 个线程是并行的，花费时间只取决于最长的那个线程运行的时间，即 11ms 最后加上汇总时间只会花费 12ms 注：需要在多核 cpu 才能提高效率，单核仍然时是轮流执行。
SpringBoot SSM vue在线作业考试系统
yinjl123456的博客
08-30 632
使用技术: SpringBoot或SSM + Mybaits + Mysql + vue(前端)后台管理 登录注册 个人中心 教师信息管理 学生信息管理 学院信息管理 专业信息管理。班级信息管理 作业信息管理 作业提交管理 通知公告管理 试卷管理 试题管理。系统管理 管理员管理 考试管理。
Java 虚方法表（虚函数）
一心向阳，光芒万丈
08-31 451
虚方法表是一个类的内部数据结构，用于支持方法的动态绑定（即运行时多态）。每个类在加载时会生成一个虚方法表，其中包含了类中所有虚方法的地址。方法地址的存储：虚方法表存储了类的所有方法（包括继承自父类的方法）的内存地址或指针。这些方法在虚方法表中的顺序与它们在类中声明的顺序一致。动态绑定：当方法调用发生时，JVM 会根据对象的实际类型（而不是声明类型）来查找并调用正确的方法实现。这种机制允许程序在运行时决定调用哪个方法，从而实现多态。被privatestaticfinal。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

国通快递驿站

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

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

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

打赏作者

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

抵扣说明：

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

余额充值