Thread类的基本操作（JAVA多线程）

news2024/11/25 0:40:01

线程是操作系统中的概念，操作系统内核实现了线程这样的机制，并提供了一些API供外部使用。

JAVA中 Thread类 将系统提供的API又近一步进行了抽象和封装，所以如果想要使用多线程就离不开 Thread 这个类。

线程的创建(Thread类)

在JAVA中 创建线程可以有多种方法，这里简单介绍几种。

方法一：我们自己编写一个类使这个类继承自Thread类，然后重写里面的 run() 方法。

    class MeThread extends Thread {
        //必须要实现这个方法，此方法是新线程执行的入口方法（告诉线程应该做什么）
        @Override
        public void run() {
            System.out.println("这是新线程执行的任务");
        }
    }

    public static void main(String[] args) {
        //创建一个线程对象
        MeThread t = new MeThread();
        //调用系统API启动线程
        t.start();
    }

当我们运行程序之后就会执行 run() 方法中的打印操作。

new 一个Thread类只是创建出了一个线程，并不会调用系统API创建线程，只有当调用了start() 方法之后才会调用系统API在系统中创建出线程并启动。（此时不理解可以，因为在介绍isAlive()方法时会验证）

这个重写的 run() 方法可以理解为一个任务，这个方法会在线程启动时自动被调用执行，当线程执行完这个方法中的内容时该线程就会被销毁并且无法再次使用start()方法唤醒。

此时我们为了可以更好的呈现多线程并发编程的效果对上述代码进行了一些细微修改。

    class MeThread extends Thread {
        //必须要重写这个方法，此方法是新线程执行的入口（告诉线程应该做什么）
        @Override
        public void run() {
            //此处让这个新线程每隔0.1s执行一次打印操作
            while (true) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("这是创建的新线程执行的任务");
            }
        }
    }

    public static void main(String[] args) {
        MeThread t = new MeThread();
        //调用系统API启动线程
        t.start();
        //让主线程每隔0.1s执行一次打印操作
        while (true) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("主线程");
        }
    }

5420a28a4bc04b979e145e656e12fa9c.png

此时可以看到两个while循环是“同时执行的” ，每个线程都是一个独立的执行流。

代码执行之后可以看到程序在无规律的进行打印，其主要原因是系统对线程的调度是随机的。 

方法二：我们自己编写一个类使实现 Runnable接口 然后重写里面的 run() 方法。

  • Thread类 实现了 Runnable接口；
  • Thread类 中的 run() 方法也是重写的 Runnable接口中的；

  • 因为在 Thread类 中提供了一个这样的构造方法：57fd3e2dbd40417aa31283ca59e7d382.png

    class MeRunnable implements Runnable{
        //必须要重写这个方法，此方法是新线程执行的入口
        @Override
        public void run() {
            System.out.println("这是一个新线程执行的任务");
        }
    }

    public static void main(String[] args) {
        MeRunnable runnable = new MeRunnable();
        Thread t = new Thread(runnable);
        //调用系统API启动线程
        t.start();
    }

使用 Runnable 接口和直接继承 Thread 的区别就是：可以帮我们降低代码的耦合性也就是“解耦合”。

Runnable 它表示一个可以执行的任务 而它并不关心这个任务是啥，在哪里执行；这个任务也不一定和线程强相关，因为这个代码可能使用单线程、多线程还是不使用线程或者是用其他方法（例：线程池，协程……）执行都没有任何区别。

而此时使用 Runnable 就可以将这个任务单独的提取出来，这样就可以随时改变这个任务是使用什么方法进行执行（例如：后面如果不想用线程了就可以直接在main方法中进行调用）例：

    class MeRunnable implements Runnable{
        @Override
        public void run() {
            System.out.println("这是一个任务");
        }
    }

    public static void main(String[] args) {
        MeRunnable runnable = new MeRunnable();
        //此时不想使用线程执行这个任务
        runnable.run();
    }

方法三：使用匿名内部类。

    public static void main(String[] args) {
        Thread t = new Thread(){
            @Override
            public void run() {
                System.out.println("这是创建的新线程执行的任务");
            }
        };
        //调用系统API启动线程
        t.start();
    }

因为在 Thread类 中提供了一个这样的构造方法：57fd3e2dbd40417aa31283ca59e7d382.png

所以我们可以写成过这样： 

    public static void main(String[] args) {
        Thread t = new Thread(new Runnable(){
            @Override
            public void run() {
                System.out.println("这是一个新线程执行的任务");
            }
        });
        //调用系统API启动线程
        t.start();
    }

 方法四：因为Runnable接口是一个函数式接口，所以可以利用 Lambda表达式 来创建线程。

    public static void main(String[] args) {
        Thread t = new Thread(() -> System.out.println("这是创建的新线程执行的任务"));
        //调用系统API启动线程
        t.start();
    }

除了观看控制台的输出结果来观察多线程之外，还可以使用JDK中带有的工具 jconsole 来更形象的观测：具体方法可以跳转这里icon-default.png?t=N7T8http://t.csdnimg.cn/b8Wca

Thread类的一些常见构造方法

方法说明
Thread()创建线程对象
Thread(Runnable target)使用 Runnable 对象创建线程对象
Thread(String name)创建线程对象，并命名
Thread(Runnable target, String name)使用 Runnable 对象创建线程对象，并命名
Thread(ThreadGroup group,Runnable target)线程可以被用来分组管理，分好的组即为线程组，这
个目前我们了解即可

Thread类中的一些常见属性：

属性获取方法
IDgetId()
名称getName()
状态getState()
优先级getPriority()
是否后台线程isDaemon()
是否存活isAlive()
是否被中断isInterrupted()

getId()：

获取当前线程的 id 

id 是线程的唯一身份标识，这个 id 是 JAVA 为这个线程分配的，并不是系统 API 分配的 ID ，更不是 PCB 的 ID 。

    public static void main(String[] args) {
        Thread t = new Thread(() -> {while (true) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                //打印异常
                e.printStackTrace();
            }
            System.out.println("这是创建的新线程执行的任务");
        }});

        Thread t1 = new Thread(() -> {while (true) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("这是创建的新线程执行的任务");
        }});
        t.start();
        t1.start();
        System.out.println(t.getId());//获取并打印当前线程的ID
        System.out.println(t1.getId());//获取并打印当前线程的ID
    }

b804bcb5dcb64387821b90b2bdf7d29e.png

isDaemon()

判断当前线程是否为后台线程。

线程默认都是前台线程。

  • 前台线程：只要该进程中还有前台线程未执行完，那么该进程就不会结束（前台线程会影响进程的结束与否）；
  • 后台线程：只要该进程中的前台线程都执行完毕，那么此时无论是否有未执行完的后台线程进程都会结束（后台线程不会影响进程的结束与否）。
    public static void main(String[] args) {
        Thread t = new Thread(() -> {while (true) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                //打印异常
                e.printStackTrace();
            }
            System.out.println("这是创建的新线程执行的任务");
        }});

        t.start();
        System.out.println(t.isDaemon());//获取并打印当前线程是否为后台线程
    }

0529f0a3cabe4a7cb3c1601bc1ed7ca9.png

此时将上述代码改成后台线程。

    public static void main(String[] args) {
        Thread t = new Thread(() -> {while (true) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                //打印异常
                e.printStackTrace();
            }
            System.out.println("这是创建的新线程执行的任务");
        }});
        //将当前线程设置为后台线程
        t.setDaemon(true);
        t.start();
        System.out.println(t.isDaemon());
    }

8bd1e4d9722f48f899f64e0cb9d291f1.png

此时因为主线程（main线程）飞快的执行完了所以没有任何打印。

isAlive()

分别在线程启动前后打印判断线程是否存活（注意：线程对象存活时线程并不一定会存活）

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                //打印异常
                e.printStackTrace();
            }
            System.out.println("新线程执行完毕");
        });
        System.out.println("线程启动前");
        System.out.println("线程是否存活"+t.isAlive());
        t.start();
        System.out.println("线程已启动");
        System.out.println("线程是否存活"+t.isAlive());
        Thread.sleep(2000);
        System.out.println("线程是否存活"+t.isAlive());
    }

c5b74a4e3d544c9299f1eab678344a41.png

根据结论可以得知当我们创建线程对象之后并不会调用系统API创建线程，只有当调用了start() 方法之后才会调用系统API在系统中创建出线程并启动。

打断线程

在JAVA中打断线程的方法是比较唯一的：本质上都是让run()方法尽快执行结束；而在C++中是有办法可以在线程执行过程中直接销毁该线程，但是这样做有个坏处比如这个线程在写文章时突然中断了那就会令这篇文章有头无尾，而在JAVA中就可以允许在此处进行一些收尾工作。

而现实中令run()方法迟迟无法结束的原因一般都是应为循环，所以只要 结束循环就可以让线程尽快执行完run()方法，从而达到打断线程的效果。

此处介绍两种方法：

第一种方法：

可以手动创建出一个标志位，用来控制 run() 方法中循环的终止条件。

    //创建一个成员变量用来控制循环的终止条件,默认值为 false;
    private static boolean isQuit;
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while(!isQuit) {
                System.out.println("新线程正在工作");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    //打印异常
                    e.printStackTrace();                }
            }
            System.out.println("新线程执行完毕");
        });
        
        t.start();
        Thread.sleep(500);
        
        isQuit = true;
        System.out.println("打断新线程");
    }

cf6542b5d12c4b8abd3f50a8b87e8445.png

但是有以下两个问题：

  1. 需要手动创建标志位；
  2. 如果循环正处在sleep状态程序将不能进行及时的响应。

第二种方法：

在JAVA中默认就有一个标志位，我们可以利用JAVA中默认的标志位来进行快速结束run()方法的操作。

好处是这样我们就不用再单独创建一个变量，不用再思考变量捕获的问题了。

  • interrupt() :该方法可以将线程中默认的标志位设置为true
  • isInterrupt():判断对象关联的线程的标志位是否被设置，调用后不清除标志位。还可以使sleep()方法抛出InterruptedException异常，来强行中断sleep()方法。

利用这两个方法就可以实现线程的打断

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            //Thread.currentThread()该方法是用来得到该线程的实例也就是t（哪个线程调用该方法就返回哪个线程的实例）
            //因为此时t还没有被创建所以不能写为t.isInterrupted()
            while(!Thread.currentThread().isInterrupted()) {
                System.out.println("新线程正在工作");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    //打印异常
                    e.printStackTrace();
                }
            }
            System.out.println("新线程执行完毕");
        });

        t.start();
        Thread.sleep(5000);
        //设置标志位为true
        t.interrupt();
        System.out.println("打断新线程");
    }

0a7d1cbb2cb043519d03f502c3c38b12.png

结果可以看出来此时标志位确实被设置了，sleep()方法也抛出了异常，可是循环并没有被终止。

原因是sleep()方法在抛出异常之后会自动将标志位清除，而此引起的结果就和没有设置标志位是相同的。

而JAVA如此设计的原因其实就是扩大程序员的可操作空间，可以再sleep()方法抛出异常之后进行一些收尾工作。

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            //Thread.currentThread()该方法是用来得到该线程的实例也就是t（哪个线程调用该方法就返回哪个线程的实例）
            //因为此时t还没有被创建所以不能写为t.isInterrupted()
            while(!Thread.currentThread().isInterrupted()) {
                System.out.println("新线程正在工作");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    //此处可以写一些收尾工作的代码
                    break;
                }
            }
            System.out.println("新线程执行完毕");
        });

        t.start();
        Thread.sleep(500);
        //设置标志位为true
        t.interrupt();
        System.out.println("打断新线程");
    }

37fd158250634d449c15b256f84593f7.png

线程等待

再多线程的代码中由于线程的调度是随机的，所以也就会导致每个线程的结束时间也是无法预测的，而这种情况下就会使得在有些场景下代码出现BUG。

而线程等待就是让一个线程来等待另一个线程执行结束，本质上就是来控制线程结束的顺序。

join()

实现线程等待的效果，让一个线程阻塞等待另一个线程执行结束之后再执行。

  • 等的线程：在哪个线程中调用 join 方法，哪个线程就阻塞等待；
  • 被等的线程：调用的哪个线程对象的 join 方法，哪个线程就是被等的线程，当这个线程执行完毕等的线程才会执行。

我们创建一个线程 t 让这个线程每隔一秒打印一次数据，让主线程等待该线程。

Thread t = new Thread(()->{
    for (int i = 0; i < 4; i++) {
        System.out.println("t线程执行中");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
});
t.start();
System.out.println("等待开始");
t.join();
System.out.println("等待结束");

注意：如果 t 线程已经执行结束，此时再调用 join 就会直接返回执行，不会发生阻塞等待。

join(等待时间)

上面的 join() 方法是一种“死等”的方法，只要被等待的线程不结束，那么就会一直等待下去。

但是一般情况下我们并不会死等而是等待超过了一定时间之后就不会再继续等待了，因为没有意义。

  • join(long millis)         最多等待 millis 毫秒
  • join(long millis, int nanos)       和上面的方法一样 就是时间精度更高，精确到了纳秒

休眠线程

  • sleep(long millis)  让线程休眠 millis 毫秒；
  • sleep(long millis，int nanos)  和上面的功能一样，就是精度更高。

但是下面的这一种其实意义不大，因为 sleep() 本身就存在一定的误差，并不是你写 sleep(1000) 就真的刚好等精确 1000 ms ，它还有一个调度的开销。系统会按照 1000 这个时间来休眠线程，当时间到了之后，系统会唤醒该线程（阻塞 -> 就绪），而且并不是线程进入就绪状态就能立即进入CPU执行。

//获取系统当前时间戳
long a = System.currentTimeMillis();
Thread.sleep(1000);
//获取系统当前时间戳
long b = System.currentTimeMillis();
System.out.println("时间："+(b - a)+" ms");

而且每次运行之后结果都是不同的。

线程的状态

JAVA中线程的所有状态都存储在一个枚举类型中，Thread.State ：

for (Thread.State str:Thread.State.values()) {
    System.out.println(str);
}

可以通过上述代码来打印所有的线程状态

通过 getState() 方法可以获取线程的状态

  • NEW：Thread对象已经有了，但还没有调用 start() 方法；
Thread t = new Thread(()->{

});
System.out.println(t.getState());

  • RUNNABLE：就绪状态（线程已经在CPU上执行了或者排队准备执行）
Thread t = new Thread(()->{
    while(true) {

    }
});
t.start();
System.out.println(t.getState());

  • BLOCKED：阻塞，由于锁竞争导致的阻塞
Object lock1 = new Object();
Object lock2 = new Object();

Thread t1 = new Thread(()->{
    synchronized(lock1) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        synchronized(lock2) {

        }
    }
});
Thread t2 = new Thread(()->{
    synchronized(lock2) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        synchronized(lock1) {

        }
    }
});
t1.start();
t2.start();
//让主线程等待 2 秒
Thread.sleep(2000);
//此时t1和t2两个线程会因为互相争对方的锁，而导致死锁
System.out.println(t1.getState());
System.out.println(t2.getState());

  • WAITING：阻塞由 wait 这种不固定时间的方式引起的阻塞
Object lock1 = new Object();

Thread t1 = new Thread(()->{
    synchronized(lock1) {
        try {
        //调用wait方法让线程阻塞
            lock1.wait();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
});

t1.start();
Thread.sleep(1000);
System.out.println(t1.getState());

  • TIMED_WAITING：由 sleep 这种固定时间限制的方式引起的阻塞
Thread t1 = new Thread(()->{
    try {
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
});

t1.start();
Thread.sleep(1000);
System.out.println(t1.getState());

  • TERMINATED：Thread对象还在，可是线程已经没了
Thread t1 = new Thread(()->{

});

t1.start();
Thread.sleep(1000);
System.out.println(t1.getState());

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

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

相关文章

SPSS多元方差分析

SPSS多元方差分析

前言&#xff1a; 本专栏参考教材为《SPSS22.0从入门到精通》&#xff0c;由于软件版本原因&#xff0c;部分内容有所改变&#xff0c;为适应软件版本的变化&#xff0c;特此创作此专栏便于大家学习。本专栏使用软件为&#xff1a;SPSS25.0 本专栏所有的数据文件请点击此链接下…
阅读更多...
大容量中间继电器 RXMH2 RK223 067 DC110V JOSEF约瑟

大容量中间继电器 RXMH2 RK223 067 DC110V JOSEF约瑟

系列型号 RXMH2 RK 223 067大容量中间继电器&#xff1b; RXMH2 RK 223 068大容量中间继电器&#xff1b; RXMH2 RK 223 069大容量中间继电器&#xff1b; RXMH2 RK 223 070大容量中间继电器&#xff1b; 一、用途 RXMH2系列大容量中间继电器用于工业自动化控制及电力系统…
阅读更多...
Git介绍及使用

Git介绍及使用

目录 一、Git 的基本概念 1. 仓库&#xff08;Repository&#xff09;: 仓库是存储代码的地方。可以通过 命令将本地文件夹初始化为 Git 仓库&#xff0c;并使用 命令从远程仓库克隆到本地 2. 分支&#xff08;Branch&#xff09;: 分支是指从主分支上创建出来的一个分支&…
阅读更多...
Python画一个爱心

Python画一个爱心

Python画一个爱心 一、效果图二、Python代码 一、效果图 二、Python代码 import random from math import sin, cos, pi, log from tkinter import *CANVAS_WIDTH 640 # 画布的宽 CANVAS_HEIGHT 480 # 画布的高 CANVAS_CENTER_X CANVAS_WIDTH / 2 # 画布中心的X轴坐标 CA…
阅读更多...
DCU集群搭建虚拟环境方法简介

DCU集群搭建虚拟环境方法简介

1.conda安装方法&#xff1a; wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh #下载miniconda安装包chmod 750 Miniconda3-latest-Linux-x86_64.sh #添加执行权限bash ./Miniconda3-latest-Linux-x86_64.sh #安装下载的minnconda32.集群安装…
阅读更多...
FreeRTOS源码阅读笔记1--task.c

FreeRTOS源码阅读笔记1--task.c

在FreeRTOS中&#xff0c;创建任务有两种方式&#xff1a;动态创建和静态创建。区别就是&#xff1a;动态创建任务的栈和任务TCB是由操作系统动态分配&#xff08;malloc&#xff09;内存空间&#xff0c;任务删除时可以释放内存&#xff08;free&#xff09;&#xff1b;而静态…
阅读更多...
单链表（无头单项非循环）

单链表（无头单项非循环）

文章目录 前言概述链表的实现初始化遍历单链表创建新节点尾插头插尾删头删单链表的查找在pos位置之前插入一个节点在pos位置删除节点在pos位置后插入节点删除pos后一个节点销毁 结尾 前言 链表是一种物理存储结构上非连续、非顺序的存储结构&#xff0c;数据元素的逻辑顺序是通…
阅读更多...
HDFS系统操作命令大全

HDFS系统操作命令大全

一&#xff0c;前言 HDFS作为分布式存储的文件系统&#xff0c;有其对数据的路径表达方式 HDFS同linux系统一样&#xff0c;均是以/作为根目录的组织形式 linux&#xff1a;/usr/local/hello.txt HDFS&#xff1a;/usr/local/hello.txt 二&#xff0c;如何区分呢&#xff1f; L…
阅读更多...
【数据结构】树与二叉树（三）：二叉树的定义、特点、性质及相关证明

【数据结构】树与二叉树（三）：二叉树的定义、特点、性质及相关证明

文章目录 5.1 树的基本概念5.1.1 树的定义5.1.2 森林的定义5.1.3 树的术语5.1.4 树的表示 5.2 二叉树5.2.1 二叉树1. 定义2. 特点3. 性质引理5.1&#xff1a;二叉树中层数为i的结点至多有 2 i 2^i 2i个&#xff0c;其中 i ≥ 0 i \geq 0 i≥0。引理5.2&#xff1a;高度为k的二叉…
阅读更多...
yolov5--ptq--qat量化之敏感层分析

yolov5--ptq--qat量化之敏感层分析

敏感层分析&#xff0c;应该是发生在ptq量化之前进行分析的操作&#xff0c;经过该操作&#xff0c;可得出哪些层不适合进行量化&#xff0c;则在接下来ptq时可以手动关闭这些层的量化。 进入敏感层分析函数sensitive_analysis中&#xff0c; 具体流程为&#xff1a; 首先验证…
阅读更多...
打印机共享连接0x000003e3错误

打印机共享连接0x000003e3错误

重点重点&#xff1a;如使用下面教程还不行的朋友&#xff0c;请这样操作。 不管主机还是客户机&#xff0c;都运行“局域网共享一键修复工具”&#xff0c;并选择“简单共享&#xff08;无密码&#xff09;” 不管主机还是客户机&#xff0c;都操作一次此教程。 不管主机还是客…
阅读更多...
Langchain-Chatchat项目：5.1-ChatGLM3-6B工具调用

Langchain-Chatchat项目：5.1-ChatGLM3-6B工具调用

在语义、数学、推理、代码、知识等不同角度的数据集上测评显示&#xff0c;ChatGLM3-6B-Base 具有在10B以下的基础模型中最强的性能。ChatGLM3-6B采用了全新设计的Prompt格式&#xff0c;除正常的多轮对话外。同时原生支持工具调用&#xff08;Function Call&#xff09;、代码…
阅读更多...
如何用思维导图拆书

如何用思维导图拆书

思维导图是一种非常有用的工具&#xff0c;可以被广泛应用于不同领域的人群。 阅读是我们获取知识和提升自己的重要途径&#xff0c;而做好读书笔记有助于加深对书中内容的理解和记忆。其中&#xff0c;使用思维导图作为读书笔记的工具&#xff0c;不仅能够帮助我们更好地整理…
阅读更多...
lombok依赖介绍（帮助我们消除冗长代码，如get，set方法）

lombok依赖介绍（帮助我们消除冗长代码，如get，set方法）

前言 lombok 是一个 Java 工具库&#xff0c;通过注解的方式&#xff0c;简化 Java 开发。要想使用 lombok 中的注解&#xff0c;我们需要先引入依赖&#xff0c;推荐看idea必装插件EditStarters&#xff08;快速引入依赖&#xff09;&#xff0c;lombok是⼀款在编译期⽣成代码…
阅读更多...
k8s提交spark应用消费kafka数据写入elasticsearch7

k8s提交spark应用消费kafka数据写入elasticsearch7

一、k8s集群环境 k8s 1.23版本&#xff0c;三个节点&#xff0c;容器运行时使用docker。 spark版本时3.3.3 k8s部署单节点的zookeeper、kafka、elasticsearch7 二、spark源码 https://download.csdn.net/download/TT1024167802/88509398 命令行提交方式 /opt/module/spark…
阅读更多...
技术分享 | 被测项目需求你理解到位了么？

技术分享 | 被测项目需求你理解到位了么？

需求分析是开始测试工作的第一步&#xff0c;产品会先产出一个需求文档&#xff0c;然后会组织需求宣讲&#xff0c;在需求宣讲中分析需求中是否存在问题&#xff0c;然后宣讲结束后&#xff0c;通过需求文档分析测试点并且预估排期。所以对于需求的理解非常重要。 需求文档 …
阅读更多...
壹[1]，QT自定义控件创建(QtDesigner)

壹[1]，QT自定义控件创建(QtDesigner)

1&#xff0c;环境 Qt 5.14.2 VS2022 原因&#xff1a;厌烦了控件提升的繁琐设置&#xff0c;且看不到界面预览显示。 2&#xff0c;QT制作自定义控件 2.1&#xff0c;New/其他项目/Qt4 设计师自定义控件 2.2&#xff0c;设置项目名称 2.3&#xff0c;设置 2.4&#xff0c;设…
阅读更多...
YOLOv7改进策略：一种新颖的可扩张残差（DWR）注意力模块，增强多尺度感受野特征，助力小目标检测

YOLOv7改进策略：一种新颖的可扩张残差（DWR）注意力模块，增强多尺度感受野特征，助力小目标检测

💡💡💡本文全网首发独家改进：一种新颖的可扩张残差（DWR）注意力模块，加强不同尺度特征提取能力，创新十足，独家首发适合科研 推荐指数：五星 DWR | 亲测在多个数据集能够实现涨点，多尺度特性在小目标检测表现也十分出色。 💡💡💡Yolov5/Yolov7魔术师，独…
阅读更多...
【Java 进阶篇】Cookie 使用详解

【Java 进阶篇】Cookie 使用详解

欢迎阅读本篇博客&#xff0c;我们将深入研究 Java 中的 Cookie&#xff0c;从入门到精通&#xff0c;包括 Cookie 的基本概念、原理、使用方法以及一些高级技巧。无论你是新手还是有经验的开发者&#xff0c;希望这篇博客对你有所帮助。 第一部分&#xff1a;Cookie 是什么&a…
阅读更多...
网络原理---封装和分用

网络原理---封装和分用

文章目录 什么是封装和分用&#xff1f;封装应用层传输层网络层数据链路层物理层 分用物理层数据链路层网络层传输层应用层 什么是封装和分用&#xff1f; 我们前面讲过协议会分层&#xff0c;每一层都有各自的功能。而在数据传输的过程中&#xff0c;得按照顺序把每一层协议都…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023