并发编程之Thread

于 2023-04-16 22:29:16 发布
阅读量467 收藏
点赞数
分类专栏： 并发编程 文章标签： 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 - 中断处理

并发编程之CountDownLatch
06-20
CountDownLatch 并发编程 CountDownLatch 是一个同步的辅助类，它可以允许一个或多个线程等待，直到一组在其它线程中的操作执行完成。它通过一个计数器来实现的，计数器的初始值为线程的数量。每当一个线程完成了...
Thread的基本操作
pawlaibd的博客
03-18 1643
了解线程的创建 , 线程的状态 , 线程的一些常见属性
thread.run 中的while(true)的使用
weixin_44490707的博客
05-26 707
在我们执行定时轮询的任务时多多少少会使用到启用多个子线程，执行while(true)进行轮询，需要注意的是如何避免内存溢出，以及执行过程中出现异常如何解决；
多线程编程细节
qq_51074048的博客
04-24 229
Thread类 Thread类实现了Runnable接口，所以Thread类对象也是Runnable对象，同时Thread类也是线程类Runnable r=new Thread(); 构造器： Thread() //一般用于在Thread类中覆盖定义run方法，可以使用匿名内部类的方式进行定义 Thread(Runnable) //使用最多的情形，run方法是通过Runnable对象提供的 Thread(String) //创建线程对象的同时设置线程名称 Thread(Runnable,St
Java------多线程_高级主题_定时调度_quartz（十三）
cz_chen_zhuo的博客
12-07 320
Java------多线程_高级主题_定时调度_quartez（十三） 定时调度 通过Timer和Timetask，可以实现定时启动某个线程。 java.util.Timer：类似闹钟的功能，本身实现的就是一个线程。 java.util.TimerTask：一个抽象类，该类实现了Runnable接口，所以该类具备多线程的能力。 Timer：线程调度任务，以供将来在后台线程中执行的功能。任务可以安排一次执行，也可以定期多次执行。 TimerTask：可以由Timer进行一次性或重复执行的任务。抽象类，重写ru
多线程的实现方式
weixin_40487115的博客
11-07 176
1. 通过继承Thread类实现： public class MyThread extends Thread{ @Override public void run() { //一个类中可以定义很多方法，规定run（）方法是由线程去执行的 //一般线程用来处理那些耗时的操作 for (int i = 0; i < 100; i++) { ...
python并发编程之多线程
01-27
Python并发编程中的多线程是提高程序执行效率的重要手段，特别是在处理I/O密集型任务时。多线程允许程序同时执行多个任务，从而利用多核CPU的优势。在Python中，有两个主要的模块用于实现线程：`threading` 和 `...
java源码之并发编程
最新发布
11-17
Java并发编程是Java开发中的重要领域，它涉及多线程、同步机制、线程池以及并发集合等核心概念。在Java源码中，这些概念都得到了深入的实现和优化，使得Java成为处理并发任务的强大工具。 1. **多线程**：Java提供...
netty教程并发编程
05-06
### Netty教程并发编程知识点详解 #### 一、Netty简介与并发模型基础 ##### 1.1 Netty概述 Netty是一个高性能、异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器与客户端。它提供了对TCP、...
Java并发编程之创建线程
09-02
在Java并发编程中，创建线程是实现多任务并行执行的关键。线程允许程序中的不同部分同时运行，提高应用程序的响应速度和效率。本文将深入探讨Java中创建线程的两种主要方法：继承`Thread`类和实现`Runnable`接口。 ...
并发编程(多线程)
zyx22334的博客
01-13 6179
标准库中的Timer类中有两个参数:1)Runnable2)时间dalay(就是多久之后完成Runnable中的任务)timer.schedule(安排)使用其功能.功能:1.能够让任务在指定的时间得到执行2.一个定时器可以注册N个任务,N个任务可以按照最初约定的时间,按顺序执行.根据任务我们能得出结论:1.我么需要一个线程扫描,负责判断时间是否到了/并执行任务.2.还需要一个数据结构,来保存所有注册的任务.
Java--多线程Thread(实现，并发并行，同步死锁，单例，线程组池)
MinggeQingchun的博客
03-12 3142
一、线程 线程是程序执行的一条路径, 一个进程中可以包含多条线程 多线程并发执行可以提高程序的效率, 可以同时完成多项工作 二、多线程并行和并发的区别 1、并行就是两个任务同时运行，就是甲任务进行的同时，乙任务也在进行。(需要多核CPU) 2、并发是指两个任务都请求运行，而处理器只能按受一个任务，就把这两个任务安排轮流进行， 由于时间间隔较短，使人感觉两个
多线程并发
jiaojiao3701的博客
06-06 879
多线程
并发编程-Thread
wuxingdepiaoying1991的专栏
04-14 163
并发编程-Thread 最近在系统的学习并发相关的知识，总结了一下Thread知识。写成博客作为输出结果。有什么疑问的可以留言哦。 线程定义 线程是什么？怎么理解呢？线程执行在进程中，是进程的最小执行单元。 线程生命周期 线程状态图： NEW：表示线程对象已经创建，但是还没有开始执行。 RUNNABLE：表示线程对象已经在Java虚拟机中运行。 BLOCKED：表示线程对象正在等待锁。 WAITING：表示线程对象正在等待另一个线程的动作 TIMED-WAITING：表示线程对象正在
Thread：线程顺序执行的四种方式
最爱猫被窝
11-26 3623
线程顺序执行的四种方式 1、通过监测信号 每个线程对应自己的一个信号，监测到信号就执行，执行完就将信号更改为下一个线程的信号 2、通过FutureTask可以阻塞获取返回值的特性 顺序开启线程并获取返回值，线程将依次执行，返回结果 3、通过join()阻塞等待线程执行完 按线程执行顺序，依次join()进行阻塞 4、通过单线程线程池特性 线程池中只有一个线程，任务会在队列中，按提交顺序依次执行 线程顺序执行的代码示例 public class ThreadOrder { public stat
写一个并发编程的代码，保证该代码只能执行一次
timchen525的专栏
05-22 1745
错误的例子：@ThreadSafe @Slf4j public class AtomicExample6 { // 总的请求个数 public static final int requestTotal = 1000; // 同一时刻最大的并发线程的个数 public static final int concurrentThreadNum = 20; ...
Java并发执行任务的几种方式
热门推荐
码到功成
05-06 1万+
背景 在编写业务代码时经常遇到并发执行多个任务的需求，因为串行执行太慢，会影响业务代码性能。特别对于直接面向普通用户的业务来说用户体验至关重要，保证用户体验重要的一点是要“快”。业务代码中经常需要调用其它业务接口或者同时从多个数据源取数据再处理等，这种情况下势必要走网络请求，网络消耗必不可少，最好的情况是毫秒级别，一般情况下是几十毫秒级别，甚至几百毫秒，TimeoutException恐怕大家并...
开启Thread线程只执行一次
skytoby
04-26 9910
代码如下 private static Thread mTaskThread = new Thread(new Runnable() { @Override public void run() { count++; System.out.println("this is time do task:" + count); } }); public static void main...
Java并发编程：Thread与Runnable深度解析
"Java并发编程学习宝典，深入解析Thread和Runnable的关系与使用" 在Java并发编程中，Thread和Runnable是实现多线程的两个关键元素。虽然它们看似是平行的实现方式，但实际上，它们之间的关系更像父子，而不是兄弟。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值