javaEE初阶————多线程初阶(2)

今天给大家带来第二期啦,保证给大家讲懂嗷;

1,线程状态

NEW安排了工作还未开始行动
RUNNABLE可工作的,或者即将工作,正在工作
BLOCKED排队等待
WAITING排队等待其他事
TIMED_WAITING排队等待其他事
TERMINATED工作完成了

1.1 观察线程的所有状态 

 1) new 

new就是创建了Thread对象还没有开始使用,也就是没有start

public class Demo1 {
    public static void main(String[] args) {
        Thread t1 = new Thread(()->{
            System.out.println(1111); 
        });
            System.out.println(t1.getState());
    }
}

看运行结果;

 

2) RUNNABLE

可工作的,又被分为即将开始工作和正在工作,这个就是在操作系统层面进程的就绪状态,用代码说明吧,简单明了;


        Thread t2 = new Thread(()->{
            while(true){
                System.out.println(11111);
            }
        });
        
        t2.start();

运行结果一定是疯了一样的打印11111,我们借助jconsole来看线程状态;

正在运行RUNNABLE;

3)TERMINATED 

工作完成了,虽然内核中的线程已经结束了,但是Thread对象还在;

4) WAITING

死等,还是上代码,

public class Demo1 {
    public static void main(String[] args) throws InterruptedException {
        Thread t2 = new Thread(()->{
            while(true){
                System.out.println(11111);
            }
        });
        t2.start();
        t2.join();
        System.out.println(22222);
    }
}

 我们让主线程main来等着t2看看的状态;

运行结果还是无线的,看不到22222;

mian的状态是WAITING,正在死等谈线程结束,这里面我们没有命名,系统自动给t2起名字了,t2还是RUNNABLE状态;BLOCKED状态我们之后说,我们还没有讲锁;

5) TIMED_WAITING

不是死等了,有时间限制的等待,(你还在等你的女神吗,她只会影响你变强的速度!!);

public class Demo2 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            while (!Thread.interrupted()){
                System.out.println("等一等~");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    break;
                }
            }
        });

        t1.start();
        t1.join(10000);

        t1.interrupt();
        System.out.println(Thread.currentThread().getName() + "劳资不等了!");
    }
}

看这个代码,我们让mian线程等待t1线程10秒,但是t1线程是没有停下来的意思的,运行结果

 

我们在运行一次,趁着这10秒来看看main线程的状态,

 TIMED_WAITING 有时间的等待;

 sleep也是会陷入有时间的等待的;我们刚才是站在线程之间的角度,而他t1线程中

t1线程在sleep之前是RUNNABLE, 在sleep时候是TIMED_WAITNG,之后还是RUNNABLE;

我们来试试;

public class Demo3 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            while (!Thread.interrupted()){
                System.out.println("等一等~");
                try {
                    System.out.println(Thread.currentThread().getState());
                    Thread.sleep(5000);
                    System.out.println(Thread.currentThread().getState());
                } catch (InterruptedException e) {
                    break;
                }
            }
        });
        t1.start();
    }
}

sleep前后都是RUNNABLE状态,而休眠的时候是TIMED_WAITING状态; 

1.2 线程状态和状态转移的意义

多线程编程中,为啥要引入这些状态呢,我们在1多线程程序中了解多线程状态是我们调试代码成功的关键,这也是我们学习多线程最基础的部分;

———————————————————————————————————————————

2,多线程带来的风险——(线程安全)

2.1 线程安全的概念

什么是线程安全?就我们单线程代码在多线程程序中能够按照预期正常运行我们就说该多线程程序是线程安全的;

2.2 观察线程不安全

我们来写一个多线程代码,让两个线程对同一操作数进行修改;

public class Demo1 {
    public static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                count++;
            }
        });

        Thread t2 = new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                count++;
            }
        });

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


        t1.join();
        t2.join();

        System.out.println(count);
    }
}

代码中我们让两个线程对成员变量count进行修改, 启动两个线程,并且让主线程等待两个线程,我们来看运行结果;

8千多,吞我1000多的数字,怎么个事,这个有两个原因,一个是原子性,另一个是罪魁祸首,就是线程调度的随机性,这两个线程是并发执行的;我们一会儿来详细讲一下这两种情况的解决办法;

2.3 线程不安全的原因

先来讨论下join;

join:

我们在代码中使用了join,同学们想过为啥要使用join没有,既然我们说过线程调度是随机的,那么有没有可能打印的count是0呢,屏蔽join后运行

是0吧,这就是因为操作系统的随机调度,线程1,2还在给count++,而我们的main线程只有打印,自然就程序开始就打印,不等那两个线程啦,我们加上join就让main等等那两个线程,这时又有同学问了,你刚才打印的8000多的数字,是不是因为count还没++完呢,你main线程就先打印了呢?   这一点事不可能1的,我们再来讲解一下

这也对,那也对,结果就是不对,为啥啊,线程并发执行并且随机调度!奶奶的我刚才了解了,那就因为这个给我++操作吃了?它咋吃的啊?

这就要我们站在CPU的角度来看了,

 就这一小段指令在CPU上是三段指令

1,读取 load 把内存中的值读到CPU上的寄存器中

2,修改 add 将寄存器中的值++

3,存储 save 将寄存器中的值放回内存中

我们所说的线程的随机调度是可能发生在这几步CPU操作当中的,可能我们线程二一顿++,到线程一又变成一了;这个我们马上详解来画;

我们先来聊聊原子可见性:

原子性:

我们不讲概念,我们就想想购票,如果你正在买最后一张票,你购买成功,在没有及时更新数据库的时候另一个人也看到了这张票,把它买下,那么一张票卖给了两个人,这不就是错误吗,我们想想为什么会出现这个原因,因为购票的操作不是原子的,购票操作有查票,买票,把数据更新到数据库中,我们在最后更新数据库的时候让其他线程插队了,这不就是刚才两个线程给count++的情况吗,我们要做的是把狗票操作锁到一块,让其他线程不能插队!

原子不可再分,这便是原子性;
可见性:

一个线程对共享变量的修改,在其他线程能够看到

JMM————java内存模型 

java虚拟机规范中定义了java内存模型————原因就是我们的特点——一次运行到处编译

为了屏蔽操作系统和各种硬件的内存访问差异;

每个线程独有的 “工作内存”  (WorkingMemory)————可以理解为寄存器

线程之间的共享变量:“主内存”  (MainMemory)————可以理解为内存

总之呢,导致内存不安全的原因呢:

1,根本) 线程之间随机调度,抢占式执行

2,多个线程同时修改一个变量

3,修改操作不是原子的

4,内存可见性

5,指令重排序(这个我们后面说)

———————————————————————————————————————————

2.4 解决之前的线程不安全问题

两个方法,

1,

public class Demo2 {
    public static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                count++;
            }
        });

        Thread t2 = new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                count++;
            }
        });

        t1.start();
        t1.join();

        t2.start();
        t2.join();

        System.out.println(count);
    }
}

直接修改程序执行的顺序,直接不启动t2线程,先让t1线程执行完,在去执行t2,但是并发很慢,我们想让他俩一起执行呀;

第二种方法:锁

public class Demo3 {
    public static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        Object locker1 = new Object();
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                synchronized(locker1){
                    count++;
                }
            }
        });

        Thread t2 = new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                synchronized (locker1){
                    count++;
                }
            }
        });

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

        System.out.println(count);
    }
}

我们接下来就好好讲讲锁; 

———————————————————————————————————————————

3,synchronized 关键字

3.1 synchronized的特性

1)互斥

两个线程要同时使用一个锁对象时会发生阻塞等待:

Object locker = new Object();
        synchronized(locker){
            System.out.println(11);
        }

互斥是发生在两个synchronized语句使用同一个锁对象的时候,锁对象就是locker,我们可以定义为任何类型,这个对象也可以有自己的用途,代码块中的System.out.println就是我们加锁的语句,进代码块加锁,出代码块解锁;我们解释下刚才那段代码Deom3那个;

public class Demo2 {
    public static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        Object locker1 = new Object();
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                synchronized(locker1){
                    count++;
                }
            }
        });

        Thread t2 = new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                synchronized (locker1){
                    count++;
                }
            }
        });

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

        System.out.println(count);
    }
}

我们这里是对count++这一操作加锁,让他在CPU上的三步指令操作可以当做一个了,我们必须执行完三步指令才能让其他线程执行,否则一直阻塞等待; 

2)可重入

同一个线程多次对使用一个锁不会发生阻塞等待;

public class Demo3 {
    static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        Object locker = new Object();
        Thread t1 = new Thread(()->{
            synchronized (locker){
                synchronized (locker){
                    count++;
                }
            }
        });

        t1.start();
        t1.join();

        System.out.println(count);
    }
}

我们看这段代码,我们在t1线程使用了两个锁,都去竞争locker,

我们实际来运行一下, 

“你刚才Dog叫什么呢,这不没问题吗”,“冤枉啊”,这是因为java中的锁是可重入锁,内部使用计数器来实现;可重入锁呢,他是在让锁对象内部保存了是哪个线程持有了这把锁,后序在对当前锁对象加锁的时候检查一下是那个线程,

3.2 synchronized 使用式例

1)修饰代码块,指定锁对象

public class Demo4 {
    public static void main(String[] args) {
        Object locker = new Object();

        Thread t1 = new Thread(()->{
            synchronized (Thread.currentThread()){
                System.out.println(1111);
            }
        });

        Thread t2 = new Thread(()->{
           synchronized (locker){
               System.out.println(2222);
           }
        });

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

我们可以使用任意锁对象或者线程对象本身;

 

2)synchronized修饰普通方法

 Object locker = new Object();
    public synchronized int add(int a,int b){
        return a+b;
    }
    //等价于
    public int add2(int a,int b){
        synchronized (locker){
            return a+b;
        }
    }

3)synchronized修饰静态方法

public synchronized static int add3(int a,int b){
        return a+b;
    }

不一一介绍了; 

3.3 Java标准库中的线程安全类

我们之前学的数据结构,在多线程中基本都是线程不安全的,

这里给大家列举一些安全的,但先不一一展开讲了;

1,vector

2,HashTable

3,ConcurrentHashMap(强推)

4,StringBuffer

下期再见嗷;

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

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

用LLM做测试驱动开发:有趣又高效的尝试

每周跟踪AI热点新闻动向和震撼发展 想要探索生成式人工智能的前沿进展吗&#xff1f;订阅我们的简报&#xff0c;深入解析最新的技术突破、实际应用案例和未来的趋势。与全球数同行一同&#xff0c;从行业内部的深度分析和实用指南中受益。不要错过这个机会&#xff0c;成为AI领…

你需要什么样的资源隔离?丨TiDB 资源隔离最佳实践

导读 资源隔离是数据库性能优化的重要环节&#xff0c; TiDB 在当前版本已经实现了从数据级隔离到流控隔离的全面升级 &#xff0c;无论是多系统共享集群、复杂负载隔离&#xff0c;还是小型系统整合和 SQL 精细化控制&#xff0c;TiDB 都提供了灵活且高效的解决方案。 本文以…

1 行命令引发的 Go 应用崩溃

一、前言 不久前&#xff0c;阿里云 ARMS 团队、编译器团队、MSE 团队携手合作&#xff0c;共同发布并开源了 Go 语言的编译时自动插桩技术。该技术以其零侵入的特性&#xff0c;为 Go 应用提供了与 Java 监控能力相媲美的解决方案。开发者只需将 go build 替换为新编译命令 o…

Python毕业设计选题:基于django+vue的宠物服务管理系统

开发语言&#xff1a;Python框架&#xff1a;djangoPython版本&#xff1a;python3.7.7数据库&#xff1a;mysql 5.7数据库工具&#xff1a;Navicat11开发软件&#xff1a;PyCharm 系统展示 管理员登录 管理员功能界面 用户管理 宠物商品管理 医疗服务管理 美容服务管理 系统…

Java连接TDengine和MySQL双数据源

git文件地址&#xff1a;项目首页 - SpringBoot连接TDengine和MySQL双数据源:SpringBoot连接TDengine和MySQL双数据源 - GitCode 1、yml配置 spring:datasource:druid:mysql:driver-class-name: com.mysql.cj.jdbc.Driverurl: jdbc:mysql://localhost:3306/testusername: roo…

三十一、事件过滤处理分析

三十一、事件过滤处理分析eventFilter 实现以下功能 bool QObject::eventFilter(QObject *watched, QEvent *event)&#xff1a; 如果已将此对象安装为所监视对象的事件过滤器&#xff0c;则过滤事件。 在你重新实现这个函数时&#xff0c;如果你想过滤掉事件&#xff0c;即停…

C++ QT中Q_Q和Q_D是什么?怎么使用?本质是什么?C++仿写

1.QT中Q_Q和Q_D是什么&#xff1f; Q_Q可以得到外部可以访问的类指针Q_D可以得到内部封装&#xff0c;外部不可达的类指针 2. 怎么使用&#xff1f; 上代码 APrivate.h #pragma once #include <QtCore>class A;class APrivate {Q_DECLARE_PUBLIC(A) public:APrivate(…

三种文本相似计算方法:规则、向量与大模型裁判

文本相似计算 项目背景 目前有众多工作需要评估字符串之间的相似(相关)程度&#xff1a;  比如&#xff0c;RAG 智能问答系统文本召回阶段需要计算用户文本与文本库内文本的相似分数&#xff0c;返回前TopK个候选文本。  在评估大模型生成的文本阶段&#xff0c;也需要评估…

高效实现 Markdown 转 PDF 的跨平台指南20250117

高效实现 Markdown 转 PDF 的跨平台指南 引言 Markdown 文件以其轻量化和灵活性受到开发者和技术写作者的青睐&#xff0c;但如何将其转换为易于分享和打印的 PDF 格式&#xff0c;是一个常见需求。本文整合了 macOS、Windows 和 Linux 三大平台的转换方法&#xff0c;并探讨…

浅谈云计算21 | Docker容器技术

Docker容器技术 一、 容器技术特性1.1 轻量级特性1.2 隔离性特性 二、容器镜像2.1 容器镜像概述2.1.1 定义与构成2.1.2 分层结构 2.2 联合文件系统2.3 容器镜像的构建与管理2.3.1 容器镜像的构建2.3.2 **构建镜像流程**2.3.3 **应用场景**2.3.4 镜像仓库的应用 2.4 容器镜像的优…

LabVIEW实现油浸式变压器自主监测与实时报告

油浸式变压器广泛应用于电力系统中&#xff0c;尤其是在电力传输和分配领域。为了确保变压器的安全、稳定运行&#xff0c;及时监测其工作状态至关重要。传统的变压器监测方法通常依赖人工巡检和定期检查&#xff0c;但这不能及时发现潜在的故障隐患&#xff0c;且效率较低。随…

【2025最新】国内中文版 ChatGPT镜像网站整理合集,GPT最新模型4o1,4o,4o-mini分类区别,镜像站是什么

1.快速导航 原生中转型镜像站点 立即Chat支持GPT4、4o以及o1,canvs等&#xff0c;同步官网功能 AIChat.com 支持最新4O 2.两者对比 官网立即Chat访问难度需要魔法直接访问支付手段国际支付国内支付封禁策略检测节点&#xff0c;随时封禁不会封禁价格每月140元订阅费用每年70元…

SpringBoot:RestTemplate与IllegalArgumentException

问题描述 在SpringBoot应用中&#xff0c;有时会遇到使用RestTemplate调用第三方服务的场景。例如&#xff1a;在进行地名数据采集时&#xff0c;为了拿到地名对应的经纬度位置&#xff0c;通常会有地理编码的步骤&#xff0c;此时就可能涉及到调用第三方接口服务实现此需求。 …

【日志篇】(7.6) ❀ 01. 在macOS下刷新FortiAnalyzer固件 ❀ FortiAnalyzer 日志分析

【简介】FortiAnalyzer 是 Fortinet Security Fabric 安全架构的基础&#xff0c;提供集中日志记录和分析&#xff0c;以及端到端可见性。因此&#xff0c;分析师可以更有效地管理安全状态&#xff0c;将安全流程自动化&#xff0c;并快速响应威胁。具有分析和自动化功能的集成…

HTML中如何保留字符串的空白符和换行符号的效果

有个字符串 储值门店{{thing3.DATA}}\n储值卡号{{character_string1.DATA}}\n储值金额{{amount4.DATA}}\n当前余额{{amount5.DATA}}\n储值时间{{time2.DATA}} &#xff0c; HTML中想要保留 \n的换行效果的有下面3种方法&#xff1a; 1、style 中 设置 white-space: pre-lin…

【腾讯云】AI驱动TDSQL-C Serveress 数据库技术实战营-如何是从0到1体验电商可视化分析小助手得统计功能,一句话就能输出目标统计图

欢迎来到《小5讲堂》 这是《腾讯云》系列文章&#xff0c;每篇文章将以博主理解的角度展开讲解。 温馨提示&#xff1a;博主能力有限&#xff0c;理解水平有限&#xff0c;若有不对之处望指正&#xff01; 目录 背景效果图流程图创建数据库 基本信息数据库配置设置密码控制台开…

基于预共享密钥的IPsec实验

一、实验目的 &#xff08;1&#xff09;了解IPsec的原理和协议运行机制&#xff1b; &#xff08;2&#xff09;掌握IPsec身份认证的预共享密钥的配置&#xff1b; &#xff08;3&#xff09;掌握用Wireshark工具抓包分析IPsec数据包格式和协议流程。 二、实验设备与环境 &…

微信小程序实现个人中心页面

文章目录 1. 官方文档教程2. 编写静态页面3. 关于作者其它项目视频教程介绍 1. 官方文档教程 https://developers.weixin.qq.com/miniprogram/dev/framework/ 2. 编写静态页面 mine.wxml布局文件 <!--index.wxml--> <navigation-bar title"个人中心" ba…

初学stm32 --- flash模仿eeprom

目录 STM32内部FLASH简介 内部FLASH构成&#xff08;F1&#xff09; FLASH读写过程&#xff08;F1&#xff09; 闪存的读取 闪存的写入 内部FLASH构成&#xff08;F4 / F7 / H7&#xff09; FLASH读写过程&#xff08;F4 / F7 / H7&#xff09; 闪存的读取 闪存的写入 …

Kinova仿生机械臂Gen3搭载BOTA 力矩传感器SeneOne:彰显机器人触觉 AI 与六维力传感的融合力量

随着工业4.0时代的到来&#xff0c;自动化和智能化成为制造业的趋势。机器人作为实现这一趋势的重要工具&#xff0c;其性能和智能水平直接影响到生产效率和产品质量。然而&#xff0c;传统的机器人系统在应对复杂任务时往往缺乏足够的灵活性和适应性。为了解决这一问题&#x…