当前位置： 首页 > news >正文

Java多线程(2)

news 来源：原创 2024/5/5 18:34:52

1.jconsole.exe

在介绍多线程状态之前,我们先来认识一个Java JDK自带的工具"jconsole.exe"

它可以让我们很好地观察Java线程的状态.

首先我们需要找到自己安装jdk的目录

然后进入bin目录下.找到名为"jconsole.exe"的程序文件
在这里插入图片描述

然后打开程序

这里我们使用一段代码来帮助观察

public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            try {
                Thread.sleep(30000);//t1线程睡眠30秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"T1");
        t1.start();
        Thread.sleep(60000);//main线程睡眠1分钟
        System.out.println(t1.getState());
    }
}

打开工具后会是如下页面,我们运行程序后,就可以在本地进程中观察到我们运行的进程.

在这里插入图片描述

双击这个进程

就会进入观察页面,会提醒一个是否以不安全状态连接,我们直接点击"不安全的连接"就好
在这里插入图片描述

点击"不安全的连接"之后

就正式进入到了监视窗口,点击线程栏,就可以在左下角的线程栏中观察到我们这个程序的线程.

选择想查看的线程,就可以看到线程的状态以及一些信息

在这里插入图片描述

2.Java中线程的状态

Java中线程的状态是Java内部的状态.与其他操作系统的状态会有所差异.

官方文档中有6种状态,也可以细分为7种状态

  • NEW: 安排了工作,还未开始行动

  • RUNNABLE: 可工作的.又可以分成正在工作中和即将开始工作

    可以细分为运行态和就绪态

  • BLOCKED: 这几个都表示排队等着其他事情

  • WAITING: 这几个都表示排队等着其他事情

  • TIMED_WAITING: 这几个都表示排队等着其他事情

  • TERMINATED: 工作完成了

先认识一个方法:getState(),获取线程的状态(谁调用获取谁的)

//此处就是获取当前运行代码的线程的状态.
Thread.currentThread().getState();

NEW:安排了工作还没开始行动

把Thread对象创建好了,但是还没有调用start运行

public class Test {
    public static void main(String[] args) {
        //NEW
        Thread t = new Thread(()->{});
        System.out.println(t.getState());
    }
}

RUNNABLE:可工作的,又可以分为正在工作和即将开始工作

就绪状态:处于这个状态的线程,就是在就绪队列中,随时可以被调度到CPU上(或者正在运行中)

如果代码没有进行sleep,也没有其他导致阻塞的操作,代码大概率是在这个状态

public class Test {
    public static void main(String[] args){
        //RUNNABLE
        System.out.println(Thread.currentThread().getState());
    }
}

TERMINATED:工作完成了

操作系统中的线程已经执行完毕,销毁了.但是Thread对象还在,获取到的状态.

public class Test {
    public static void main(String[] args) throws InterruptedException {
        //TERMINATED,
        Thread t = new Thread(()->{
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        t.start();
        Thread.sleep(3000);
        System.out.println(t.getState());
    }
}

BLOCKED:表示排队等着其他事情(和下一个一起观察)

当一个线程加锁成功的时候,其他线程尝试加锁,就会触发阻塞等待.此时对应的线程(尝试加锁的线程)就处于BLOCKED状态.(等待获取锁)

TIMED_WAITING

表示线程在等待等待其他线程发来通知.(下列代码中t1等待sleep唤醒)

public class Test {
    public static void main(String[] args) {
        final Object object = new Object();
        Thread t1 = new Thread(new Runnable() {
            @Override        
            public void run() {
                synchronized (object) {
                    while (true) {
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }, "t1");
        t1.start();
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (object) {
                    System.out.println("hehe");
                }
            }
        }, "t2");
        t2.start();
    }
}

运行起来代码以后,使用 jconsole工具就可以观察到 t1 的状态是 TIMED_WAITING , t2 的状态是 BLOCKED

WAITING同样表示等待其他线程发来通知.

与TIMED_WAITING的区别在于,TIMED_WAITING线程在等待唤醒，但设置了时限;
而WAITING 线程在无限等待唤醒

public class Test {
    public static void main(String[] args) {
        final Object object = new Object();
        Thread t1 = new Thread(new Runnable() {
            @Override        
            public void run() {
                synchronized (object) {
                    while (true) {
                        try {
                            // [与上述代码相同,只是修改了这里]
                            // Thread.sleep(1000);                    
                            object.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }, "t1");
        t1.start();
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (object) {
                    System.out.println("hehe");
                }
            }
        }, "t2");
        t2.start();
    }
}

此时使用 jconsole 工具可以看到 t1 的状态是 WAITING

3.了解方法:yield():大公无私,让出 CPU

谁调用Thread.yield()方法谁就让出CPU,不会改变线程的状态,会重新进入就绪队列排队

public class Test {
    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("张三");
                    Thread.yield();
                }
            }
        }, "t1");
        t1.start();
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("李四");
                }
            }
        }, "t2");
        t2.start();
    }
}

通过上述代码,我们可以发现,张三的数量远远少于李四,说明"张三"总在给"李四"让行.这就是yield的作用

4.多线程带来的的风险-线程安全问题

我们先来观察下面代码

class Counter{
    public int count = 0;
    
    public void increase(){
        count++;
    }
}
public class Test {
    private static Counter counter = new Counter();
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                counter.increase();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                counter.increase();
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();//main线程等待t1和t2线程运行结束,输出最终结果.
        System.out.println(counter.count);
    }
}

多次运行后,我们会发现结果总会在50_000-100_000之间.

为什么会有这样的现象发生呢？为什么不是每次都是100_000呢?

类似于此类多线程安全问题的具体的原因有以下几点

  1. 线程是抢占式,进程间的调度充满随机性.
  2. 多个线程对同一个变量进行修改操作
  3. 针对变量的操作不是原子的
  4. 内存可见性(属于编译器优化)
  5. 指令重排序(属于编译器优化)

我们图示一个可能发生的状态来描述.

在这里插入图片描述

我们发现,此时虽然执行了两次++操作,但是最后的结果却只是++了一次的结果.

类似于这种状态还有多种.

在这里插入图片描述

认真想想,只要不是这种每次的操作是原子性的执行,就都会产生上述不安全的情况.

什么是原子性.

在我们这里,原子性就是保证一段代码是不可分割执行的.

synchronized关键字

对于上述安全问题的解决,我们就需要了解这个关键字.

synchronized的底层是使用操作系统的mutex lock实现的

synchronized 的特性

1.互斥

synchronized 会起到互斥效果,某个线程执行到某个对象的 synchronized 中时,其他线程如果也执行到 同一个对象 synchronized 就会阻塞等待.

  • 进入 synchronized 修饰的代码块,相当于加锁
  • 退出 synchronized 修饰的代码块,相当于解锁

2.刷新内存

synchronized 的工作过程:

  1. 获得互斥锁
  2. 从主内存拷贝变量的最新副本到工作的内存
  3. 执行代码
  4. 将更改后的共享变量的值刷新到主内存
  5. 释放互斥锁

所以 synchronized 也能保证内存可见性(简单理解就是保证每次得到的数据都是最新的).

3.可重入

synchronized 同步块对同一条线程来说是可重入的,不会出现自己把自己锁死的问题.(也就是在自己加锁后,在没有释放锁的状态下,自己是可以再次进入这段加锁的代码的.)

在下面的代码中,

increase 和 increase2 两个方法都加了 synchronized, 此处的 synchronized 都是针对 this 当前对象加锁的.

在调用 increase2 的时候, 先加了一次锁, 执行到 increase 的时候, 又加了一次锁. (上个锁还没释 放, 相当于连续加两次锁)

对于synchronized来说,这个代码是完全没问题的. 因为 synchronized 是可重入锁

static class Counter {
    public int count = 0;
    synchronized void increase() {
        count++;
    }
    synchronized void increase2() {
        increase();
    }
}

实现方式: 在可重入锁的内部, 包含了 “线程持有者” 和 “计数器” 两个信息.

如果某个线程加锁的时候, 发现锁已经被人占用, 但是恰好占用的正是自己, 那么仍然可以继续获取 到锁, 并让计数器自增.

解锁的时候计数器递减为 0 的时候, 才真正释放锁. (才能被别的线程获取到)

synchronized关键字 本质就是对代码加锁

加锁之后,可以保证指令的原子性,同时保证内存可见性

使得多个线程不可以同时对同一个变量进行修改操作,也就保证了安全.

synchronized 有三种使用方式

使用synchronized的时候,本质上是在针对某个"对象"进行加锁

1. 直接修饰普通方法

当修饰普通方法的时候,锁对象就是this:加锁操作就是在设置this的对象头的标志位

2. 修饰一个代码块

修饰一个代码块的时候,就需要显示指定针对哪个对象加锁(Java中的任意对象都可以作为锁对象)

3. 修饰一个静态方法

修饰一个静态方法的时候,就是针对当前类的类对象(xxx.class)加锁

当一个线程加锁成功的时候,其他线程如果尝试加锁,就会触发阻塞等待.等待到锁释放时对线程的唤醒.此时对应的线程(尝试加锁的线程)就处于BLOCKED状态

那我们该怎么解决上述问题呢

当然是使用synchronized加锁啦(对获取变量并修改的操作进行加锁,把操作打包成原子的)

正确的加锁之后,多线程代码就变成安全的了.

class Counter{
    public int count = 0;
    synchronized public void sIncrease(){
        //加锁
        count++;
    }
}
public class Test2 {
    private static Counter counter = new Counter();
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                counter.sIncrease();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                counter.sIncrease();
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(counter.count);
    }
}

我们对要操作变量的方法,加上synchronized关键字,就是对此方法加了锁,此时我们再去运行这段代码.无论运行几次,最终结果都会达到我们的预期.

5.内存可见性

我们看一个编译器优化的问题.

public class Test {
//    private static volatile int isQuit = 0;
    private static int isQuit = 0;
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while(isQuit == 0){
                //不进行操作,使得程序不停地访问isQuit
            }
            System.out.println("循环结束 t线程退出");
        });
        t.start();

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个isQuit的值");
        if(sc.hasNextInt()){
            isQuit = sc.nextInt();
        }
        System.out.println("main 执行完毕");
    }
}

上述代码,当输入1之后t线程可能是不会退出的.这就属于编译器优化了.

因为在不停高速地访问isQuit变量,编译器直接 (进行优化) 将isQuit变量的值一次读取并保存副本.后续读取副本的值.不会访问实际内存,大量节省了程序读的时间.(也因此产生了bug)

volatile关键字

volatile关键字就会保证了内存可见性,保证程序每次读取的值,都是内存中真实的值.

volatile不保证原子性

volatile 和 synchronized 有着本质的区别. synchronized 能够保证原子性, volatile 保证的是内存可见性.

我们给isQuit变量加上volatile关键字,在运行程序,输入1之后马上就会退出循环,bug就消失啦.

相关文章：

  • 深入浅出Spring注解（22）
  • [C++基础]-初识模板
  • 【黄啊码】MySQL入门—13、悲观锁、乐观锁怎么用？什么是行锁、页锁和表锁？死锁了咋办？
  • 小小博客项目（servlet实战演练）
  • C++学习（6）——模板
  • C++重载运算符
  • 1027推免分享材料 备份
  • JavaScript---常用JS方法(utils.js)额外篇
  • 《CTF特训营》学习笔记——APK逆向基础
  • 一文带你了解怎样快速上手微信小程序开发
  • 基于注意力机制的深度协同推荐模型
  • 【Linux修炼】6.gcc/g++及Makefile【工具篇】
  • 【Linux】基本的指令(三)
  • 算法学习 | 贪心算法~通过局部最优的选择来得到整体最优解
  • 聊聊Spring Cloud Gateway 动态路由及通过Apollo的实现
  • C++回声服务器_9-epoll边缘触发模式版本服务器
  • ES6 ...操作符
  • JAVA 学习IO流
  • Laravel 实践之路: 数据库迁移与数据填充
  • log4j2输出到kafka
  • php中curl和soap方式请求服务超时问题
  • Spring技术内幕笔记（2）：Spring MVC 与 Web
  • vue 个人积累(使用工具，组件)
  • 分享一份非常强势的Android面试题
  • 力扣(LeetCode)56
  • 普通函数和构造函数的区别
  • 前端面试总结（at, md）
  • 吐槽Javascript系列二：数组中的splice和slice方法
  • 为视图添加丝滑的水波纹
  • 06-01 点餐小程序前台界面搭建
  • hi-nginx-1.3.4编译安装
  • MPAndroidChart 教程：Y轴 YAxis
  • #pragma预处理命令
  • #调用传感器数据_Flink使用函数之监控传感器温度上升提醒
  • #数学建模# 线性规划问题的Matlab求解
  • #我与Java虚拟机的故事#连载06：收获颇多的经典之作
  • （6）STL算法之转换
  • (pojstep1.1.2)2654(直叙式模拟)
  • （八）Docker网络跨主机通讯vxlan和vlan
  • (二) Windows 下 Sublime Text 3 安装离线插件 Anaconda
  • （附程序）AD采集中的10种经典软件滤波程序优缺点分析
  • （离散数学）逻辑连接词
  • (十三)Maven插件解析运行机制
  • （四）七种元启发算法（DBO、LO、SWO、COA、LSO、KOA、GRO）求解无人机路径规划MATLAB
  • (五) 一起学 Unix 环境高级编程 (APUE) 之 进程环境
  • （已解决）vue+element-ui实现个人中心，仿照原神
  • (转)C语言家族扩展收藏 (转)C语言家族扩展
  • （转）PlayerPrefs在Windows下存到哪里去了？
  • **python多态
  • .java 9 找不到符号_java找不到符号
  • .net core MVC 通过 Filters 过滤器拦截请求及响应内容
  • .NET 反射的使用
  • .NET成年了，然后呢？
  • .NET基础篇——反射的奥妙
  • []新浪博客如何插入代码（其他博客应该也可以）