并发编程的故事——Java线程

news2024/11/17 22:34:02

Java线程

`

文章目录

  • Java线程
  • 一、线程创建
  • 二、线程运行
  • 三、线程运行
  • 四、主线程和守护线程
  • 五、线程的五种状态
  • 六、线程的六种状态
  • 七、烧水泡茶案例

一、线程创建

创建线程方法一：
Thread重写run方法
@Slf4j(topic = "c.MyTest1")
public class MyTest1 {
    public static void main(String[] args) {
        Thread t=new Thread(){
            @Override
            public void run() {
                log.info("好人");
            }
        };
        t.setName("线程1");
        t.start();

        log.info("main测试");
    }
}

创建方法2:
直接写一个Runable传给线程Thread
@Slf4j(topic = "c.Test2")
public class Test2 {
    public static void main(String[] args) {
        Runnable r = () -> {log.debug("running");};

        Thread t = new Thread(r, "t2");

        t.start();
    }
}

Thread和Runable的区别
Thread实现了Runable方法，也就是说Thread可以覆盖Runable的任务方法执行run。但是也可以通过传入任务来执行对应的Runable方法(如下面代码所示)。

 @Override
    public void run() {
        if (target != null) {
            target.run();
        }
}


创建方法3:
FutureTask实现了Runnable和Future，Future主要是用来返回值的。其实相当于也是一个任务类但是需要实现Callable实现类对象传入到task上。并且执行之后才能够使用task的get来获取数据，如果没有执行线程那么get就会阻塞
@Slf4j(topic = "c.MyTest2")
public class MyTest2 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<Integer> task=new FutureTask<Integer>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                log.debug("你好");
                return 4;
            }
        });

        Thread t=new Thread(task,"t1");
        t.start();
        log.debug("{}",task.get());

    }
}

总结:更推荐方法2，原因是Runable就是任务，把任务和线程分开才能更好的分配任务。

二、线程运行

命令
jps:查看java进程
tasklist:windos查看所有进程
taskkill /F /PID XXX：杀死某个进程

三、线程运行

线程的栈
每次开启一个线程都会产生一个线程的栈给线程使用，实际上就是一开始分配的虚拟机栈。
每个栈都有多个栈帧
线程只能有一个活动栈帧

线程执行的过程
先分配栈给线程，线程调用main方法，在栈分配一个栈帧给main方法，栈帧保存锁记录、局部变量表、操作数栈、返回地址（返回到原来的栈帧方法的下一条指令）

在这里插入图片描述
线程上下文切换

导致上下文切换的条件：
时间片用完
优先级
垃圾回收
自己调用sleep、wait等

线程的状态包括：
程序计数器，记录执行到什么位置
虚拟机栈，包括所有栈帧信息

常见方法
start
线程进入就绪状态，等待调度器调用。这里相当于是开启了一个新的线程
run
执行Runnable里面的方法。这里并没有开启线程，只是通过本线程执行代码
如果开启了两次start就会出现线程状态异常的问题IlegalThreadStateException
线程的两个状态
NEW
start之后就是Runnable等待调度
sleep
线程睡眠，并把状态改为Timed Waiting，被打断的时候会抛出异常InterruptedException。可以通过TimeUnit.SECONDS.sleep来规定睡眠时间的单位。睡眠可以使用在while循环自转的地方，如果长时间自转就会消耗CPU的使用时间，其他线程无法使用
interrupt
唤醒线程，如果线程处于睡眠状态那么就会抛出异常

public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                log.debug("enter sleep...");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    log.debug("wake up...");
                    e.printStackTrace();
                }
            }
        };
        t1.start();

        Thread.sleep(1000);
        log.debug("interrupt...");
        t1.interrupt();
    }

yield
其实就是把线程状态从Running转变到Runnable暂时让出cpu，重新去竞争
setPriority
设置优先级是给调度器进行提示，先执行这个线程，但是仍然没有办法控制线程。
join
join实际上就是卡点，就是一定要等待调用join的线程完成后才能执行下面的代码

@Slf4j(topic = "c.Test10")
public class Test10 {
    static int r = 0;
    public static void main(String[] args) throws InterruptedException {
        test1();
    }
    private static void test1() throws InterruptedException {
        log.debug("开始");
        Thread t1 = new Thread(() -> {
            log.debug("开始");
            sleep(1);
            log.debug("结束");
            r = 10;
        },"t1");
        t1.start();
        t1.join();
        log.debug("结果为:{}", r);
        log.debug("结束");
    }
}

同步应用案例
多线程的join只需要等待最长的那个线程就可以了，因为它们是并行执行的。
test3案例，实际上就是限时等待，如果超过时间那么就不等了。如果没有超过时间，那么结束join还是以处理完线程的任务时间为主，而不是最大的等待时间
在这里插入图片描述

@Slf4j(topic = "c.TestJoin")
public class TestJoin {
    static int r = 0;
    static int r1 = 0;
    static int r2 = 0;

    public static void main(String[] args) throws InterruptedException {
        test2();
    }

    public static void test3() throws InterruptedException {
        Thread t1 = new Thread(() -> {
            sleep(2);
            r1 = 10;
        });

        long start = System.currentTimeMillis();
        t1.start();

        // 线程执行结束会导致 join 结束
        log.debug("join begin");
        t1.join(3000);
        long end = System.currentTimeMillis();
        log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
    }

    private static void test2() throws InterruptedException {
        Thread t1 = new Thread(() -> {
            sleep(1);
            r1 = 10;
        });
        Thread t2 = new Thread(() -> {
            sleep(2);
            r2 = 20;
        });
        t1.start();
        t2.start();
        long start = System.currentTimeMillis();
        log.debug("join begin");

        t1.join();
        log.debug("t1 join end");
        t2.join();
        log.debug("t2 join end");
        long end = System.currentTimeMillis();
        log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
    }

    private static void test1() throws InterruptedException {
        log.debug("开始");
        Thread t1 = new Thread(() -> {
            log.debug("开始");
            sleep(1);
            log.debug("结束");
            r = 10;
        });
        t1.start();
        t1.join();
        log.debug("结果为:{}", r);
        log.debug("结束");
    }
}

在这里插入图片描述
interrupt
打断阻塞
打断sleep和wait。打断后会抛出异常到那时不会给它打上打断标记。而且这里需要给主线程睡眠一会，不然t1线程还没睡眠，主线程就已经调用打断，那么这个时候的打断是打断t1，并且加上打断标记，但是打断睡眠并不会有打断标记

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

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            log.debug("sleep...");
            try {
                Thread.sleep(5000); // wait, join
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t1");

        t1.start();
        Thread.sleep(1000);
        log.debug("interrupt");
        t1.interrupt();
        log.debug("打断标记:{}", t1.isInterrupted());
    }
}

打断正常
当我们打断的事正常的线程（没在sleep或wait），那么就会给这个线程加上打断标记。但是要不要打断取决于被打断线程的意愿，其它线程只能给一个通知。

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

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            while(true) {

                boolean interrupted = Thread.currentThread().isInterrupted();
                if(interrupted){
                    break;
                }
            }
        }, "t1");
        t1.start();

        Thread.sleep(1000);
        log.debug("interrupt");
        t1.interrupt();
    }
}

LockSupport
其实就是一个锁的支持类，它的park方法可以模拟sleep把线程进行阻塞，但是需要标记是false的时候。如果打断标记是true那么就无法使用。但是这个地方可以使用Thread.interrupted来获取打断标记状态和消除标记。

public static void test5() {
        Thread t1 = new Thread(()->{
            log.debug("park...");
            LockSupport.park();
            log.debug("unpark...");
            log.debug("打断状态：{}", Thread.interrupted());
            LockSupport.park();
            log.debug("unpark...");

        },"t1");
        t1.start();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        t1.interrupt();


}

四、主线程和守护线程

守护线程其实就是Daemon。也就是在其它非守护线程运行完之后，无论守护线程是否还有任务需要执行都会强制停止。
垃圾回收器是守护线程
tomcat的Acceptor和poller

@Slf4j(topic = "c.Test15")
public class Test15 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            while (true) {
                if (Thread.currentThread().isInterrupted()) {
                    break;
                }
            }
            log.debug("结束");
        }, "t1");
        t1.setDaemon(true);
        t1.start();

        Thread.sleep(1000);
        log.debug("结束");
    }
}

五、线程的五种状态

1、初始：new线程的时候
2、可运行：执行了start
3、运行：线程可以使用cpu的时候
4、阻塞：不能被cpu调度器使用的时候
5、终止：线程结束的时候
在这里插入图片描述

六、线程的六种状态

NEW:初始化
RUNNABLE:包括了运行、可运行和阻塞，通常表示正在运行
WAITING：没有时间限制的等待
TIMED_WAITING:有时间限制的等待
BLOCKED:阻塞
TERMINATED:终止

七、烧水泡茶案例

join思路
其实就是老王洗烧壶和烧水，小王洗茶壶、茶杯、茶叶，等待烧水完成之后泡茶。可以用join来等待t1处理。

Slf4j(topic = "c.Test16")
public class Test16 {



    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            log.debug("洗茶壶");
            Sleeper.sleep(1);
            log.debug("烧水");
            Sleeper.sleep(5);
        }, "老王");


        Thread t2=new Thread(()->{
            log.debug("洗茶壶");
            Sleeper.sleep(1);
            log.debug("洗茶叶");
            Sleeper.sleep(2);
            log.debug("洗茶杯");
            Sleeper.sleep(1);

            try {
                t1.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            log.debug("泡茶");
        },"小王");

        t1.start();
        t2.start();


    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/956616.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Linux系统Ubuntu配置Docker详细流程

Linux系统Ubuntu配置Docker详细流程

本文介绍在Linux操作系统Ubuntu的18.04及以上版本中&#xff0c;配置开源容器化平台和工具集Docker的详细方法&#xff1b;其中&#xff0c;我们以配置Docker平台的核心组件之一——Docker Engine为例来详细介绍。 首先&#xff0c;大家需要明确&#xff0c;我们常说的Docker&a…
阅读更多...
设计模式-原型模式详解

设计模式-原型模式详解

文章目录 前言理论基础1. 原型模式定义2. 原型模式角色3. 原型模式工作过程4. 原型模式的优缺点 实战应用1. 原型模式适用场景2. 原型模式实现步骤3. 原型模式与单例模式的区别 原型模式的变体1. 带有原型管理器的原型模式2. 懒汉式单例模式的原型模式实现3. 细粒度原型模式 总…
阅读更多...
敏捷开发要点

敏捷开发要点

敏捷开发是一种以人为核心&#xff0c;迭代、增量式的软件开发方法。它强调团队成员的自我管理、面对变化时的快速适应能力&#xff0c;以及持续的沟通和协作。 以下是敏捷开发的几个要点&#xff1a; 敏捷宣言&#xff1a;敏捷开发遵循敏捷宣言&#xff0c;其中包括四个价值声…
阅读更多...
Java单元测试及常用语句 | 京东物流技术团队

Java单元测试及常用语句 | 京东物流技术团队

1 前言 编写Java单元测试用例&#xff0c;即把一段复杂的代码拆解成一系列简单的单元测试用例&#xff0c;并且无需启动服务&#xff0c;在短时间内测试代码中的处理逻辑。写好Java单元测试用例&#xff0c;其实就是把“复杂问题简单化&#xff0c;建单问题深入化“。在编写的…
阅读更多...
stm32CubeMX HAL W5500芯片介绍 第一章

stm32CubeMX HAL W5500芯片介绍 第一章

W5500芯片介绍 文章目录 W5500芯片介绍简单简绍以太网以太网分五层&#xff1a;第一层物理层&#xff1a;第二层&#xff1a;数据链路层&#xff1a;第三层&#xff1a;网络层&#xff1a;第四层&#xff1a;传输层&#xff1a;第五层&#xff1a;应用层&#xff1a;以太网应用…
阅读更多...
redis面试题二

redis面试题二

redis如何处理已过期的元素 常见的过期策略 定时删除&#xff1a;给每个键值设置一个定时删除的事件&#xff0c;比如有一个key值今天5点过期&#xff0c;那么设置一个事件5点钟去执行&#xff0c;把它数据给删除掉&#xff08;优点&#xff1a;可以及时利用内存及时清除无效数…
阅读更多...
《存储IO路径》专题：IO块设备的创建

《存储IO路径》专题：IO块设备的创建

今天我们来一起学习一下Linux块设备层。它就像是一位大厨&#xff0c;为我们准备各种数据的饕餮盛宴。这个大厨非常厉害&#xff0c;不仅能够读取和写入数据&#xff0c;还能对数据进行各种复杂的操作&#xff0c;比如切割、合并、复制等等。那么&#xff0c;块设备层是如何实现…
阅读更多...
C#-抽象类与接口

C#-抽象类与接口

文章目录 一、抽象类和接口总结总结补充说明主要区别 二、抽象类2.1 抽象类概述与声明2.2 抽象方法2.3 抽象类与抽象方法的使用 三、接口3.1 接口概述概述特征声明示例 3.2 接口的实现和继承说明示例 3.3 显式接口成员实现说明注意示例 一、抽象类和接口总结 总结 抽象类和接…
阅读更多...
k8s使用ECK（2.4）形式部署elasticsearch+kibana-http协议

k8s使用ECK（2.4）形式部署elasticsearch+kibana-http协议

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 前言一、准备elasticsearch-cluster.yaml二、部署并测试总结 前言 之前写了eck2.4部署eskibana&#xff0c;默认的话是https协议的&#xff0c;这里写一个使用http…
阅读更多...
【docker】docker的一些常用命令-------从小白到大神之路之学习运维第92天

【docker】docker的一些常用命令-------从小白到大神之路之学习运维第92天

目录 一、安装docker-ce 1、从阿里云下载docker-cer.epo源 2、下载部分依赖 3、安装docker 二、启用docker 1、启动docker和不启动查看docker version 2、启动服务查看docker version 有什么区别&#xff1f;看到了吗&#xff1f; 3、看看docker启动后的镜像仓库都有什…
阅读更多...
解密Spring MVC异常处理：从局部到全局，打造稳固系统的关键步骤

解密Spring MVC异常处理：从局部到全局，打造稳固系统的关键步骤

&#x1f600;前言 在现代软件开发中&#xff0c;异常处理是不可或缺的一部分&#xff0c;它能够有效地提高系统的稳定性和健壮性。在Spring MVC框架中&#xff0c;异常处理机制起着至关重要的作用&#xff0c;它允许开发者在程序运行过程中捕获、处理和报告异常&#xff0c;从…
阅读更多...
26 Linux高级篇-Linux面试题

26 Linux高级篇-Linux面试题

26 Linux高级篇-Linux面试题 文章目录 26 Linux高级篇-Linux面试题1.分析日志t.txt(访问量)&#xff0c;将各个ip地址截取&#xff0c;并统计出现次数&#xff0c;并按从大到小排序(腾讯)2.统计连接到服务器的各个ip情况&#xff0c;并按连接数从大到小排序(腾讯)3.如忘记了mys…
阅读更多...
历时3天的springboot+vue打包成jar包

历时3天的springboot+vue打包成jar包

有人说问什么打包花了三天&#xff0c;里面的坑很多&#xff0c;我就先不叙述太多&#xff0c;直接说我搞了三天得出来的最后解决方案&#xff0c;不一定适合每一个人&#xff01;! # 前端 # 修改prod.env.js文件下的内容&#xff0c;把里面的 BASE_API 修改为和dev.env.js文件…
阅读更多...
[管理与领导-63]：IT基层管理者 - 潜技能 - 1 - 职场中的陷阱 - 看清楚职场中的霸凌现象

[管理与领导-63]：IT基层管理者 - 潜技能 - 1 - 职场中的陷阱 - 看清楚职场中的霸凌现象

目录 前言&#xff1a; 1&#xff1a;打击自尊心 2&#xff1a;孤立他人 3&#xff1a;恶意针对 4&#xff1a;当众羞辱 5&#xff1a;持续性否定 前言&#xff1a; 职场中&#xff0c;什么样的人都有。 害人之心不可有&#xff0c;防人之心不可无。 前者教人从善&…
阅读更多...
顺序栈（数组形式）的实现

顺序栈（数组形式）的实现

&#x1f308;什么是栈&#xff1f; 1.抽象化具象&#xff1a;可以理解为一个细长的乒乓球筒&#xff0c;一端封闭&#xff0c;放球只能从另一端放入球&#xff0c;取出球时也只能从该端取出。先进的球最后出&#xff0c;后进的球最先出。 2.定义&#xff1a;栈是一种线性数据…
阅读更多...
【C++】map/multimap容器

【C++】map/multimap容器

1.map基本概念 2.map构造和赋值 #include <iostream> using namespace std;//map容器 构造和赋值 #include<map>//遍历输出map容器 void printMap(const map<int, int>& m) {for (map<int, int>::const_iterator it m.begin(); it ! m.end(); it)…
阅读更多...
Ubuntu学习---跟着绍发学linux课程记录（第一部分）

Ubuntu学习---跟着绍发学linux课程记录（第一部分）

文章目录 1、启动、关闭、挂起、恢复&#xff08;电源&#xff09;2、更多虚拟机操作2.1 电源设置2.2 硬件参数设置2.3 状态栏2.4 全屏显示 3、快照与系统恢复4、桌面环境5、文件系统6、用户目录7、创建目录和文件8、命令行&#xff1a;文件列表ls 9、命令行&#xff1a;切换目…
阅读更多...
分布式任务调度框架

分布式任务调度框架

分布式任务调度框架 学习为主 文章目录 分布式任务调度框架一、概念二、架构图三、任务调度的流程定时触发任务是如何实现的&#xff1f;&#xff1a;使用时间轮实现定时执行任务逻辑:3.1 对到达now时间后的任务&#xff08;超出now 5秒外)3.2 对到达now时间后的任务&#xff0…
阅读更多...
从代码设计看 Glide 之生命周期（上）

从代码设计看 Glide 之生命周期（上）

欢迎关注我的其他平台账号&#xff1a; 掘金&#xff1a;0xforee 个人博客&#xff1a;0xforee’s blog 微信公众号&#xff1a; 上期我们探索了一个具备核心功能的图片加载库该怎么设计。这一期我们来看看如何给这个图片加载库关联生命周期管理。 欢迎关注本系列其他文章&…
阅读更多...
PPPoE连接无法建立的排查和修复

PPPoE连接无法建立的排查和修复

嗨&#xff0c;亲爱的读者朋友们&#xff01;你是否曾经遇到过PPPoE连接无法建立的问题&#xff1f;今天我将为你详细解析排查和修复这个问题的步骤。 检查物理连接 首先&#xff0c;我们需要确保物理连接没有问题。请按照以下步骤进行检查&#xff1a; - 检查网线是否插好&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023