【JavaEE】【多线程】Thread类讲解

鸽鸽程序猿2024-10-12 5:04

目录

一、Thread构造方法

方法 说明
Thread() 创建线程对象
Thread(Runnable target) 使用 Runnable 对象创建线程对象
Thread(String name) 创建线程对象，并命名（当前线程名）
Thread(Runnable target, String name) 使用 Runnable 对象创建线程对象，并命名
Thread(ThreadGroup group,Runnable target) 线程可以被用来分组管理，分好的组即为线程组

二、Thread 的常见属性
属性 获取方法
ID getId()
名称 getName()
状态 getState()
优先级 getPriority()
是否后台线程 isDaemon()
是否存活 isAlive()
是否被中断 isInterrupted()

解释：

  • ID 是线程的唯一标识，不同线程不会重复，但是这里的id是Java给的id，不是前面PCB中说的id。
  • 名称在各种调试工具用到，前面构造方法给的名称就是这个。
  • 状态表示线程当前所处的一个情况。
  • 优先级高的线程理论上来说更容易被调度到，但是这个是系统微观程度上的，很难感知到。
  • 关于后台线程，需要记住一点：JVM会在一个进程的所有非后台线程(前台线程)结束后，才会结束运行，而后台线程不影响Java进程的结束，可以在start()调用前使用setDaemon(true)来设置线程为后台线程。
  • 是否存活，即简单的理解，为 run 方法是否运行结束了

三、创建一个线程

在前一篇文章中就介绍了相关操作，在这简单提一下一定要使用线程变量名.start();创建一个新线程，start()方法是Java提供的API来调用系统中创建线程的方法。而run()方法是这个线程要干的事情，在线程创建好之后自动就会调用。
每个线程对象只能start一次。

四、获取当前线程引用

方法 说明
public static Thread currentThread(); 返回当前线程对象的引用

是静态方法直接使用Thread.currentThread();就可以获取到当前的线程引用。

五、终止一个线程

在Java中终止一个线程的思路就是让线程中的run()方法尽快结束。

5.1 使用标志位

由于线程迟迟不结束大多是因为里面有循环语句，我们就可以使用一个成员变量来控制循环的结束。
不能使用局部变量定义在main方法内，因为虽然lambda表达式可以捕获上层变量，但是这个变量不可以进行修改。

java 复制代码 
public class Demo {
    private static boolean isQuit = false;
    public static void main(String[] args) {
        Thread thread = new Thread(() ->{
            while(isQuit) {
              //具体操作  
            }
        });
        thread.start();
        isQuit = true;
    }
}

5.2 使用自带的标志位

方法 说明
public void interrupt() 中断对象关联的线程，如果线程正在阻塞，则以异常方式通知，否则设置标志位
public static boolean interrupted() 判断当前线程的中断标志位是否设置，调用后清除标志位，不建议使用，静态方法为所有线程共用的
public boolean isInterrupted() 判断对象关联的线程的标志位是否设置，调用后不清除标志位

Java中自带了标志位来标志是否结束循环。先使用Thread.currentThread()获取到当前线程，在.isInterrupted()获取标志位。然后再主进程中调用interrupte()方法来将标志位值修改为true。

java 复制代码 
public class Demo {
	public static void main(String[] args) {
	        Thread thread = new Thread(() ->{
	           while (!Thread.currentThread().isInterrupted()) {
	
	               //操作
	           }
	        });
	        thread.start();
	        thread.interrupt();
	    }
}

但是如果在线程中有捕获InterruptedException异常的语句，那么会在调用interrupte()同时捕获到该异常，并且消除标志位。

此时我们就可以在catch语句中自己选择是将线程结束还是进行其它操作。

java 复制代码 
public class Demo {
    public static void main(String[] args) {
        Thread thread = new Thread(() ->{
           while (!Thread.currentThread().isInterrupted()) {
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                  //1.不操作继续执行线程（因为sleep唤醒后会又将标志位改为true）
                   e.printStackTrace();
                   //2.结束线程
                   break;
                   //3.进行其它操作
               }
           }
        });
        thread.start();
        thread.interrupt();
    }
}

六、等待一个线程

方法 说明
public void join() 等待线程结束
public void join(long millis) 等待线程结束，最多等 millis 毫秒
public void join(long millis, int nanos) 等待线程结束，最多等 millis 毫秒，但可以更高精度

在主线程中调用线程对象.join();就是等待线程对象执行完再执行主线程。

调用细节：

  • 调用线程对象.join();就会让该线程执行完才继续执行外面的线程，如果线程对象对应的线程一直不结束那么外面的线程就会一直等（死等）
  • 调用线程对象.join(long millis);就会在该线程执行millis毫秒后执行外面的线程。
  • 如果遇到调用join前线程已经结束，外面的线程不会陷入等待。

如下代码执行结果就是先打印5个thread线程，最后在打印main线程：

java 复制代码 
public class Demo6 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
          for(int i = 0; i < 5; i++) {
          	System.out.println("thread线程");
          }
        });       
        thread。start();
        thread.join();
        System.out.println("main线程");
    }
}

七、线程休眠

方法 说明
public static void sleep(long millis) throws InterruptedException 休眠当前线程 millis毫秒
public static void sleep(long millis, int nanos) throws InterruptedException 可以更高精度的休眠

在系统让线程休眠sleep中的参数毫秒后，线程会被唤醒从阻塞状态变成就绪状态，但不会马上执行，涉及到调度开销。所以实际使用的时间是大于sleep中的参数的。

并且在Windows和Linux系统上达到毫秒级误差。

八、线程状态

在操作系统里面进程和线程最重要的状态就是：就绪状态和阻塞状态。

在Java中又给线程又给线程赋予了一些其他状态。
线程的状态是一个枚举类型 Thread.State。

状态 说明
new Thread对象已经创建，但是start()方法没有调用
terminated Thread对象还在，但是内核中线程已经结束了
Runnable 就绪状态，线程已经在CPU上执行或者在CPU上等待执行
timed_waiting 由于像sleep()，join(时间) 这种固定时间产生的阻塞
waiting 由于像wait()，join() 这种不固定时间产生的阻塞
blocked 由于锁竞争产生的阻塞

九、线程安全

线程安全的简单说法就是符不符合预期：如果多线程环境下代码运行的结果是符合我们预期的，即在单线程环境应该的结果，则说这个程序是线程安全的。

例如以下代码：

我们的预期结果是10000，但是其实每次的结果都是不一样的，这种就是线程不安全。

java 复制代码 
public class Demo {
    private static int ret;
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                ret++;
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                ret++;
            }
        });
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        
        System.out.println(ret);;
    }
}

就以上诉代码例子来讲解出现线程不安全的原因。

在CPU上实现自增操作主要有三步：

  1. 将数据给到CPU的寄存器中；
  2. 数据在寄存器中加1；
  3. 将数据返回到内存中。

就以一个thread1和一个thread2来说，每个线程都进行这三步操作，但是线程在CPU上又是随机调用的，这就相当于有六个位置随机坐，相当于排列组合的A66，当数据作为不同线程的开始值进入寄存器时就相当于两次自增只执行了一次。

但是线程调用就更加复杂了，线程数量不一样，顺序不一样，这就相当于有无数种可能了，所以结果是不可控的，就导致了线程不安全的情况。

9.1 线程不安全原因总结

在介绍线程不安全原因之前先介绍一个概念：原子性。

原子性：简单来讲就是执行一段代码连续执行完不被其他线程干扰。举个例子：

我们把一段代码想象成一个房间，每个线程就是要进入这个房间的人。如果没有任何机制保证，A进入房间之后，还没有出来；B 是不是也可以进入房间，打断 A 在房间里的隐私。这个就是不具备原子性的。

那我们应该如何解决这个问题呢？是不是只要给房间加一把锁，A 进去就把门锁上，其他人是不是就进不来了。这样就保证了这段代码的原子性了。

有时也把这个现象叫做同步互斥，表示操作是互相排斥的。

原因总结：

  • 操作系统调度线程是随机的（抢占式执行）；
  • 多个线程对同一个变量进行修改；
  • 修改操作不是原子性的；
  • 内存可见性问题；
  • 指令重排序问题。

9.2 解决由先前线程不安全问题例子

要解决就要从原因入手：

  • 操作系统随机调度是操作系统带来的解决不了；
  • 多个线程对一个变量修改，有些可以规避，但有些根据需求无法规避。
  • 将操作改为原子性，可以通过synchronized关键字 加锁操作来实现。

语法：

java 复制代码 
synchronized(变量){
//修改操作
}

()括号内的变量不重要，作用是区分加锁对象是否一样，如果对同一个对象加锁，那么两个操作就会产生"blocked"锁竞争阻塞问题，后一个线程就会等到前一个线程解锁再执行。

进入左大括号 '{' 就是加锁，出了右大括号 '}' 就是解锁。

对上诉代码进行如下修改，就会出现预期结果10000:

java 复制代码 
public class Demo7 {
    private static int ret;
    public static void main(String[] args) throws InterruptedException {
        Object block = new Object();
        
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                
                synchronized (block){
                    ret++;
                }
                
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {

                synchronized (block){
                    ret++;
                }

            }
        });
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println(ret);;
    }
}

synchronized还可以修饰方法（静态方法也行）。

  • synchronized修饰实例方法：
java 复制代码 
class Counter{
    public int ret;
    public void increase1() {
        synchronized (this) {
            ret++;
        }
    }
    //简化版本
    synchronized public void increase2() {
        ret++;
    }
}
  • synchronized修饰静态方法：相当于修饰这个类
java 复制代码 
class Counter{
	private static int ret2;
	public static void increase3() {
        synchronized (Counter.class) {
            ret2++;
        }
    }
    //简化版本
    synchronized public static void increase4() {
        ret2++;
    }
}
相关推荐
ZSYP-S34 分钟前
Day 15：Spring 框架基础
java·开发语言·数据结构·后端·spring
yuanbenshidiaos37 分钟前
c++------------------函数
开发语言·c++
程序员_三木1 小时前
Three.js入门-Raycaster鼠标拾取详解与应用
开发语言·javascript·计算机外设·webgl·three.js
是小崔啊1 小时前
开源轮子 - EasyExcel01(核心api)
java·开发语言·开源·excel·阿里巴巴
tianmu_sama1 小时前
[Effective C++]条款38-39 复合和private继承
开发语言·c++
黄公子学安全1 小时前
Java的基础概念（一）
java·开发语言·python
liwulin05061 小时前
【JAVA】Tesseract-OCR截图屏幕指定区域识别0.4.2
java·开发语言·ocr
jackiendsc1 小时前
Java的垃圾回收机制介绍、工作原理、算法及分析调优
java·开发语言·算法
Oneforlove_twoforjob1 小时前
【Java基础面试题027】Java的StringBuilder是怎么实现的？
java·开发语言
羚羊角uou1 小时前
【C++】优先级队列以及仿函数
开发语言·c++
热门推荐
01构建高效的广告投放系统：应用架构的设计与实现02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04Cube-Studio：开源大模型全链路一站式中台05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问07〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO