【Java并发编程 | JUC】线程

最新推荐文章于 2024-09-08 21:42:31 发布
最新推荐文章于 2024-09-08 21:42:31 发布
阅读量604 收藏 4
点赞数 2
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wmh1024/article/details/141983860
版权

Java 线程

项目配置

pom.xml

<dependencies>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.10</version>
    </dependency>
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.2.3</version>
    </dependency>
</dependencies>

logback.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration
        xmlns="http://ch.qos.logback/xml/ns/logback"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://ch.qos.logback/xml/ns/logback logback.xsd">
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%date{HH:mm:ss} [%t] %logger - %m%n</pattern>
        </encoder>
    </appender>
    <logger name="c" level="debug" additivity="false">
        <appender-ref ref="STDOUT"/>
    </logger>
    <root level="ERROR">
        <appender-ref ref="STDOUT"/>
    </root>
</configuration>

多线程概述

进程与线程

程序：一组静态的指令集

进程：程序运行的一个实例

线程：进程中的一个执行单元

并行与并发

并发 concurrent：单个核心通过任务调度器，线程轮流使用 CPU

并行 parallel：多个核心同时运行

同步与异步

同步：需要等待返回

异步：不需要等待返回

I/O 操作不占用 CPU

创建线程

Thread 类

@Slf4j(topic = "c.App")
public class App {
    public static void main(String[] args) {
        Thread t = new Thread(() -> log.info("Thread t"));
        t.setName("t");
        t.start();
        log.info("Thread main");
    }
}

Runable 接口

将任务和线程分离，代码更灵活

组合优于基础

@Slf4j(topic = "c.App")
public class App {
    public static void main(String[] args) {
        Runnable func = () -> log.info("Thread t");
        Thread t = new Thread(func, "t");
        t.start();
        log.info("Thread main");
    }
}

Callable 接口 & FutureTask 类

@Slf4j(topic = "c.App")
public class App {
    public static void main(String[] args) 
        throws ExecutionException, InterruptedException {
        FutureTask<Integer> task = new FutureTask<>(() -> {
            log.info("Thread t running");
            Thread.sleep(1000);
            return 114514;
        });
        new Thread(task, "t").start();
        Integer res = task.get();
        log.info("Thread main - {}", res);
    }
}

线程运行的原理

栈与栈帧

每个线程都有一个栈，栈内有多个栈帧，每个栈帧对定一个方法。

每个线程只有一个活动帧（栈顶的栈帧），对应正在执行的方法。

线程上下文切换

导致 cpu 切换运行其他线程的原因：

  1. 线程时间片用完
  2. 垃圾回收
  3. 有更高优先级进程
  4. 线程调用了 sleep、wait 等方法

线程上下文切换时需要保存进程状态，并恢复另一个线程状态。

Thread 类方法

API

方法说明
public void start()启动一个新线程，Java虚拟机调用此线程的 run 方法
public void run()线程启动后调用的方法
public void setName(String name)给当前线程取名字
public void getName()获取当前线程的名字
默认名称：子线程是 Thread-索引，主线程是 main
public static Thread currentThread()获取当前线程对象，代码在哪个线程中执行
public static void sleep(long time)让当前线程休眠多少毫秒再继续执行
Thread.sleep(0) : 让操作系统立刻重新进行一次 CPU 竞争
public static native void yield()提示线程调度器让出当前线程对 CPU 的使用
public final int getPriority()返回此线程的优先级
public final void setPriority(int priority)更改此线程的优先级，常用 1 5 10
public void interrupt()中断这个线程，异常处理机制
public static boolean interrupted()判断当前线程是否被打断，清除打断标记
public boolean isInterrupted()判断当前线程是否被打断，不清除打断标记
public final void join()等待这个线程结束
public final void join(long millis)等待这个线程死亡 millis 毫秒，0 意味着永远等待
public final native boolean isAlive()线程是否存活（是否运行完毕）
public final void setDaemon(boolean on)将此线程标记为守护线程或用户线程

start() 和 run()

start()：用于启动线程，不能被多次调用。线程启动前状态为 new，启动后变成 runable

run()：线程启动后执行的代码

sleep()

  1. 睡眠当前线程，将当前线程状态将 running 变成 timed_waiting（阻塞状态）
  2. 其它线程可以使用 interrupt() 方法打断正在睡眠的线程，这时 sleep() 方法会抛出 InterruptedException 异常
  3. 建议使用 TimeUnit.SECOND.sleep() 代替 Thread.sleep()，提高可读性

在没有利用 cpu 来计算时，不要让 while(true) 空转浪费 cpu ，可以使用 yield() 或 sleep() 来让出 cpu 的使用权给其他程序。

yield()

  1. 让出当前线程 CPU 使用权，将当前线程状态将 running 变成 runable（就绪状态）
  2. 具体实现依赖于操作系统的任务调度区

join()

等待调用的线程结束，可以用于线程同步

@Slf4j(topic = "c.App")
public class App {
    static int num = 0;

    public static void main(String[] args) throws InterruptedException {
        log.info("before start - {}", num);
        Thread t = new Thread(() -> num = 1, "t");
        t.start();
        log.info("after start - {}", num);
        t.join();
        log.info("after join - {}", num);
    }
}

17:18:57 [main] c.App - before start - 0
17:18:57 [main] c.App - after start - 0
17:18:57 [main] c.App - after join - 1

park()

使线程进入阻塞状态，类似于断点。遇到 interrupt() 会打断 park()

@Slf4j(topic = "c.App")
public class App {

    public static void main(String[] args) throws InterruptedException {
        Runnable runnable = () -> {
            log.debug("before park()");
            LockSupport.park();
            log.debug("after park()");
        };

        Thread t = new Thread(runnable, "t");
        t.start();
        TimeUnit.SECONDS.sleep(1);
        t.interrupt();
    }
}

23:45:16 [t] c.App - before park()
23:45:17 [t] c.App - after park()

interrupt()

1、打断阻塞（sleep、wait、join、park）的线程，会清除打断状态。

@Slf4j(topic = "c.App")
public class App {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            log.debug("sleep");
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                log.debug(e.getMessage());
            }
        }, "t");
        t.start();
        // 避免主线程先打断
        TimeUnit.SECONDS.sleep(1);
        log.info("interrupt");
        t.interrupt();
        // 等待标记被清除
        TimeUnit.SECONDS.sleep(1);
        log.info("t.isInterrupted() = {}", t.isInterrupted());
    }
}


21:21:47 [t] c.App - sleep
21:21:48 [main] c.App - interrupt
21:21:48 [t] c.App - sleep interrupted
21:21:49 [main] c.App - t.isInterrupted() = false

2、打断正常运行的线程，会存在打断状态。

@Slf4j(topic = "c.App")
public class App {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            log.debug("while()");
            // 使用打断标记停止线程
            while (!Thread.currentThread().isInterrupted()) ;
        }, "t");
        t.start();
        // 避免主线程先打断
        TimeUnit.SECONDS.sleep(1);
        log.info("interrupt");
        t.interrupt();
        log.info("t.isInterrupted() = {}", t.isInterrupted());
    }
}

21:21:14 [t] c.App - while (true)
21:21:15 [main] c.App - interrupt
21:21:16 [main] c.App - t.isInterrupted() = true

不推荐使用的 API

  1. stop()：停止线程运行
  2. suspend()：挂起（暂停）线程运行
  3. resume()：恢复线程运行

如果线程持有锁，那么没有机会释放锁。

两阶段终止模式

错误思路

stop() 方法会直接停止线程。如果线程持有锁，那么没有机会释放锁。

流程分析
是
否
无异常
有异常
while(true)
有没有被打断？
料理后事
结束循环
睡眠 2s
执行监控记录
设置打断标记

代码实现

@Slf4j(topic = "c.App")
public class App {

    public static void main(String[] args) throws InterruptedException {
        Runnable runnable = () -> {
            while (true) {
                Thread thread = Thread.currentThread();
                // 监控资源
                log.debug("running");

                // 判断打断标记
                if (thread.isInterrupted()) {
                    // 释放占用资源
                    log.debug("exit...");
                    break;
                }

                // 避免大量 CPU 占用
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    thread.interrupt();
                }
            }
        };


        Thread t = new Thread(runnable, "t");
        t.start();
        TimeUnit.SECONDS.sleep(3);
        t.interrupt();
    }
}

守护线程

守护线程：只要非守护线程运行结束了，即使守护线程的代码没有执行完，也会强制结束。

垃圾回收器线程就是一个守护线程。

@Slf4j(topic = "c.App")
public class App {

    public static void main(String[] args) throws InterruptedException {
        Runnable runnable = () -> {
            while (true) {
                log.debug("test");
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        };

        Thread t = new Thread(runnable, "t");
        t.setDaemon(true);
        t.start();
        Thread.sleep(1000);
        log.debug("main stop");
    }
}

23:59:33 [t] c.App - test
23:59:33 [t] c.App - test
23:59:33 [t] c.App - test
23:59:34 [t] c.App - test
23:59:34 [t] c.App - test
23:59:34 [main] c.App - main stop

线程的状态

五种状态

从操作系统层面描述

  1. 初始状态：创建了线程对象
  2. 可运行状态（就绪状态）：线程对象与操作系统线程关联，可以被调度
  3. 运行状态：线程正在被执行
  4. 阻塞状态：线程调用了阻塞 API
  5. 终止状态：线程已经执行结束

六种状态

根据 Java 中 Thread.State 枚举类划分

  1. new：线程被创建，未调用 start() 方法
  2. runnable：运行状态 + 可运行状态 + 操作系统的阻塞状态（BIO）
  3. terminated：终止状态
  4. blocked：等待 synchronized() 获取锁
  5. waiting：等待 join()
  6. timed_waiting：有时限的阻塞状态，等待 sleep()

wmh1024
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
java并发编程：juc线程池
08-09
Java并发编程中的JUC线程池是Java程序员必须掌握的关键技术之一，它允许开发者高效地管理并发执行的任务，充分利用多核处理器的性能。线程池的出现解决了在并发环境中线程创建、销毁带来的开销，提高了系统资源的...
java并发编程：juc、aqs
08-09
Java并发编程中的`JUC`(Java Util Concurrency)库是Java平台中用于处理多线程问题的核心工具包，它提供了一系列高效、线程安全的工具类，帮助开发者编写并发应用程序。`AQS`(AbstractQueuedSynchronizer)是JUC库中的...
JUC代码演示 Java多线程并发
05-03
总结来说，Java多线程并发编程是一个复杂但重要的领域。了解和掌握线程的基本概念（如用户线程与守护线程）、同步机制（如`synchronized`和`Lock`接口），以及线程间通信的方法对于开发高质量的并发应用至关重要。...
Java并发编程-3.pdf
05-28
Java并发编程中的多线程协作机制 在 Java 并发编程中，多线程协作机制是非常重要的一部分。多线程协作机制是指在多线程编程中，多个线程之间如何协作、同步和通信，以达到共同完成某个任务的目的。Java 提供了多种...
java并发编程专题（六）----浅析（JUC）Semaphore
08-18
Java 并发编程专题（六）----浅析（JUC）Semaphore 是 Java 并发编程中的一种重要机制，它主要用于控制多个线程访问共享资源的同时性。Semaphore 是一种信号量机制，它维护了一个许可集，通过 acquire() 和 release...
spring事务详细讲解-深入浅出
小电玩
09-08 261
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1109
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
JAVA基础：值传递和址传递
weixin_53755148的博客
09-08 669
方法调用时，传递的实参是一个基本类型的数据形参改变，实参不变又称为地址传递，或引用传递方法调用时，传递的实参是一个引用类型的数据基本类型的数据，比较简单，可以直接存储在变量中引用类型的数据比较复杂，包含了一堆子数据，不能直接存储在变量中，存储在堆区，会为其分配一个内存地址我们在使用引用类型数据时，都是通过地址间接引用类型的数据所谓的地址传递，就是在方法调用时，传递的是引用类型的地址。形参（内容）改变，实参（内容）改变类似于值传递的址传递。
JAVA基础：数据类型、命名规范
weixin_53755148的博客
09-05 1290
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
okhttp，retrofit,rxjava 是如何配合工作的 作用分别是什么
追梦的鱼儿
09-04 640
OkHttp、Retrofit 和 RxJava 是 Android 开发中常用的三种库，它们各自有不同的作用，并且可以很好地配合工作来实现网络请求和响应的处理。
nmt---Docker-compose自动化部署
qq_69920145的博客
09-03 1032
static-rr 权重, leastconn 最少连接, source 请求IP, 轮询 roundrobin。# 这⾥是容器中的IP地址，由于配置的是轮询roundrobin，weight 权重其实没有⽣效。# 这⾥是容器中的IP地址，由于配置的是轮询roundrobin，weight 权重其实没有⽣效。# 在 mysql 创建⼀个没有权限的haproxy⽤户，密码为空。# 在 mysql 创建⼀个没有权限的haproxy⽤户，密码为空。10. docker-compose移除容器。
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 340
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
自定义Stater
m0_63624484的博客
09-07 570
我们平时在导入依赖的时候，大部分导入的都是xxx-spring-boot-stater。那是因为它们都基于spring的规则将写好的框架定义成一个stater，这样方便springboot引用它们写好的功能。那我们为什么也要自定义stater呢？
在Java Web开发中，如何保障应用的安全性？请列举常见的安全策略和措施。请解释Spring框架中的事务管理，包括声明式事务和编程式事务。
weixin_53180424的博客
09-03 1090
在实际开发中，声明式事务管理因其非侵入性和易维护性而更受欢迎。它允许开发者将注意力集中在业务逻辑上，而不是事务管理的细节上。然而，在某些特殊场景下，编程式事务管理可能提供更灵活的控制力。因此，在选择事务管理方式时，应根据实际需求和场景来决定。
JVM 垃圾回收机制：GC
m0_60462557的博客
09-04 1470
JVM的垃圾回收机制：GC，是Java提供的对于内存自动回收的机制。
基于SpringBoot的旅游管理系统
heye0910032的博客
09-08 157
随着科技的发展，旅游管理系统的信息化成为提升旅游服务效率的关键。本系统采用JSP技术和SpringBoot框架，结合MySQL数据库，旨在实现一个功能全面、操作简便、安全可靠的旅游管理平台。系统通过需求分析、系统设计、功能实现和测试，确保了良好的用户体验和数据处理能力，为旅游业务的现代化管理提供了强有力的技术支持。本研究成功开发了一个基于SpringBoot的旅游管理系统，该系统通过集成多种旅游管理功能，显著提高了旅游服务的效率和质量。系统的用户友好界面和强大的后端功能，使得管理员和用户都能从中受益。
基于JavaWeb开发的JavaSpringboot+Vue实现前后端分离房屋租赁系统
央顺科技官方博客
09-05 504
2021年处于信息科技高速发展的大背景之下。在今天，缺少手机和电脑几乎已经成为不可能的事情，人们生活中已经难以离开手机和电脑。针对增加的成本管理和操作,各大商家非常有必要建立自己的网上房屋租赁平台系统，这既可以让更多的人体验到网络所带来的方便，也有助于提高房屋的租赁。在经过几十年的高速发展后，互联网已成为最流行、最普及的媒体，每天的信息流量甚至能比得上过去十年。其以便捷的信息交换、快速的沟通速度，悄然地改变着会员的消费方式。
Linux服务器Java启动脚本
最新发布
Jack魏
09-08 306
本文章介绍了如何在Linux服务器上执行Java并启动jar包，通常我们会使用nohup直接启动，但是还是需要手动停止然后再次启动，那如何更优雅的在服务器上启动jar包呢，让我们一起探讨一下吧。
基于Spring Boot开发一个二手交易平台系统
嵌入式行业打工人，不定期更新博客。
09-08 473
这个示例提供了一个非常基础的框架，你可以在此基础上扩展更多的功能，如商品搜索、购物车、支付接口等。在实际开发过程中，还需要考虑诸如错误处理、事务管理、日志记录等方面的问题。此外，确保所有的API调用都是安全的，并且正确处理用户的输入数据，防止SQL注入等安全风险。如有疑问可以评论或者私信，看到一定解答。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

wmh1024

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

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

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

打赏作者

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

抵扣说明：

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

余额充值