关于Java多线程你了解多少

news2024/11/17 5:26:31

🏡个人主页 ：@ 守夜人st
🚀系列专栏：Java
…持续更新中敬请关注…
🙉博主简介：软件工程专业，在校学生，写博客是为了总结回顾一些所学知识点

目录

  • 多线程
    • 多线程的创建
      • 继承Thread类
      • 实现Runnable接口
      • JDK5新增：实现Callable接口
    • Thread的常用方法
    • 线程安全
      • 线程安全的问题是什么，发生的原因？
      • 线程安全问题案例模拟
    • 线程同步
      • 方式一：同步代码块
      • 方式二：同步方法
      • 方式三：Lock锁
    • 线程通信
    • 线程池
      • 线程池实现的API、参数说明
      • 线程池处理Runnable任务
      • 线程池处理Callable任务
      • Executors得到线程池对象的常用方法
    • 定时器
    • 并发与并行
    • 生命周期

多线程

什么是线程？

  • 线程(thread)是一个程序内部的一条执行路径。
  • 启动程序执行后，main方法的执行其实就是一条> > 单独的执行路径
  • 程序中如果只有一条执行路径，那么这个程序就是> 单线程的程序

什么是多线程？

  • 多线程是指从软硬件上实现多条执行流程的技术
  • 多线程的应用十分广泛，例如：消息通信、淘宝、> 京东这样的系统都离不开多线程

多线程的创建

继承Thread类

  1. 定义一个子类MyThread继承线程类java.lang.Thread,重写run()方法

  2. 创建MyThread类的对象

  3. 调用线程对象的start()方法启动线程(启动后还是执行run方法的)

优缺点：

  • 优点：编码简单
  • 缺点：线程类已经继承Thread，无法继承其他类，不利于扩展。
package com.shouyeren.Thread_app;

/**
    目标：多线程的创建方式一：继承Thread类实现
 */
public class ThreadDemo01 {
    public static void main(String[] args) {
        //创建MyThread类的对象
        Thread myThread = new MyThread();

        //调用线程对象的start()方法启动线程
        myThread.start();
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出" + i);
        }
    }
}

/**
 1. 定义一个子类MyThread继承线程类java.lang.Thread,重写run()方法

 2. 创建MyThread类的对象

 3. 调用线程对象的start()方法启动线程(启动后还是执行run方法的)
 */
class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行输出" + i);
        }
    }
}
  1. 为什么不直接调用run方法，而是调用start启动线程？
  • 直接调用run方法会当成普通方法执行，此时相当于还是单线程执行
  • 只有调用start方法启动才是启动一个新的线程执行
  1. 为什么不要把主线程任务放在子线程之前？
    • 这样主线程是一直先跑完的，相当于是一个单线程的效果了

实现Runnable接口

  1. 定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法
  2. 创建MyRunnable任务对象
  3. 把MyRunnable任务对象交给Thread处理
  4. 调用线程对象的start()方法启动线程
构造器说明
public Thread(Sting name)可以为当前线程指定名称
public Thread(Runnable target)封装Runnable对象成为线程对象
public Thread(Runnable target,String name)封装Runnable对象成为线程对象,并为当前线程指定名称
package com.shouyeren.Thread_app;

/**
    目标：多线程的创建方式二：实现MyRunnable接口
 */
public class ThreadDemo02 {
    public static void main(String[] args) {
        //创建一个任务对象
        Runnable target = new MyRunnable();
        //把任务对象交给Thread处理
        Thread thread = new Thread(target);
        //启动线程
        thread.start();
    }
}
class MyRunnable implements Runnable{
    /***
     * 重写run方法，定义线程的执行任务
     */
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("子线程输出：" + i);
        }
    }
}


package com.shouyeren.Thread_app;

/**
    目标：多线程的创建方式二：匿名内部类实现，语法形式
 */
public class ThreadDemo03 {
    public static void main(String[] args) {
        //写法1
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("子线程1输出：" + i);
                }
            }
        };

        Thread thread = new Thread(runnable);
        thread.start();

        //写法2
        new Thread(new Runnable(){
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("子线程2输出：" + i);
                }
            }
        }).start();

        //写法3
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                System.out.println("子线程3输出：" + i);
            }
        }).start();

        for (int i = 0; i < 10; i++) {
            System.out.println("主线程执行输出：" + i);
        }
    }
}

优缺点：

  • 优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强
  • 缺点：编程多一层对象包装，如果线程有执行结果是不可以直接返回的。

JDK5新增：实现Callable接口

  1. 得到任务对象

定义实现类Callable接口，重写call方法，封装要做的事情
用FutureTask把Callable对象封装成线程任务对象

  1. 把线程任务对象交给Thread处理
  2. 调用Thread的start方法启动线程，执行任务
  3. 线程执行完毕后，通过FutureTask的get方法去获取任务执行的结果。
方法名称说明
public FutureTask<>(Callable call)把Callable对象封装成FutureTask对象
public V get() throws Exception获取线程执行call方法返回的结果
package com.shouyeren.Thread_app;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

/**
 * 线程创建的第三种方式：实现Callable接口，结合FutureTask完成
 */
public class ThreadDemo04 {
    public static void main(String[] args) {
        //创建Callanle任务对象
        Callable<String> callable1 = new MyCallable(100);
        //把Callable任务对象交给FutureTask对象
        FutureTask<String> futureTask1 = new FutureTask<>(callable1);
        Thread t1 = new Thread(futureTask1);
        t1.start();

        Callable<String> callable2 = new MyCallable(200);
        FutureTask<String> futureTask2 = new FutureTask<>(callable2);
        Thread t2 = new Thread(futureTask2);
        t2.start();

        try {
            String rs1 = callable1.call();
            System.out.println("第一个返回结果：" + rs1);
        } catch (Exception e) {
            e.printStackTrace();
        }

        try {
            String rs2 = callable2.call();
            System.out.println("第二个返回结果：" + rs2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
//定义一个任务类，实现Callable接口，应该声明线程执行返回结果的数据类型
class MyCallable implements Callable<String> {
    private int n;

    public MyCallable(int n) {
        this.n = n;
    }

    //重写call方法
    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= n; i++) {
            sum += i;
        }
        return "子线程的执行结果是：" + sum;
    }
}

创建线程的3种方式对比

方法优点缺点
继承Thread类编程比较简单，可以直接使用Thread中的方法扩展性较差，不能再继续继承其他的类，不能返回执行结果
实现Runnable接口扩展性强，实现该接口的同时还能继承其他的类编程相对复杂，不能返回执行结果
实现Callable接口扩展性强，实现该接口的同时还可以继承其他的类，并且可以得到返回的执行结果编程相对复杂

Thread的常用方法

Thread的构造器

方法名称说明
public Thread (String name)可以为当前线程指定名称
public Thread (Runnable target)封装Runnable对象成为线程对象
public Thread(Runnable target ,String name)封装Runnable对象成为线程对象,并指定线程名称
方法名称说明
public final String getName()获取当前线程的名称，默认是Thread-索引
public final synchronized void setName(String name)修改当前线程的名称
public static native Thread currentThread();获取当前线程
public static void sleep(long time)让当前线程休眠指定的时间后继续执行，单位毫秒

线程安全

线程安全的问题是什么，发生的原因？

多个线程同时操作同一个共享资源的时候可能会出现业务安全问题，成为线程安全问题。

线程安全问题出现的原因？

  • 存在多线程并发
  • 同时访问共享资源
  • 存在修改共享资源

线程安全问题案例模拟

案例：取钱业务

小明和小红是一对夫妻，他们有一个共同的账户，余额10万元，模拟两个人同时取钱10万元

分析：

  1. 需要提供一个账户类，创建一个账户对象表示两人的共享账户
  2. 需要定义一个线程类，线程类可以处理账户对象
  3. 创建两个线程对象，传入同一个账户对象。
  4. 启动了两个线程，去同一个账户对象中取钱10万元
package com.shouyeren.Thread_app.Thread_safe;

public class ThreadDemo {
    public static void main(String[] args) {
        //创建一个共享账户对象
        Account account = new Account(100000);
        //创建两个线程对象，代表小明和小红
       new DrawThread(account,"小明").start();
       new DrawThread(account,"小红").start();


    }
}


package com.shouyeren.Thread_app.Thread_safe;

public class Account {
    private double money;

    public Account(double money) {
        this.money = money;
    }

    public Account() {
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    public void DrawMoney(double money) {
        String name = Thread.currentThread().getName();
        //判断余额
        if (this.money >= money){
            System.out.println(name + "取钱成功，吐出" + money);
            //更新余额
            this.money -= money;
            System.out.println("余额：" + this.money);
        }else {
            System.out.println("余额不足");
        }
    }
}


package com.shouyeren.Thread_app.Thread_safe;

public class DrawThread extends Thread{
    private Account account;
    public DrawThread(Account account,String name){
        this.account = account;
    }
    @Override
    public void run() {
        account.DrawMoney(100000);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-juj0F0pC-1677676685836)(C:\Users\shouyeren\AppData\Roaming\Typora\typora-user-images\image-20230226203037611.png)]

线程同步

线程同步就是为了解决线程安全问题

核心思想：

  • 加锁，把共享资源进行上锁，每次只能一个线程进入访问完毕以后解锁，然后其他线程才能进来

方式一：同步代码块

  • 作用：把出现线程安全问题的核心代码给上锁

  • 原理：每次只能进入一个线程，执行完毕后自动解锁，其他线程才可以进来执行

    synchronized(同步锁对象){
    操作共享资源的核心代码；
}

    package com.shouyeren.Thread_app.Thread_safe;

public class Account {
    private double money;

    public Account(double money) {
        this.money = money;
    }

    public Account() {
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    public void DrawMoney(double money) {
        String name = Thread.currentThread().getName();
        //判断余额
        synchronized (this) {
            if (this.money >= money){
                System.out.println(name + "取钱成功，吐出" + money);
                //更新余额
                this.money -= money;
                System.out.println("余额：" + this.money);
            }else {
                System.out.println("余额不足");
            }
        }
    }
}

    锁对象要求：

    • 理论上：锁对象只要对于当前同时执行的线程来说是同一个对象即可。
    • 锁对象用任意唯一的对象会影响其他无关线程的执行
    • 建议使用共享资源作为锁对象
    • 对于实例方法建议使用this作为锁对象
    • 对于静态方法建议使用字节码（类名.class）对象作为锁对象

方式二：同步方法

作用：把出现线程安全问题的核心方法给上锁

原理：每次只能进入一个线程，执行完毕后自动解锁，其他线程才可以进来执行

修饰符 synchronized 返回值类型 方法名称(形参列表){
    操作共享资源的代码
}

public synchronized void DrawMoney(double money) {
        String name = Thread.currentThread().getName();
        //判断余额
        if (this.money >= money){
            System.out.println(name + "取钱成功，吐出" + money);
            //更新余额
            this.money -= money;
            System.out.println("余额：" + this.money);
        }else {
            System.out.println("余额不足");
        }
    }

底层原理:同步方法其实底层也是有隐式锁的，只是锁的范围是整个方法代码。

如果方法是实例方法，同步方法默认用this作为锁对象，但是代码要高度面向对象。

如果方法是静态方法，同步方法默认用类名.class作为锁对象

方式三：Lock锁

  • 为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock，更加灵活、方便

  • Lock实现提供比使用synchronzied方法和语句可以获得更广泛的锁定操作

  • Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来构建Lock锁对象

方法名称说明
public ReentrantLock()获得Lock锁的实现类对象
方法名称说明
void lock()获得锁
void unlock()释放锁
private final ReentrantLock lock = new ReentrantLock();

public void m(){
    lock.lok();//上锁
    try{
        method body...
    }finally{
        lock,unlock();//释放锁
    }
}

线程通信

什么是线程通信、如何实现？

  • 所谓线程通信就是线程间相互发送数据，线程通信通常通过共享一个数据的方式实现。
  • 线程间会根据共享数据的情况决定自己该怎么做，以及通知其他线程该怎么做

线程通信常见模型

  • 生产者与消费者模型：生产者线程负责生产数据，消费者负责消费数据
  • 要求：生产者线程生产完成数据后，唤醒消费者，然后等待自己；消费者消费完该数据后，唤醒生产者，然后等待自己
  • 线程通信是在多个线程操作同一共享资源的时候进行，前提是保证线程安全。

Object类的等待和唤醒方法：

方法名称说明
void wait()让当前线程等待并释放所占用锁，直到另一个线程调用notify()方法或notifyAll()方法
void notify()唤醒正在等待的单个线程
void notifyAll()唤醒正在等待的所有线程

注意：

  • 上述方法应当使用当前同步锁对象

生产者消费者模型模拟

package com.shouyeren.Thread_app.Thread_comunication;

public class Commodity {
    private double quantity;

    public Commodity() {
    }
    public Commodity(double quantity) {
        this.quantity = quantity;
    }

    public synchronized void consumption(double quantity) {
        String name = Thread.currentThread().getName();
        try {
            if (this.quantity >= quantity){
                this.quantity -= quantity;
                System.out.println(name + "购买商品成功，仓库剩余产品数量为：" + this.quantity);
                this.notifyAll();
                this.wait();
            }else {
                this.notifyAll();
                this.wait();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public synchronized void production(double quantity) {
        String name = Thread.currentThread().getName();
        try {
            if (this.quantity == 0){
                this.quantity += quantity;
                System.out.println(name + "生产商品并存入仓库成功，仓库剩余产品数量为：" + this.quantity);
                this.notifyAll();
                this.wait();
            }else {
                this.notifyAll();
                this.wait();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public double getQuantity() {
        return quantity;
    }

    public void setQuantity(double quantity) {
        this.quantity = quantity;
    }



}


package com.shouyeren.Thread_app.Thread_comunication;



public class ProductionThread extends Thread{
  private Commodity commodity;
  public ProductionThread(Commodity commodity, String name){
      super(name);
      this.commodity = commodity;
    }
    @Override
    public void run() {
       while (true){
           commodity.production(100000);
           try{
               Thread.sleep(3000);
           }catch (Exception e){
               e.printStackTrace();
           }
       }
    }
}


package com.shouyeren.Thread_app.Thread_comunication;



public class DrawThread extends Thread{
  private Commodity commodity;
  public DrawThread(Commodity commodity, String name){
      super(name);
      this.commodity = commodity;
    }
    @Override
    public void run() {
       while (true){
           commodity.consumption(100000);
           try{
               Thread.sleep(3000);
           }catch (Exception e){
               e.printStackTrace();
           }
       }
    }
}


package com.shouyeren.Thread_app.Thread_comunication;

/**
 * 模拟生产者消费者模型
 */
public class ThreadDemo {
    public static void main(String[] args) {
        Commodity commodity = new Commodity(0);
        new DrawThread(commodity,"消费者1号").start();
        new DrawThread(commodity,"消费者2号").start();

        new ProductionThread(commodity,"生产者1号").start();
        new ProductionThread(commodity,"生产者2号").start();
        new ProductionThread(commodity,"生产者3号").start();


    }
}

线程池

线程池就是一个可以复用线程的技术

如果用户每发起一个请求，后台就建立一个新线程来处理，下次新任务来了又要创建新线程，而创建新线程的开销是很大的，这样会严重影响系统的性能。

线程池实现的API、参数说明

  • JDK 5.0起提供了代表线程池的接口：ExecutorService

如何得到线程池对象

  • 方式一：使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象
  • 方式二：使用Executors(线程池的工具类)调用方法返回不同特点的线程池对象

ThreadPoolExecutor构造器的参数说明

public ThreadPoolExecutor(int corePoolSize,
                         int maximumPoolSize,
                         long KeepAliveTime,
                         TimeUnit unit,
                         BlockingQueue<Runnable> workQueue,
                         ThreadFactory threadFactory,
                         RejectedExecutionHandler handler)
  • 参数一：指定线程池的线程数量(核心线程)：coreOpplSize——不能小于0
  • 参数二：指定线程池可支持的最大线程数：maximumPoolSize——最大数量>=核心线程数量
  • 参数三：指定零食线程的最大存活时间：KeepAliveTime——不能小于0
  • 参数四：指定存活时间的单位(秒，分，时，天)：unit——时间单位
  • 参数五：指定任务队列：workQueue——不能为NULL
  • 参数六：指定用哪个线程工厂创建线程：threadFactory——不能为NULL
  • 参数七：指定线程忙，任务满时，新任务来了怎么办：handler——不能为NULL

常见面试题：

临时线程什么时候创建？

  • 新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程

什么时候会开始拒绝任务？

  • 核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始拒绝任务

线程池处理Runnable任务

ExecutorService pools = new ThreadPoolExecutor(3,5,8,TimeUnit.SECONDS,new ArrayBlockingQueue<>(6),Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());

ExecutorService的常用方法

方法名称说明
void execute(Runnable command)执行任务/命令，无返回值，一般用来执行Runnable任务
Future submit(Callable task)执行任务，返回未来任务对象获取线程结果，一般用来执行Callable任务
void shutdown()等任务执行完之后关闭线程
List shutdownNow()立刻关闭，停止正在正在执行的任务，并返回队列中未执行的任务

新任务拒绝策略

策略详解
ThreadPoolExecutor.AbortPolicy丢弃任务并抛出RejectedExecutionException异常，是默认的策略
ThreadPoolExecutor.DiscardPolicy：丢弃任务，但是不抛出异常，这是不推荐的做法
ThreadPoolExecutor.DiscardOldesPolicy抛弃队列中等待最久任务，然后把当前任务加入队列中
ThreadPoolExecutor.CallerRunsPolicy由主线程负责调用任务的run()方法从而绕过线程池直接执行
package com.shouyeren.Thread_app.pool;

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "输出了：hello word ==>" + i);
        }
    }
}


package com.shouyeren.Thread_app.pool;

import java.util.concurrent.*;

public class ThreadPoolDemo {
    public static void main(String[] args) {
        ExecutorService pool = new ThreadPoolExecutor(3,5,6,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(5),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

        Runnable myRunnable = new MyRunnable();
        pool.execute(myRunnable);
        pool.execute(myRunnable);
        pool.execute(myRunnable);

    }
}

线程池处理Callable任务

package com.shouyeren.Thread_app.pool;

import java.util.concurrent.Callable;

//定义一个任务类，实现Callable接口，应该声明线程执行返回结果的数据类型
class MyCallable implements Callable<String> {
    private int n;

    public MyCallable(int n) {
        this.n = n;
    }

    //重写call方法
    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= n; i++) {
            sum += i;
        }
        return Thread.currentThread().getName() + "子线程的执行结果是：" + sum;
    }
}

package com.shouyeren.Thread_app.pool;

import java.util.concurrent.*;

public class ThreadPoolDemo_Callable {
    public static void main(String[] args) throws Exception{
        ExecutorService pool = new ThreadPoolExecutor(3,5,6,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(5),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

        Future<String> f1 = pool.submit(new MyCallable(100));
        Future<String> f2 = pool.submit(new MyCallable(200));
        Future<String> f3 = pool.submit(new MyCallable(300));
        Future<String> f4 = pool.submit(new MyCallable(400));

        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());

    }
}

Executors得到线程池对象的常用方法

Executors：线程池的工具类通过调用方法返回不同类型的线程池对象

方法名称说明
public static ExecitorService newCachedThreadPool()线程数量随着任务增加而增加，如果线程任务执行完毕且空闲了一段时间则会被回收掉
public static ExecutorService newCachedThreadPool(int nThreads)创建固定线程数量的线程池，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程替代他
public static ExecitorService newSingleThreadExecutor()创建只有一个线程的线程池对象，如果该线程出现异常而结束，那么线程池会补充一个新线程
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)创建一个线程池，可以实现给定的延迟后运行任务，或者定期执行任务

注意：Executors的底层其实也是基于线程池的实现类ThreadPoolExecutor创建线程池对象的。

Executors使用可能存在的陷阱

  • 大型并发系统环境中使用Executors如果不注意，可能会出现系统风险

public static ExecutorService newFixedThreadPool(int nThreads)

public static ExecutorService newSingleThreadExecutor()

允许请求任务队列的长度是Integer,MAX_VALUE,可能出现OOM错误(java.lang.OutOfMemoryError)

public static ExecutorService newCachedThreadPool()

public static ScheduExecutorService newScheduThreadPool(int corepoolSize)

创建的线程数量最大上限是Integer,MAX_VALUE，线程数可能会随着任务1：1增长，也可能出现OOM错误(java.lang.OutOfMemoryError)

定时器

定时器是一种控制任务延迟调用，或者周期调用的技术（闹钟、定时邮件发送）

定时器实现的方式：

  • 方式一：Timer

    构造器说明
    public Timer()创建Timer定时器对象
    方法说明
    public void schedule(TimerTask task,long delay,long period)开启一个定时器。按照计划处理TimerTask任务

    Timer定时器的特点和存在的问题

    1. Timer是单线程，处理多个任务按照顺序执行，存在延时与设置定时器的时间有出入
    2. 可能因为其中的某个任务的异常使Timer线程死亡，从而影响后续任务执行

  • 方式二：ScheduledExecutorService

ScheduledExecutorService是jdk1.5中引入的并发包，目的是为了弥补Timer的缺陷，ScheduledExecutorService内部为线程池

Executors的方法说明
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)得到线程池对象
ScheduledExecutorService的方法说明
public ScheduledFuture<?> scheduledRate(Runnable command,long initialDelay,long period,TimeUnit unit)周期调度方法

ScheduledExecutorService的优点

基于线程池，某个任务的执行情况不会影响其他定时任务的执行。

并发与并行

正在运行的程序(软件)就是一个独立的进程，线程是属于进程的，多个线程其实是并发与并行同时进行的

并发的理解：

  • CPU同时处理线程的数量有限
  • CPU会轮询为系统每个线程服务，由于CPU切换的速度很快，给我们感觉这些线程在同时进行，这就是并发
    并行的理解：
  • 在同一个时刻上，同时有多个线程在被CPU处理并执行

生命周期

线程的状态：也就是线程从生到死的过程，以及中间经历的各种状态及状态切换

理解线程的状态有利于提升并发编程的理解能力

Java线程的状态：

  • Java总共定义了6种状态
  • 6种状态都定义在Thread类的内部枚举类中
public class Thread{
    public enum State{
        NEW,//新建
        RUNABLE,//可运行
        BLOCKED,//阻塞
        WAITING,//无限等待
        TIMED_WAITING,//计时等待
        TERMINATED;//被终止下
    }
}

​在这里插入图片描述

感觉不错的话，动手点个赞吧！

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

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

相关文章

主板EC程序烧写异常致无法点亮修复经验

主板EC程序烧写异常致无法点亮修复经验

主板型号&#xff1a;Gigabyte AB350M-Gaming3 官网上明确写着支持R5 5500&#xff0c;但按照如下步骤实践下来实际是不支持的 升级biosF31到F40版本的注意事项&#xff1a; 步骤&#xff1a; 1 使用Q-Flash先将bios升级到f31版本&#xff1b;2 然后下载提示中的ECFW Update To…
阅读更多...
常见排序算法——冒泡排序和选择排序

常见排序算法——冒泡排序和选择排序

常用算法 一、排序算法 1.1、冒泡排序 冒泡排序(Bubble Sorting)的基本思想是&#xff1a;通过对待排序序列从前向后&#xff08;从下标较小的元素开始&#xff09;&#xff0c;依次比较相邻元素的值&#xff0c;若发现逆序则交换&#xff0c;使值较大的元素逐渐从前移向后部…
阅读更多...
Fiddler 模拟弱网环境测试

Fiddler 模拟弱网环境测试

为什么要进行弱网环境测试&#xff1f; 由于用户自身的网络环境波动&#xff0c;或者是本身网络环境就较为恶劣&#xff0c;导致会出现一些意想不到的非功能性bug&#xff0c;影响用户体检。比如 利用Fiddler&#xff0c;Charles等具有代理服务器功能的网络流量分析软件来实现…
阅读更多...
操作留痕功能实现与探讨

操作留痕功能实现与探讨

操作留痕功能实现与探讨 背景 接手了一个单体应用项目&#xff0c;看系统介绍&#xff0c;说实现了【高性能的操作日志留痕】功能&#xff0c;就有点好奇它是怎么设计的&#xff0c;是阻塞队列还是怎样的线程池。结果我打开代码一看&#xff0c;真的是笑洗个人了。它是做了一…
阅读更多...
Mysql全解[基础篇]

Mysql全解[基础篇]

目录MySQL概述数据库相关概念MySQL数据库版本docker部署单机节点sqlmode说明连接mysql数据模型关系型数据库&#xff08;RDBMS&#xff09;数据模型mysql版本对比MySQL 5.5MySQL 5.6MySQL 5.7MySQL 8.0SQLSQL通用语法SQL分类DDL数据库操作表操作数据类型数值类型字符串类型日期…
阅读更多...
操作系统——12.处理机调度的概念、层次

操作系统——12.处理机调度的概念、层次

这篇文章我们来讲一下处理机调度的概念和层次 目录 1.概述 2.调度的基本概念 3.调度的三个层次 3.1高级调度 3.2中级调度 3.3.低级调度 3.4三种调度的对比 4.挂起状态与七状态模型 5.小结 1.概述 首先&#xff0c;我们来看一下本节的知识框架图&#xff1a; 2.调度的…
阅读更多...
连接Oracle数据库失败（ORA-12514）故障排除

连接Oracle数据库失败（ORA-12514）故障排除

文章目录症状产生原因解决办法欢迎加下方我的微信&#x1f447;&#xff0c;拉你入学习群点击试看博主的专著《MySQL 8.0运维与优化》&#xff08;清华大学出版社&#xff09;ORA-12514的故障是很多新手在连接Oracle数据库时经常遇到故障&#xff0c;它通常表示无法连接到数据库…
阅读更多...
python+pytest接口自动化框架(5)-requests发送post请求

python+pytest接口自动化框架(5)-requests发送post请求

在HTTP协议中&#xff0c;与get请求把请求参数直接放在url中不同&#xff0c;post请求的请求数据需通过消息主体(request body)中传递。且协议中并没有规定post请求的请求数据必须使用什么样的编码方式&#xff0c;所以其请求数据可以有不同的编码方式&#xff0c;服务端通过请…
阅读更多...
专访阮健丨压力就是动力，危机也是转机

专访阮健丨压力就是动力，危机也是转机

48岁的阮健加入酷雷曼已经三个年头&#xff0c;从最初的孤身一人至今&#xff0c;他已经拥有了一个五六人的VR全景团队。 阮健团队的拍摄设备 “人的一生真的是充满不确定性的&#xff0c;那些年我辗转好几个行业的时候&#xff0c;也会一边抱怨行业不景气一边又想着怎么多干点…
阅读更多...
Vue3 企业级项目实战：全新优化升级

Vue3 企业级项目实战：全新优化升级

Vue3 企业级项目实战 - 程序员十三 - 掘金小册Vue3 Element Plus Spring Boot 企业级项目开发&#xff0c;升职加薪&#xff0c;快人一步。。「Vue3 企业级项目实战」由程序员十三撰写&#xff0c;2744人购买https://s.juejin.cn/ds/S2RkR9F/ 写下这些文字的时候是2022年9月…
阅读更多...
无需公网IP，安全稳定实现U8C异地访问

无需公网IP，安全稳定实现U8C异地访问

用友是全球领先的企业云服务与软件提供商&#xff0c;在财务、人力、供应链、采购、制造、营销、研发、项目、资产、协同等领域为客户提供数字化、智能化、社会化的企业云服务产品与解决方案。 U8C是用友针对成长型、创新型企业&#xff0c;提供企业级ERP整体解决方案。在系统…
阅读更多...
ChunJun 1.16 Release版本即将发布，bug 捉虫活动邀您参与！

ChunJun 1.16 Release版本即将发布，bug 捉虫活动邀您参与！

亲爱的社区小伙伴们&#xff0c;历时数月&#xff0c;我们很高兴地宣布&#xff0c;ChunJun 即将迎来 1.16 Release 版本的正式发布。在新版本中&#xff0c;ChunJun 新增了一批常用功能&#xff0c;进行了多项功能优化和问题修复&#xff0c;并在用户使用体验上进行了极大地改…
阅读更多...
systemctl 启动/停止/重新加载 nginx

systemctl 启动/停止/重新加载 nginx

systemctl 启动/停止/重新加载 nginx 一、新建nginx.service脚本 sudo vim /usr/lib/systemd/system/nginx.service然后按iii进入编辑模式&#xff0c;粘贴如下内容&#xff0c;其中/usr/local/nginx/是进行make && make install之后的文件夹路径&#xff0c;需要根据…
阅读更多...
虚拟地址空间

虚拟地址空间

本节目录1.如何理解区域划分2.为什么一个变量可以存储两个不同的值&#xff1f;3.深入理解虚拟地址空间为什么要有地址空间&#xff1f;4.理解什么是挂起&#xff1f;1.虚拟地址空间究竟是什么&#xff1f;2.映射关系的维护是谁做的&#xff1f;1.如何理解区域划分 所谓的区域…
阅读更多...
STM32F1，F4，L1系列禁止JTAG和SW引脚方法

STM32F1，F4，L1系列禁止JTAG和SW引脚方法

STM32F1系列 程序中在使用到JTAG、SWD的某个IO 时&#xff0c;需要禁用掉相关调试方法后&#xff0c;再配置相应的IO方式。在需要相应的接口配置前使用这些代码。 对于F1系列&#xff0c;调用函数进行专门的禁止。 标准库配置方式&#xff1a; RCC_APB2PeriphClockCmd(RCC_A…
阅读更多...
【蓝桥杯嵌入式】LCD屏的原理图解析与代码实现（第十三届省赛为例）——STM32

【蓝桥杯嵌入式】LCD屏的原理图解析与代码实现（第十三届省赛为例）——STM32

&#x1f38a;【蓝桥杯嵌入式】专题正在持续更新中&#xff0c;原理图解析✨&#xff0c;各模块分析✨以及历年真题讲解✨都在这儿哦&#xff0c;欢迎大家前往订阅本专题&#xff0c;获取更多详细信息哦&#x1f38f;&#x1f38f;&#x1f38f; &#x1fa94;本系列专栏 - 蓝…
阅读更多...
智能家居Homekit系列一智能触摸开关

智能家居Homekit系列一智能触摸开关

触摸开关&#xff0c;即通过触摸方式控制的墙壁开关&#xff0c;其感官场景如同我们的触屏手机&#xff0c;只需手指轻轻一点即可达到控制电器的目的&#xff0c;随着人们生活品质的提高&#xff0c;触摸开关将逐渐将换代传统机械按键开关。 触摸开关控制原理 触摸开关我们把…
阅读更多...
HNU工训中心： 三人表决器及八人抢答器实验报告

HNU工训中心： 三人表决器及八人抢答器实验报告

工训中心的牛马实验 三人表决器&#xff1a; 实验目的 1) 辨识数字IC功能说明。 2) 测试数字集成门电路&#xff0c;掌握输出故障排除、使用注意事项。 3) 掌握逻辑函数搭建三人表决器。 2.实验资源 HBE硬件基础电路实验箱、万用表 74LS00与非门、74LS10 三个3输入与非门…
阅读更多...
JS 的同步异步、事件循环

JS 的同步异步、事件循环

js 执行过程&#xff1a;先执行同步代码在执行异步代码案例1: 以下就是 同步代码异步代码&#xff0c;同步代码先执行&#xff0c;异步代码后执行console.log(1); //1 setTimeout(()>{ console.log(3) //2 },10)案例2: 执行顺序console.log(1) //1 setTimeout(()>{ conso…
阅读更多...
ChatGTP--事务是否生效?

ChatGTP--事务是否生效?

项目场景&#xff1a; 由于最近在做一个项目的cola代码改造,所以由于cola需要在 service 和 dao层中间加一层>>> gateway,和springcloud中的gateway不一样,这个仅仅是抽象了一层; 思考: 现在我的事务 依然在service中开启,那么我的事务经过了一个gateway后,再次调用d…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023