2.线程的六种状态

最新推荐文章于 2024-08-06 22:27:00 发布
最新推荐文章于 2024-08-06 22:27:00 发布
阅读量445 收藏
点赞数
分类专栏： # 线程 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43252908/article/details/110122753
版权

一、线程六种状态

**1. 初始(NEW)：**新创建了一个线程对象，但还没有调用start()方法。
2. 运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。
线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得CPU时间片后变为运行中状态（running）。
**3. 阻塞(BLOCKED)：**表示线程阻塞于锁。
**4. 等待(WAITING)：**进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
**5. 超时等待(TIMED_WAITING)：**该状态不同于WAITING，它可以在指定的时间后自行返回。
**6. 终止(TERMINATED)：**表示该线程已经执行完毕。

在这里插入图片描述
在这里插入图片描述

join()相当于插队，待此线程执行完成后，再执行其他线程，其他线程阻塞
yield()有点像礼让，但不一定礼让成功。让当前线程暂停，但不阻塞。将线程从运行转化为就绪状态，然后所有就绪进程在再争夺时间片。
interrupt() 不建议使用
在这里插入图片描述
在这里插入图片描述

二、状态详细说明

1. 初始状态(NEW)

实现Runnable接口和继承Thread可以得到一个线程类，new一个实例出来，线程就进入了初始状态。

2.1. 就绪状态(RUNNABLE之READY)

  1. 就绪状态只是说你资格运行，调度程序没有挑选到你，你就永远是就绪状态。 调用线程的start()方法，此线程进入就绪状态。
  2. 当前线程sleep()方法结束，其他线程join()结束，等待用户输入完毕，某个线程拿到对象锁，这些线程也将进入就绪状态。
  3. 当前线程时间片用完了，调用当前线程的yield()方法，当前线程进入就绪状态。 锁池里的线程拿到对象锁后，进入就绪状态。
  4. 当前线程时间片用完了，调用当前线程的yield()方法，当前线程进入就绪状态。
  5. 锁池里的线程拿到对象锁后，进入就绪状态。

2.2. 运行中状态(RUNNABLE之RUNNING)
线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一的一种方式。

3. 阻塞状态(BLOCKED)

阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态。

4. 等待(WAITING)

处于这种状态的线程不会被分配CPU执行时间，它们要等待被显式地唤醒，否则会处于无限期等待的状态。

5. 超时等待(TIMED_WAITING)

处于这种状态的线程不会被分配CPU执行时间，不过无须无限期等待被其他线程显示地唤醒，在达到一定时间后它们会自动唤醒。

6. 终止状态(TERMINATED)

  1. 当线程的run()方法完成时，或者主线程的main()方法完成时，我们就认为它终止了。这个线程对象也许是活的，但是它已经不是一个单独执行的线程。线程一旦终止了，就不能复生。
  2. 在一个终止的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常。

7.方法详解

1.start() 与 run()

start(): 启动一个线程，线程之间是没有顺序的，是按CPU分配的时间片来回切换的。
run(): 调用线程的run方法，就是普通的方法调用，虽然将代码封装到两个线程体中，可以看到线程中打印的线程名字都是main主线程，run()方法用于封装线程的代码，具体要启动一个线程来运行线程体中的代码(run()方法)还是通过start()方法来实现，调用run()方法就是一种顺序编程不是并发编程。

2.sleep() 与 interrupt()

sleep(long millis): 睡眠指定时间，程序暂停运行，睡眠期间会让出CPU的执行权，去执行其它线程，同时CPU也会监视睡眠的时间，一旦睡眠时间到就会立刻执行(因为睡眠过程中仍然保留着锁，有锁只要睡眠时间到就能立刻执行)。

  • sleep():睡眠指定时间，即让程序暂停指定时间运行，时间到了会继续执行代码，如果时间未到就要醒需要使用interrupt()来随时唤醒。

  • interrupt(): 唤醒正在睡眠的程序，调用interrupt()方法，会使得sleep()方法抛出InterruptedException异常，当sleep()方法抛出异常就中断了sleep的方法，从而让程序继续运行下去

3. wait() 与 notify()

wait、notify和notifyAll方法是Object类的final native方法。所以这些方法不能被子类重写，Object类是所有类的超类，因此在程序中可以通过this或者super来调用this.wait(), super.wait()

         wait(): 导致线程进入等待阻塞状态，会一直等待直到它被其他线程通过notify()或者notifyAll唤醒。该方法只能在同步方法中调用。如果当前线程不是锁的持有者，该方法抛出一个IllegalMonitorStateException异常。wait(long timeout): 时间到了自动执行，类似于sleep(long millis)
         notify(): 该方法只能在同步方法或同步块内部调用， 随机选择一个(注意：只会通知一个)在该对象上调用wait方法的线程，解除其阻塞状态
notifyAll(): 唤醒所有的wait对象
注意：

         Object.wait()和Object.notify()和Object.notifyall()必须写在synchronized方法内部或者synchronized块内部
让哪个对象等待wait就去通知notify哪个对象，不要让A对象等待，结果却去通知B对象，要操作同一个对象

4. sleep() 与 wait()

① Thread.sleep(long millis): 睡眠时不会释放锁 wait 释放锁
②sleep thread类 wait Object类
③sleep 可以用在任意地方，wait只能在同步代码块中
④sleep 必须捕获异常 wait 不需要捕获异常

5. wait() 与 interrupt()

wait(): 方法的作用是释放锁，加入到等待队列，当调用interrupt()方法后，线程必须先获取到锁后，然后才抛出异常InterruptedException 。注意： 在获取锁之前是不会抛出异常的，只有在获取锁之后才会抛异常

所有能抛出InterruptedException的方法都可以通过interrupt()来取消的

notify()和interrupt()区别:

从让正在wait的线程重新运行这一点来说，notify方法和intterrupt方法的作用有些类似，但仍有以下不同之处：

notify/notifyAll是java.lang.Object类的方法，唤醒的是该实例的等待队列中的线程，而不能直接指定某个具体的线程。notify/notifyAll唤醒的线程会继续执行wait的下一条语句，另外执行notify/notifyAll时线程必须要获取实例的锁

interrupte方法是java.lang.Thread类的方法，可以直接指定线程并唤醒，当被interrupt的线程处于sleep或者wait中时会抛出InterruptedException异常。执行interrupt()并不需要获取取消线程的锁。

总之notify/notifyAll和interrupt的区别在于是否能直接让某个指定的线程唤醒、执行唤醒是否需要锁、方法属于的类不同

6. interrupt()

interrupt方法只是改变了线程的“中断状态”而已，所谓中断状态是一个boolean值，表示线程是否被中断的状态。

假设Thread-0执行了sleep、wait、join中的一个方法而停止运行，在Thread-1中调用了interrupt方法，此时线程Thread-0的确会抛出InterruptedException异常，但这其实是sleep、wait、join中的方法内部会对线程的“中断状态”进行检查，如果中断状态为true,就会抛出InterruptedException异常。假如某个线程的中断状态为true，但线程体中却没有调用或者没有判断线程中断状态的值，那么线程则不会抛出InterruptedException异常。

isInterrupted() 检查中断状态
若指定线程处于中断状态则返回true,若指定线程为非中断状态，则反回false, isInterrupted() 只是获取中断状态的值，并不会改变中断状态的值。

interrupted()
检查中断状态并清除当前线程的中断状态。如当前线程处于中断状态返回true，若当前线程处于非中断状态则返回false, 并清除中断状态(将中断状态设置为false), 只有这个方法才可以清除中断状态，Thread.interrupted的操作对象是当前线程，所以该方法并不能用于清除其它线程的中断状态。

interrupt()与interrupted()：

  • interrupt()：打断线程，将中断状态修改为true
  • interrupted():不打断线程，获取线程的中断状态，并将中断状态设置为false

sleep与wait的区别

  • sleep在Thread类中，wait在Object类中
  • sleep不会释放锁，wait会释放锁
  • sleep使用interrupt()来唤醒，wait需要notify或者notifyAll来通知

7.join()

让当前线程加入父线程，加入后父线程会一直wait，直到子线程执行完毕后父线程才能执行。当我们调用某个线程的这个方法时，这个方法会挂起调用线程，直到被调用线程结束执行，调用线程才会继续执行。

将某个线程加入到当前线程中来，一般某个线程和当前线程依赖关系比较强，必须先等待某个线程执行完毕才能执行当前线程。一般在run()方法内使用

  • join() 和 join(long millis, int nanos) 最后都调用了 join(long millis)。

  • join(long millis, int nanos)和join(long millis)方法 都是synchronized。

  • join() 调用了join(0)，从源码可以看到join(0)不断检查当前线程是否处于Active状态。

  • join() 和 sleep() 一样，都可以被中断（被中断时，会抛出 InterrupptedException
    异常）；不同的是，join() 内部调用了wait()，会出让锁，而 sleep() 会一直保持锁。

8.yield()

交出CPU的执行时间，不会释放锁，让线程进入就绪状态，等待重新获取CPU执行时间

sleep(long millis) 与 yeid()

sleep(long millis): 需要指定具体睡眠的时间，不会释放锁，睡眠期间CPU会执行其它线程，睡眠时间到会立刻执行
yeid(): 交出CPU的执行权，不会释放锁，和sleep不同的时当再次获取到CPU的执行，不能确定是什么时候，而sleep是能确定什么时候再次执行。两者的区别就是sleep后再次执行的时间能确定，而yeid是不能确定的
yield会把CPU的执行权交出去，所以可以用yield来控制线程的执行速度，当一个线程执行的比较快，此时想让它执行的稍微慢一些可以使用该方法，想让线程变慢可以使用sleep和wait,但是这两个方法都需要指定具体时间，而yield不需要指定具体时间，让CPU决定什么时候能再次被执行，当放弃到下次再次被执行的中间时间就是间歇等待的时间

三、等待队列

调用obj的wait(), notify()方法前，必须获得obj锁，也就是必须写在synchronized(obj) 代码段内。
与等待队列相关的步骤和图
在这里插入图片描述

线程1获取对象A的锁，正在使用对象A。
线程1调用对象A的wait()方法。
线程1释放对象A的锁，并马上进入等待队列。
锁池里面的对象争抢对象A的锁。
线程5获得对象A的锁，进入synchronized块，使用对象A。
线程5调用对象A的notifyAll()方法，唤醒所有线程，所有线程进入同步队列。若线程5调用对象A的notify()方法，则唤醒一个线程，不知道会唤醒谁，被唤醒的那个线程进入同步队列。
notifyAll()方法所在synchronized结束，线程5释放对象A的锁。
同步队列的线程争抢对象锁，但线程1什么时候能抢到就不知道了。

四、同步队列状态

当前线程想调用对象A的同步方法时，发现对象A的锁被别的线程占有，此时当前线程进入同步队列。简言之，同步队列里面放的都是想争夺对象锁的线程。
当一个线程1被另外一个线程2唤醒时，1线程进入同步队列，去争夺对象锁。
同步队列是在同步的环境下才有的概念，一个对象对应一个同步队列。
线程等待时间到了或被notify/notifyAll唤醒后，会进入同步队列竞争锁，如果获得锁，进入RUNNABLE状态，否则进入BLOCKED状态等待获取锁。

五、几个方法的比较

Thread.sleep(long millis)，一定是当前线程调用此方法，当前线程进入TIMED_WAITING状态，但不释放对象锁，millis后线程自动苏醒进入就绪状态。作用：给其它线程执行机会的最佳方式。
Thread.yield()，一定是当前线程调用此方法，当前线程放弃获取的CPU时间片，但不释放锁资源，由运行状态变为就绪状态，让OS再次选择线程。作用：让相同优先级的线程轮流执行，但并不保证一定会轮流执行。实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。Thread.yield()不会导致阻塞。该方法与sleep()类似，只是不能由用户指定暂停多长时间。
thread.join()/thread.join(long millis)，当前线程里调用其它线程t的join方法，当前线程进入WAITING/TIMED_WAITING状态，当前线程不会释放已经持有的对象锁。线程t执行完毕或者millis时间到，当前线程一般情况下进入RUNNABLE状态，也有可能进入BLOCKED状态（因为join是基于wait实现的）。
obj.wait()，当前线程调用对象的wait()方法，当前线程释放对象锁，进入等待队列。依靠notify()/notifyAll()唤醒或者wait(long timeout) timeout时间到自动唤醒。
obj.notify()唤醒在此对象监视器上等待的单个线程，选择是任意性的。notifyAll()唤醒在此对象监视器上等待的所有线程。
LockSupport.park()/LockSupport.parkNanos(long nanos),LockSupport.parkUntil(long deadlines), 当前线程进入WAITING/TIMED_WAITING状态。对比wait方法,不需要获得锁就可以让线程进入WAITING/TIMED_WAITING状态，需要通过LockSupport.unpark(Thread thread)唤醒。

六、疑问

等待队列里许许多多的线程都wait()在一个对象上，此时某一线程调用了对象的notify()方法，那唤醒的到底是哪个线程？随机？队列FIFO？or sth else？Java文档就简单的写了句：选择是任意性的

七、sleep和wait的区别

在这里插入图片描述

参考文档：
添加链接描述

八、状态测试

package thread_;

public class StateDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
            System.out.println("end....");
        });

        Thread.State state= thread.getState();
        System.out.println(state);//new
        thread.start();
        state= thread.getState(); // runnable
        System.out.println(state);
        while(state!=Thread.State.TERMINATED){

            Thread.sleep(100);
            state= thread.getState();

            System.out.println(state);
        }
    }
}

在这里插入图片描述

线程终止之后，就不能再启动了。否则会报错

九、线程的终止

在这里插入图片描述

package thread_;

public class StopDemo implements Runnable{
    private boolean flag = true;
    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println("run...Thread " +i++);
        }
    }

    public void  stop(){
        this.flag = false;
    }

    public static void main(String[] args) {
        StopDemo stopDemo = new StopDemo();
        new  Thread(stopDemo).start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("main : " +i);
            if(i==650){
                stopDemo.stop();
                System.out.println("停止了");
            }
        }
    }
}
njl_0114
关注
专栏目录
Unet实现对数据集进行图片重建和去噪
03-28
Image_denoising_using_UNET 本教程包括使用Unet架构的图像去噪技术。 所以这里我用两种类型的噪声来训练模型，一种是泊松噪声，另一种是散斑噪声(伽玛分布)。 数据是由我生成的。 在训练模型后，我发现当将干净图像与带噪图像和预测图像进行比较时，PSNR和SSIM值略有增加。 在代码中，您还可以看到干净和预测图像的MSE。
基于改进Res-UNet网络的钢铁表面缺陷图像分割研究.docx
02-23
基于改进Res-UNet网络的钢铁表面缺陷图像分割研究.docx
UNET ResNet50网络结构 caffe版本
03-06
UNET ResNet50网络结构 caffe版本，
深度学习--图像分割UNet介绍及代码分析
最新发布
Young_Zn_Cu
08-06 1260
U-net 架构（以最低分辨率为 32x32 像素为例），每个蓝色框对应一个多通道特征图。通道数显示在框的顶部。x-y 大小位于框的左下边缘。白框表示复制的特征图。箭头表示不同的操作。深蓝色箭头：利用3×3的卷积核对图片进行卷积后，通过ReLU激活函数输出特征通道；灰色箭头：对左边下采样过程中的图片进行裁剪复制；红色箭头：通过最大池化对图片进行下采样，池化核大小为2×2；绿色箭头：反卷积，对图像进行上采样，卷积核大小为2×2；青色箭头：使用1×1的卷积核对图片进行卷积。
【小白】基于Resnet+Unet的图像分割模型（by Pytorch）
热门推荐
weixin_43842265的博客
07-18 4万+
文章目录（一）Unet1.概述2.代码实现（二）Resnet1.概述2.代码实现（三）Resnet+Unet代码详解1.为什么可以这么做？2.分部代码详解3.整体代码 （一）Unet 1.概述 1.Unet是目前应用最广泛的图像（语义）分割模型。它采用了encode（编码）+decode（解码）的结构，先对图像进行多次conv（+Bn+Relu）+pooling下采样，再进行upsample上采样...
【代码复现】ResUNet++进行语义分割（含图像切片预处理）
weixin_44883789的博客
08-26 4143
可能由于显卡内存不够的原因，导致尺寸很大的图片进行训练时，导致GPU显存不够的情况，一个简单的方法：对图片进行切片操作。对图片进行。
基于加权的Res-UNet注意力机制分割视网膜血管分割挑战
爱CV
01-27 7684
•小血管缺失:位于树枝末端的小血管有时甚至人眼也难以分辨。 •视盘区分割差:视盘区往往较亮，对比度较低，使得视网膜血管难以分割。 •无法维持结构关系:视网膜血管有类似于树木的分叉结构。但当血管太薄而无法探测时，这种结构很难维持。 •照明:光照不足或过度暴露，包括相机光源引起的光反射，会降低图像对比度，导致视网膜血管边界不清晰。 为了解决这些挑战，本文提出：加权的Res-UNet。模型建立在原始的UNet模型基础上，并增加了一个加权注意机制。使得模型学习更多的鉴别血管和非血管像素的特征，更好的维护视网膜血管
使用ResNet50与Res-UNET结合策略在Jupyter环境中对钢材缺陷进行深度学习预测及直观定位
qq_38334677的博客
08-21 450
在本指南中，我们首先介绍了使用ResNet50模型预测钢材中的缺陷的基本流程。随后，我们介绍了Res-UNET模型，这是一种专门用于图像分割的深度学习模型。加入残差连接的Res-UNET可以更好地捕捉图像中的细节信息，并为我们提供缺陷的精确位置。使用这些先进的模型，我们不仅可以自动化检测过程，还可以大大提高检测的准确性。在工业生产中，确保钢材质量至关重要。传统的质量控制方法依赖于人工检查，但随着深度学习技术的进步，我们现在可以使用复杂的模型如ResNet50和Res-UNET来自动预测和定位钢材中的缺陷。
An Improved Res-UNet Model for Tree Species Classification Using Airborne High-Resolution Images论文理解
kiko.c的博客
09-14 1878
该部分内容仅为自己学习所用，仅代表个人理解。 该论文是北京林业大学林学院张晓丽教授团队在树种分类深度学习模型上取得重要进展。张晓丽教授是北京林业大学林学院地图学与地理信息系统学科教授，研究方向主要为林业遥感与信息化、资源监测与信息化管理、地理信息技术集成与应用。联系方式为：邮箱：zhangxl@bjfu.edu.cn;电话: +86-010-62336227 (XL.Z.) 作者提出了一种基于深度学习的树分类方法。该方法将语义分割网络U-Net和特征提取网络ResNet组...
论文笔记：Spatial-Temporal Map Vehicle Trajectory Detection Using Dynamic Mode Decomposition and Res-UNe
qq_40206371的博客
02-27 2491
Spatial-Temporal Map Vehicle Trajectory Detection Using Dynamic Mode Decomposition and Res-UNet+ Neural Networks. 0 摘要 本文提出的方法，用于从高角度交通摄像机中提取车辆轨迹。 动态模式分解 (DMD) 方法通过将空间时间图 (STMap) 分解为稀疏前景和低秩背景来提取车辆线。通过采用两种流行的深度学习架构，为语义分割任务设计了一个名为 Res-UNet+ 的深度神...
当UNet遇见ResNet会发生什么？
小白学视觉
08-04 4315
点击上方“小白学视觉”，选择加"星标"或“置顶”重磅干货，第一时间送达1.前言这篇文章主要以几篇经典的分割论文为切入点，浅谈一下当Unet遇见ResNet会发生什么？2. UNet首先回顾一下UNet，UNet的结构如下图所示：UNet 网络结构「从UNet的网络结构我们会发现两个最主要的特点，一个是它的U型结构，一个是它的跳层连接。」 其中UNet的编码器一共有4次下采...
结合残差结构的Res-Unet及其代码实现
m0_46501089的博客
04-20 1万+
本博客主要为代码实现的小伙伴提供模板，具体的原理已经有好多文章啦，所以在这里我也就不啰嗦啦，只作简单介绍！ 1.残差结构 1.1 残差单元 与普通网络的串行结构相比，残差单元增加了跳跃映射，将输入与输出直接进行相加，补充卷积过程中损失的特征信息，这点与U-net的跳跃连接结构有点类似，不过Res中的跳跃连接做的是Add操作，而U-net的跳跃连接做的是Concatenate操作，还是有本质的不同，残差单元如图所示: 1.2 残差家族 根据层数的不同ResNet有以下的伐木累 由图中可以看出ResNet
论文：图像分割的U-Net系列方法
杨杨子江的博客
10-23 4732
膜拜大佬        &nbsp在图像分割任务特别是医学图像分割中，U-Net[1]无疑是最成功的方法之一，该方法在2015年MICCAI会议上提出，目前已达到四千多次引用。其采用的编码器（下采样）-解码器（上采样）结构和跳跃连接是一种非常经典的设计方法。目前已有许多新的卷积神经网络设计方式，但很多仍延续了U-Net...
Deep Residual U-Net (ResUNet)
爱CV
08-21 4436
Paper:https://arxiv.org/pdf/1711.10684.pdf ResUNet, a semantic segmentation model inspired by the deep residual learning and UNet. An architecture that take advantages from both(Residual and UNet) models. 1.1 Advantages The residual unit will ease the .
深度ResUnet与ResUnet++：新一代的语义分割神器
gitblog_00024的博客
06-08 652
深度ResUnet与ResUnet++：新一代的语义分割神器 项目地址:https://gitcode.com/rishikksh20/ResUnet 在这个数据驱动的时代，深度学习模型在图像处理领域展现出了强大的潜力，尤其是在语义分割任务中。今天，我们向您推荐一个基于PyTorch实现的开源项目——Deep ResUnet和ResUnet++。这两个模型源自于学术界的最新研究，旨在提高图像分割的...
深度学习| ResNet和ResUnet
qq_40306845的博客
03-18 2654
快速理解ResNet和RestUnet。
经典论文之（二）——Resnet
qq_43212927的博客
01-06 1378
Deep Residual Learning for Image Recognition》——用于图像识别的深度残差学习是由何凯明团队提出的，在当时获得分类任务，目标检测，图像分割第一名。该论文的四位作者何恺明、张祥雨、任少卿和孙剑如今在人工智能领域里都是响当当的名字。在本文中，提出的残差网络框架对后世影响深远。在本文做出的实验中，结果表明残差网络更容易优化，并且加深网络层数有助于提高正确率。在ImageNet数据集上，评估了深度高达152层的残差网——比VGG网深8倍[40]，但仍然具有较低的复杂性。
unet 网络结构
qq_40107571的博客
10-03 1万+
unet 网络结构
图像分割必备知识点 | Unet详解 理论+ 代码
忽逢桃林的博客
11-26 4万+
文章转自：微信公众号【机器学习炼丹术】。文章转载或者交流联系作者微信：cyx645016617 Unet其实挺简单的，所以今天的文章并不会很长。 喜欢的话可以参与文中的讨论、在文章末尾点赞、在看点一下呗。 0 概述 语义分割(Semantic Segmentation)是图像处理和机器视觉一个重要分支。与分类任务不同，语义分割需要判断图像每个像素点的类别，进行精确分割。语义分割目前在自动驾驶、自动抠图、医疗影像等领域有着比较广泛的应用。 上图为自动驾驶中的移动分割任务的分割结果，可以从一张图片中有效的识别
UNet 浅析
晓野豬
09-28 4万+
文章目录1. UNet网络结构2. UNet网络结构特点3. Skip Connection4. 医学图像分割数据集ISBI（果蝇电镜图）【参考】 1. UNet网络结构 2. UNet网络结构特点 （1）U型网络结构； （2）跳层连接（Skip connection）； 3. Skip Connection （1）在上采样过程中融合下采样过程中的特征图； （2）融合方式为concatenate，按特征图通道数进行叠加； （3）在实际中，融合的两张特征图尺寸可能不同，一般可采用裁剪和padding（UNe
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值