并发编程之Thread

于 2023-04-16 22:29:16 发布
阅读量354 收藏
点赞数
分类专栏： 并发编程 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43476824/article/details/130188491
版权

    Thread类是java中线程的定义，创建时可以设置线程要执行的代码，调用start方法会创建并执行真正的线程，通知管理线程的中断和线程的状态。

目录

1. 创建并执行一个简单的线程

2.sleep方法主动休眠

3.线程中断

4. sleep等待中的线程收到中断标记，会抛出InterruptedException异常，并清除中断标记

5. 线程同步join

6 线程两阶段终止线程中断示例

1. 创建并执行一个简单的线程

package org.example.concurrent;

import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

import java.util.concurrent.TimeUnit;

@Slf4j
public class ThreadTest {
    @Test
    public void test() {
        // 创建线程，入参为线程要执行的代码，这里打印一行日志
        Thread thread = new Thread(() -> log.debug("Hello world!"));

        // 创建并执行线程
        thread.start();
        sleep(10L);
    }


    @SneakyThrows
    private void sleep(long delay) {
        TimeUnit.MILLISECONDS.sleep(delay);
    }
}

2.sleep方法主动休眠

    Thread的静态方法sleep可以让线程主动休眠，入参为休眠的指定时间

package org.example.concurrent;

import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

import java.util.concurrent.TimeUnit;

@Slf4j
public class ThreadTest {
    @Test
    public void test() {
        // 创建线程，入参为线程要执行的代码，这里打印一行日志
        Thread thread = new Thread(() -> {
            log.debug("start");
            sleep(1000L); // 休眠1秒
            log.debug("end");
        });

        // 创建并执行线程
        thread.start();
        sleep(2000L);
    }


    @SneakyThrows
    private void sleep(long delay) {
        TimeUnit.MILLISECONDS.sleep(delay);
    }
}

log日志end会比start晚1秒打印，打印结果如下：

21:27:30.627 [Thread-0] DEBUG org.example.concurrent.ThreadTest - start
21:27:31.644 [Thread-0] DEBUG org.example.concurrent.ThreadTest - end

3.线程中断

   Thread的interrupt方法用于设置线程中断标记。

   Thread的isInterrupted方法用于判断线程是否有中断标记

   Thread的静态方法interrupted返回当前线程是否有中断标记，并清除中断标记。

示例1： sInterrupted方法用于判断线程是否有中断标记

package org.example.concurrent;

import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

import java.util.concurrent.TimeUnit;

@Slf4j
public class ThreadTest {
    @Test
    public void test() {
        // 创建线程，入参为线程要执行的代码，这里打印一行日志
        Thread thread = new Thread(() -> {
            Thread currentThread = Thread.currentThread();
            while (!currentThread.isInterrupted()) {
                // 线程未中断这一直执行
            }
            log.debug("当前中断标记为：{}", currentThread.isInterrupted());
        }, "t1");

        // 创建并执行线程
        thread.start();
        sleep(10);

        // 中断线程
        thread.interrupt();

        sleep(1000);
    }

    @SneakyThrows
    private void sleep(long delay) {
        TimeUnit.MILLISECONDS.sleep(delay);
    }
}

执行结果：

21:40:33.816 [t1] DEBUG org.example.concurrent.ThreadTest - 开始sleep
21:40:33.833 [t1] DEBUG org.example.concurrent.ThreadTest - currentThread has been interrupted

示例2：静态方法interrupted返回当前线程是否有中断标记，并清除中断标记

package org.example.concurrent;

import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

import java.util.concurrent.TimeUnit;

@Slf4j
public class ThreadTest {
    @Test
    public void test() {
        Thread thread = new Thread(() -> {
            Thread currentThread = Thread.currentThread();
            while (true) {
                if (Thread.interrupted()) {
                    log.debug("检测到当前线程中断");
                    break;
                }
            }
            log.debug("中断标记：{}", currentThread.isInterrupted());
        }, "t1");

        // 创建并执行线程
        thread.start();
        sleep(10);

        // 中断线程
        thread.interrupt();
        sleep(1000L);
    }

    @SneakyThrows
    private void sleep(long delay) {
        TimeUnit.MILLISECONDS.sleep(delay);
    }
}

执行结果：

21:48:37.217 [t1] DEBUG org.example.concurrent.ThreadTest - 检测到当前线程中断
21:48:37.221 [t1] DEBUG org.example.concurrent.ThreadTest - 中断标记：false

4. sleep等待中的线程收到中断标记，会抛出InterruptedException异常，并清除中断标记

除了sleep，join，wait收到中断标记，都会抛出InterruptedException异常，并清除中断标记。

package org.example.concurrent;

import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

import java.util.concurrent.TimeUnit;

@Slf4j
public class ThreadTest {
    @Test
    public void test() {
        Thread thread = new Thread(() -> {
            log.debug("t1开始睡眠");
            try {
                Thread.sleep(1000L);
            } catch (InterruptedException e) {
                log.debug("sleep抛出InterruptedException异常，当前线程的中断标记为:{}", Thread.currentThread().isInterrupted());
            }
        }, "t1");

        thread.start();
        sleep(10L);
        thread.interrupt(); //中断线程
        sleep(1000L);
    }

    @SneakyThrows
    private void sleep(long delay) {
        TimeUnit.MILLISECONDS.sleep(delay);
    }
}

5. 线程同步join

    Thread的join方法用于线程同步，即当前线程等待指定线程执行完毕，也可以设置最大等待时间，当前线程等待超过最大等待时间后，会继续往下执行：

package org.example.concurrent;

import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

import java.util.concurrent.TimeUnit;

@Slf4j
public class ThreadTest {
    @Test
    public void test() throws InterruptedException {
        Thread t1 = new Thread(() -> {
            log.debug("t1开始执行");
            sleep(1000L);
            log.debug("t1执行完毕");
        }, "t1");

        t1.start();

        log.debug("开始执行t1.join");
        t1.join();
        log.debug("t1.join已经返回");
    }

    @SneakyThrows
    private void sleep(long delay) {
        TimeUnit.MILLISECONDS.sleep(delay);
    }
}

执行过程中，在线程t1执行完毕后，t1.join才会返回，主线程继续执行，执行结果如下：

22:15:10.527 [t1] DEBUG org.example.concurrent.ThreadTest - t1开始执行
22:15:10.527 [main] DEBUG org.example.concurrent.ThreadTest - 开始执行t1.join
22:15:11.533 [t1] DEBUG org.example.concurrent.ThreadTest - t1执行完毕
22:15:11.534 [main] DEBUG org.example.concurrent.ThreadTest - t1.join已经返回

6 线程两阶段终止线程中断示例

所谓两阶段终止是指：

  1. 主动调用isInterrupted检查是否被中断，如果被中断则进入中断处理
  2. 如果使用了sleep、join、wait等操作，需要catch中断异常，并进入中断处理
package org.example.concurrent;

import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

import java.util.concurrent.TimeUnit;

@Slf4j
public class ThreadTest {
    @Test
    public void test() throws InterruptedException {
        Thread t1 = new Thread(this::monitor, "t1");

        t1.start();
        sleep(10L);
        t1.interrupt();
        t1.join();
    }

    private void monitor() {
        Thread currentThread = Thread.currentThread();

        // 1.while条件为当前线程未中断，则一直执行
        while (!currentThread.isInterrupted()) {
            try {
                log.debug("monitor 处理");
                Thread.sleep(5L);
            } catch (InterruptedException e) {
                // sleep抛出异常后，会清除中断标记，重新设置中断标记，也可以直接break
                currentThread.interrupt();
            }
        }

        log.debug("中断处理");
    }

    @SneakyThrows
    private void sleep(long delay) {
        TimeUnit.MILLISECONDS.sleep(delay);
    }
}

执行结果：

22:25:43.634 [t1] DEBUG org.example.concurrent.ThreadTest - monitor 处理
22:25:43.644 [t1] DEBUG org.example.concurrent.ThreadTest - monitor 处理
22:25:43.650 [t1] DEBUG org.example.concurrent.ThreadTest - monitor 处理
22:25:43.652 [t1] DEBUG org.example.concurrent.ThreadTest - 中断处理

不听话的小耳朵
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
笔记 34 | java线程之Thread线程优先
项勇 | 一天不学点啥就浑身难受
11-14 262
地址 线程优先 前言 当我们需要在几个线程中拍个优先执行的顺序时，我们就需要用到线程优先的相关方法， Thread类有setPriority(int level)方法用来设置线程的优先级。 线程的有限级从1到10，1是最不重要的，10是最重要的。如果没有给线程设置优先级，那么线程的优先级将是默认值5. 目录 未设置线程优先 设置了线程优先 1.未设置线程优先 @Overri
python并发编程之多线程
01-27
Python并发编程中的多线程是提高程序执行效率的重要手段，特别是在处理I/O密集型任务时。多线程允许程序同时执行多个任务，从而利用多核CPU的优势。在Python中，有两个主要的模块用于实现线程：`threading` 和 `...
多线程并发 (二) 了解 Thread
王项雨 的博客
12-30 7526
章节：多线程并发 (一) 了解 Java 虚拟机 - JVM多线程并发 (二) 了解 Thread多线程并发 (三) 锁 synchronized、volatile多线程并发 (四) 了解原子类 AtomicXX 属性地址偏移量，CAS机制多线程并发 (五) ReentrantLock 使用和源码 通过上一篇多线程并发 (一) 了解 Java 虚拟机 - JVM了解了java 虚拟机的构成...
并发系列（1）之 Thread 详解
weixin_30614109的博客
03-14 508
本文主要结合 java.lang.Thread 源码，梳理 Java 线程的整体脉络； 一、线程概述 对于 Java 中的线程主要是依赖于系统的 API 实现的，这一点可以从 java.lang.Thread；源码中关键的方法都是 native 方法看出，也可以直接查看 OpenJDK 源码看出来，这一点后面还会讲到；对于 JDK1.8 而言，他的 Windows 版和 Linux 版使用的都是 ...
Thread 并发运行实例
weixin_45430563的博客
11-08 319
package com.mingri; public class demo { public static void main(String[] args) { Thread a = new ThreadA(); Thread b = new ThreadB(); a.start(); b.start(); } } class ThreadA extends Thread { @Override public void run() { for (int i = 0; i < 101; i++) { S
并发编程之CountDownLatch
06-20
CountDownLatch 并发编程 CountDownLatch 是一个同步的辅助类，它可以允许一个或多个线程等待，直到一组在其它线程中的操作执行完成。它通过一个计数器来实现的，计数器的初始值为线程的数量。每当一个线程完成了...
thread- java高并发编程
最新发布
11-20
"thread- java高并发编程"这个主题包含了对Java并发编程的深入探讨，通过实例来解析如何在实际应用中有效地利用多线程。 1. **线程基础**：在Java中，线程是程序执行的最小单元，由Java虚拟机（JVM）管理。通过`...
java源码之并发编程
11-17
Java并发编程是Java开发中的重要领域，它涉及多线程、同步机制、线程池以及并发集合等核心概念。在Java源码中，这些概念都得到了深入的实现和优化，使得Java成为处理并发任务的强大工具。 1. **多线程**：Java提供...
Java并发编程之创建线程
09-02
在Java并发编程中，创建线程是实现多任务并行执行的关键。线程允许程序中的不同部分同时运行，提高应用程序的响应速度和效率。本文将深入探讨Java中创建线程的两种主要方法：继承`Thread`类和实现`Runnable`接口。 ...
【Thread】Thread并发知识 JUC all-in-one
qfzhangwei的专栏
02-18 271
1 并发知识库 2 JAVA 线程实现/创建方式 继承Thread类，native start()方法; 实现Runnable接口（自己的类已经extends 另一个情况，new Thread()）; ExecutorService、Callable<Class>、Future 有返回值线程(有返回值的任务必须实现 Callable 接口，类似的，无返回值的任务必须 Runnable 接口) 基于线程池的方式(线程和数据库连接这些资源都是非常宝贵的资源。那么每次需要的时候创建，不需
Java 并发 - Thread 详解
PinuoC的博客
09-29 301
Thread Thread 类是我们比较常用的一个类，它用作于多线程的创建，内部实现的 Runnable 接口只是对用户传入 Runnable 方法的简单调用，Thread 类提供了很多可以控制线程的方法，比如 yield、sleep、start0、stop0，这些方法都是 native 方法，由具体平台的虚拟机的C++代码实现，只有了解了这些代码的作用才会对 Thread 类有一个新的了解，下面先从 Thread 构造方法来说： public Thread(Runnable target) {
并发编程-Thread
wuxingdepiaoying1991的专栏
04-14 142
并发编程-Thread 最近在系统的学习并发相关的知识，总结了一下Thread知识。写成博客作为输出结果。有什么疑问的可以留言哦。 线程定义 线程是什么？怎么理解呢？线程执行在进程中，是进程的最小执行单元。 线程生命周期 线程状态图： NEW：表示线程对象已经创建，但是还没有开始执行。 RUNNABLE：表示线程对象已经在Java虚拟机中运行。 BLOCKED：表示线程对象正在等待锁。 WAITING：表示线程对象正在等待另一个线程的动作 TIMED-WAITING：表示线程对象正在
并发编程1：全面认识 Thread
热门推荐
张拭心的博客 shixinzhang
02-26 1万+
读完本文你将了解到： 线程简介 线程创建的三种方式 实现 Runnable 接口 继承 Thread重写其 run 方法 实现 Callable 接口重写 call 方法用 FutureTask 获得结果 线程的基本属性 优先级 守护线程 线程的生命周期 线程的关键方法 Threadsleep Objectwait Threadyield Threadjoin 线程的中断 public void i
【并发编程】Thread类的详细介绍
weixin_45969084的博客
12-06 111
Thread类是Java中实现多线程编程的基础类。本篇博客就来介绍下Thread类的常用API和常见用法。 Thread类常用的方法如下： Thread.activeCount()：这个方法用于返回当前线程的线程组中活动线程的数量，返回的值只是一个估计值，因为当此方法遍历内部数据结构时，线程数可能会动态更改。）。 Thread.checkAccess(): 检验当前正在执行的线程是否有权限修改th...
多线程的实现方式
weixin_40487115的博客
11-07 160
1. 通过继承Thread类实现： public class MyThread extends Thread{ @Override public void run() { //一个类中可以定义很多方法，规定run（）方法是由线程去执行的 //一般线程用来处理那些耗时的操作 for (int i = 0; i < 100; i++) { ...
[讨论][探索]优雅的并发执行代码.
麟麟麟的专栏
02-26 621
先看这段代码: int a = 1;//step 1 int b = 一段执行10秒的方法();//step 2 int c = 一段执行15秒的方法();//step 3 int d = b + c;//step 4 在这里,第二步和第三步是不需要先后执行的,我希望它们可以同时执行,只要执行第4步之前第2,3步执行完就可以了.
Thread的基本操作
pawlaibd的博客
03-18 1523
了解线程的创建 , 线程的状态 , 线程的一些常见属性
并发编程(多线程)
zyx22334的博客
01-13 6036
标准库中的Timer类中有两个参数:1)Runnable2)时间dalay(就是多久之后完成Runnable中的任务)timer.schedule(安排)使用其功能.功能:1.能够让任务在指定的时间得到执行2.一个定时器可以注册N个任务,N个任务可以按照最初约定的时间,按顺序执行.根据任务我们能得出结论:1.我么需要一个线程扫描,负责判断时间是否到了/并执行任务.2.还需要一个数据结构,来保存所有注册的任务.
Python并发编程：多线程实战与原理解析
"Python并发编程是提高程序执行效率的重要手段，多线程是其中的一个方法。在Python中，threading和multiprocessing模块提供了多线程和多进程的支持。本文主要探讨了Python中的多线程编程，包括threading模块的使用、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值