Java 并发编程知识总结【五】

news2024/12/26 3:12:50

6. 线程中断与 LockSupport

6.1 线程中断机制

大厂（蚂蚁金服）面试题：

image-20230101205547041

什么是中断？

首先，一个线程不应该由其他线程来强制中断或停止，而是应该由线程自己自行停止。所以，Thread.stop, Thread.suspend, Thread.resume 都已经被废弃了。

其次，在 Java 中没有办法立即停止一条线程，然而停止线程却显得尤为重要，如取消一个耗时操作。因此，Java 提供了一种用于停止线程的机制——中断。

**中断只是一种协作机制，Java没有给中断增加任何语法，中断的过程完全需要程序员自己实现。**若要中断一个线程，你需要手动调用该线程的 interrupt 方法，**该方法也仅仅是将线程对象的中断标识设成 true **；接着你需要自己写代码不断地检测当前线程的标识位，如果为 true ，表示别的线程要求这条线程中断，此时究竟该做什么需要你自己写代码实现。

每个线程对象中都有一个标识，用于表示线程是否被中断；该标识位为 true 表示中断，为 false 表示未中断；通过调用线程对象的interrupt 方法将该线程的标识位设为 true；可以在别的线程中调用，也可以在自己的线程中调用。

中断的相关 API 方法

image-20230101210251778

image-20230101210314188

如何使用中断标识停止线程？

在需要中断的线程中不断监听中断状态，一旦发生中断，就执行相应的中断处理业务逻辑。

方法：

  • 通过一个volatile变量实现
private static volatile boolean isStop = false;

public static void main(String[] args) {
    new Thread(() -> {
        while (true) {
            if (isStop) {
                System.out.println("-----isStop = true，程序结束。");
                break;
            }
            System.out.println("------hello isStop");
        }
    }, "t1").start();

    // 暂停几秒钟线程
    try {
        TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    new Thread(() -> isStop = true, "t2").start();
}
  • 通过 AtomicBoolean
private static AtomicBoolean atomicBoolean = new AtomicBoolean(false);

public static void main(String[] args) {
    new Thread(() -> {
        while (true) {
            if (atomicBoolean.get()) {
                System.out.println("-----atomicBoolean.get() = true，程序结束。");
                break;
            }
            System.out.println("------hello atomicBoolean");
        }
    }, "t1").start();

    // 暂停几秒钟线程
    try {
        TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    new Thread(() -> atomicBoolean.set(true), "t2").start();
}
  • 通过Thread 类自带的中断 api 方法实现

实例方法interrupt()，没有返回值

image-20230101213640013

源码：

public void interrupt() {
    if (this != Thread.currentThread()) {
        checkAccess();

        // thread may be blocked in an I/O operation
        synchronized (blockerLock) {
            Interruptible b = blocker;
            if (b != null) {
                interrupted = true;
                interrupt0();  // inform VM of interrupt   这里调用 OS 底层，即 调用 C++
                b.interrupt(this);
                return;
            }
        }
    }
    interrupted = true;
    // inform VM of interrupt
    interrupt0();
}

实例方法isInterrupted()，返回布尔值

image-20230101213726635

image-20230101220153811

public static void main(String[] args) {
    Thread t1 = new Thread(() -> {
        while (true) {
            if (Thread.currentThread().isInterrupted()) {
                System.out.println("-----isInterrupted() = true，程序结束。");
                break;
            }
            System.out.println("------hello Interrupt");
        }
    }, "t1");
    t1.start();
    try {
        TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    // 修改t1线程的中断标志位为true
    new Thread(t1::interrupt, "t2").start();
}

当前线程的中断标识为true，是不是就立刻停止（重点）？

我们首先来继续说下 interrupt() 方法

当对一个线程，调用 interrupt() 时：

  1. 如果线程处于正常活动状态，那么会将该线程的中断标志设置为 true，仅此而已。被设置中断标志的线程将继续正常运行，不受影响。所以， interrupt() 并不能真正的中断线程，需要被调用的线程自己进行配合才行。
  2. 如果线程处于被阻塞状态（例如处于 sleep, wait, join 等状态），在别的线程中调用当前线程对象的 interrupt 方法，那么线程将立即退出被阻塞状态，并抛出一个 InterruptedException 异常。

证明代码：

public static void main(String[] args) {
    // 中断为true后，并不是立刻stop程序
    Thread t1 = new Thread(() -> {
        for (int i = 1; i <= 600; i++) {
            System.out.println("------i: " + i);
        }
        System.out.println("t1.interrupt()调用之后02： " + Thread.currentThread().isInterrupted());
    }, "t1");
    t1.start();
    System.out.println("t1.interrupt()调用之前,t1线程的中断标识默认值： " + t1.isInterrupted());
    try {
        TimeUnit.MILLISECONDS.sleep(3);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    // 实例方法interrupt()仅仅是设置线程的中断状态位设置为true，不会停止线程
    t1.interrupt();
    // 活动状态,t1线程还在执行中
    System.out.println("t1.interrupt()调用之后01： " + t1.isInterrupted());
    try {
        TimeUnit.MILLISECONDS.sleep(3000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    // 非活动状态,t1线程不在执行中，已经结束执行了。
    System.out.println("t1.interrupt()调用之后03： " + t1.isInterrupted());
}
// 结果
------i: 1
------i: 2
------i: 3
t1.interrupt()调用之前,t1线程的中断标识默认值： false
...
------i: 445
t1.interrupt()调用之后01： true   // 从这里已经可以看出 当我们将 t1 线程 interrupt 之后，for 循环还在继续，说明线程没有停止 此时 t1 还处于活动状态 此时的 isInterrupted 为 true
------i: 446
...
------i: 600
t1.interrupt()调用之后02： true // 调用 interrupt 之后， 线程中断状态位为 true
t1.interrupt()调用之后03： false // 这里为 false 是因为 线程已经结束，停止了，此时应恢复原始状态 false （JDK17不同）

代码继续，问题发现：

public static void main(String[] args) {
    Thread t1 = new Thread(() -> {
        while (true) {
            if (Thread.currentThread().isInterrupted()) {
                System.out.println("-----isInterrupted() = true，程序结束。");
                break;
            }
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("------hello Interrupt");
        }
    }, "t1");
    t1.start();
    try {
        TimeUnit.SECONDS.sleep(3);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    new Thread(t1::interrupt, "t2").start();
}
// 此时运行程序后会发现 程序会报 InterruptedException 异常，并且 程序无法停止 继续打印 ------hello Interrupt

why???

我们上面看了 interrupt 方法的源码，在注释中解释了，当中断 wait、join、sleep等阻塞方法时，该线程的中断标识将被清除设置为 false，并且抛出 InterruptedException 异常，并且在 sleep 的源码中也有相应的解释

image-20230101214125367

image-20230101221601206

如何改进（重点）：

public static void main(String[] args) {
    Thread t1 = new Thread(() -> {
        while (true) {
            if (Thread.currentThread().isInterrupted()) {
                System.out.println("-----isInterrupted() = true，程序结束。");
                break;
            }
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                // 线程的中断标志位为false,无法停下，需要再次掉interrupt()设置true
                Thread.currentThread().interrupt();
                e.printStackTrace();
            }
            System.out.println("------hello Interrupt");
        }
    }, "t1");
    t1.start();
    try {
        TimeUnit.SECONDS.sleep(3);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    new Thread(t1::interrupt, "t2").start();
}
// 我们在 catch 中再次将 中断标识 设置为 true 这样就不会导致无限循环了

总结：中断只是一种协同机制，修改中断标识位仅此而已，不是立刻 stop 打断

静态方法Thread.interrupted()

image-20230101222143780

public static void main(String[] args) {
    System.out.println(Thread.currentThread().getName() + "---" + Thread.interrupted());
    System.out.println(Thread.currentThread().getName() + "---" + Thread.interrupted());
    System.out.println("111111");
    Thread.currentThread().interrupt();///----false---> true
    System.out.println("222222");
    System.out.println(Thread.currentThread().getName() + "---" + Thread.interrupted());
    System.out.println(Thread.currentThread().getName() + "---" + Thread.interrupted());
}
// 结果
main---false
main---false
111111
222222
main---true
main---false

和普通方法对比

image-20230101222314033

方法的注释也清晰的表达了“中断状态将会根据传入的 ClearInterrupted 参数值确定是否重置”。

所以，静态方法 interrupted将会清除中断状态（传入的参数 ClearInterrupted 为 true），实例方法 isInterrupted 则不会（传入的参数 ClearInterrupted 为 false ）

总结线程中断相关的方法：：

interrupt()方法是一个实例方法，它通知目标线程中断，也就是设置目标线程的中断标志位为true，中断标志位表示当前线程已经被中断了

isInterrupted()方法也是一个实例方法，它判断当前线程是否被中断（通过检查中断标志位）并获取中断标志

Thread类的静态方法interrupted()，返回当前线程的中断状态(boolean类型)且将当前线程的中断状态设为false，此方法调用之后会清除当前线程的中断标志位的状态（将中断标志置为false了），返回当前值并清零置false

6.2 线程等待唤醒机制

这一节是线程通信的续接，会更深入

LockSupport 是什么

image-20230103153605014

LockSupport 是用来创建锁和其他同步类的基本线程阻塞原语。LockSupport 中的 park() 和 unpark() 的作用分别是阻塞线程和解除阻塞线程

LockSupport 类使用了一种名为 Permit（许可）的概念来做到阻塞和唤醒线程的功能， 每个线程都有一个许可(permit)，
permit 只有两个值1和零，默认是零。

可以把许可看成是一种(0,1)信号量（Semaphore），但与 Semaphore 不同的是，许可的累加上限是1。

LockSupport 的主要方法：

park() /park(Object blocker) ：阻塞当前线程/阻塞传入的具体线程

permit 默认是零，所以一开始调用 park() 方法，当前线程就会阻塞，直到别的线程将当前线程的 permit 设置为1时，park 方法会被唤醒，然后会将 permit 再次设置为零并返回。

unpark(Thread thread) ：唤醒处于阻塞状态的指定线程

调用 unpark(thread) 方法后，就会将 thread 线程的许可 permit 设置成1(注意多次调用unpark方法，不会累加，permit值还是1)会自动唤醒 thread 线程，即之前阻塞中的 LockSupport.park()方法会立即解除阻塞。

三种让线程等待唤醒的方法：

  1. 使用 Object 中的 wait() 方法让线程等待，使用 Object 中的 notify() 方法唤醒线程
  2. 使用 JUC 包中 Condition 的 await() 方法让线程等待，使用 signal() 方法唤醒线程
  3. LockSupport 类可以阻塞当前线程以及唤醒指定被阻塞的线程

方式一：

正常情况：

public static void main(String[] args) {
    new Thread(() -> {
        synchronized (objectLock) {
            System.out.println(Thread.currentThread().getName() + "\t" + "---come in");
            try {
                objectLock.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "\t" + "---被唤醒");
        }
    }, "t1").start();

    new Thread(() -> {
        synchronized (objectLock) {
            objectLock.notify();
            System.out.println(Thread.currentThread().getName() + "\t" + "---发出通知");
        }
    }, "t2").start();
}
// 结果
t1	---come in
t2	---发出通知
t1	---被唤醒

异常情况1，取消使用 synchronized 关键字。即 wait 方法和 notify 方法，两个都去掉同步代码块:

// 结果
Exception in thread "t2" java.lang.IllegalMonitorStateException: current thread is not owner
	at java.base/java.lang.Object.notify(Native Method)
	at com.lt.juc.interrupt.LockSupportDemo.lambda$main$1(LockSupportDemo.java:36)
	at java.base/java.lang.Thread.run(Thread.java:833)
Exception in thread "t1" java.lang.IllegalMonitorStateException: current thread is not owner
	at java.base/java.lang.Object.wait(Native Method)
	at java.base/java.lang.Object.wait(Object.java:338)
	at com.lt.juc.interrupt.LockSupportDemo.lambda$main$0(LockSupportDemo.java:26)
	at java.base/java.lang.Thread.run(Thread.java:833)

异常情况2，将 notify 放在 wait 方法前面:

public static void main(String[] args) {
    new Thread(() -> {
        //暂停几秒钟线程
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (objectLock) {
            System.out.println(Thread.currentThread().getName() + "\t" + "---come in");
            try {
                objectLock.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "\t" + "---被唤醒");
        }
    }, "t1").start();

    new Thread(() -> {
        synchronized (objectLock) {
            objectLock.notify();
            System.out.println(Thread.currentThread().getName() + "\t" + "---发出通知");
        }
    }, "t2").start();
}
// 结果 可以发现 程序还在运行，被阻塞，无法唤醒
t2	---发出通知
t1	---come in

总结

  • wait 和 notify 方法必须要在同步块或者方法里面，且成对出现使用
  • 先 wait 后 notify 才OK

方式二：

正常情况：

static Lock lock = new ReentrantLock();
static Condition condition = lock.newCondition();

public static void main(String[] args) {
    new Thread(() -> {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t" + "---come in");
            condition.await();
            System.out.println(Thread.currentThread().getName() + "\t" + "---被唤醒");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }, "t1").start();

    new Thread(() -> {
        lock.lock();
        try {
            condition.signal();
            System.out.println(Thread.currentThread().getName() + "\t" + "---发出通知");
        } finally {
            lock.unlock();
        }
    }, "t2").start();
}
// 结果
t1	---come in
t2	---发出通知
t1	---被唤醒

异常情况1，去掉 lock/unlock：

// 结果
Exception in thread "t2" java.lang.IllegalMonitorStateException at java.base/java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.signal(AbstractQueuedSynchronizer.java:1473) at com.lt.juc.interrupt.LockSupportDemo.lambda$main$1(LockSupportDemo.java:42)
at java.base/java.lang.Thread.run(Thread.java:833)
Exception in thread "t1" java.lang.IllegalMonitorStateException at java.base/java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.enableWait(AbstractQueuedSynchronizer.java:1516) at java.base/java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:1611) at com.lt.juc.interrupt.LockSupportDemo.lambda$main$0(LockSupportDemo.java:30)
	at java.base/java.lang.Thread.run(Thread.java:833)

异常情况2，先 signal 后 await

static Lock lock = new ReentrantLock();
static Condition condition = lock.newCondition();

public static void main(String[] args) {
    new Thread(() -> {
        // 暂停几秒钟线程
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t" + "---come in");
            condition.await();
            System.out.println(Thread.currentThread().getName() + "\t" + "---被唤醒");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }, "t1").start();

    new Thread(() -> {
        lock.lock();
        try {
            condition.signal();
            System.out.println(Thread.currentThread().getName() + "\t" + "---发出通知");
        } finally {
            lock.unlock();
        }
    }, "t2").start();
}
// 结果 可以发现 程序还在运行，被阻塞，无法唤醒
t2	---发出通知
t1	---come in

结论：

  • Condtion 中的线程等待和唤醒方法之前，需要先获取锁
  • 一定要先 await 后 signal，不要反了

由上述两种方法可知，Object 和 Condition 使用的限制条件：

  • 线程先要获得并持有锁，必须在锁块( synchronized或 lock)中
  • 必须要先等待后唤醒，线程才能够被唤醒

方法三：

public static void main(String[] args) {
    Thread t1 = new Thread(() -> {
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "\t" + "---come in");
        LockSupport.park();
        System.out.println(Thread.currentThread().getName() + "\t" + "---被唤醒");
    }, "t1");
    t1.start();

    new Thread(() -> {
        LockSupport.unpark(t1);
        System.out.println(Thread.currentThread().getName() + "\t" + "---发出通知");
    }, "t2").start();
}
// 结果 可以发现使用 LockSupport 方法 无锁块要求 并且 唤醒等待顺序也无要求 但是切记，permit 的值最多为1
t2	---发出通知
t1	---come in
t1	---被唤醒

public static void main(String[] args) {
    Thread t1 = new Thread(() -> {
        System.out.println(Thread.currentThread().getName() + "\t" + "---come in");
        LockSupport.park();
        LockSupport.park();
        System.out.println(Thread.currentThread().getName() + "\t" + "---被唤醒");
    }, "t1");
    t1.start();

    new Thread(() -> {
        LockSupport.unpark(t1);
        LockSupport.unpark(t1);
        System.out.println(Thread.currentThread().getName() + "\t" + "---发出通知");
    }, "t2").start();
}
// 结果 我们使用了 2次 park 和2次 unpark 但是程序还是被阻塞 就是因为 许可证 permit 最大为1 
t1	---come in
t2	---发出通知

更多文章在我的语雀平台：https://www.yuque.com/ambition-bcpii/muziteng

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

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

相关文章

Exynos_4412——中断控制器

Exynos_4412——中断控制器

目录 一、中断控制器 中断控制器的作用&#xff1a; 二、Exynos_4412下的中断控制器 它支持三种类型的中断 可以编程设置&#xff1a; 三、中断控制器详解 四、中断控制器编程 一、中断控制器 外设产生的中断信号&#xff0c;先要经过中断控制器&#xff0c;中断是异常…
阅读更多...
如何解决软件项目管理中的冲突？

如何解决软件项目管理中的冲突？

1、项目干系人间的良好沟通 项目干系人之间保持良好的沟通交流&#xff0c;是减少项目管理中冲突的重要手段。甲乙双方签订合同后&#xff0c;为保障项目的成功&#xff0c;在项目发生矛盾和困难时&#xff0c;需要双方相互理解和沟通&#xff0c;共同协商解决问题。 为了及时解…
阅读更多...
Git（八） - IDEA 集成 GitHub

Git（八） - IDEA 集成 GitHub

一、设置 GitHub 账号 二、分享工程到 GitHub 来到GitHub中发现已经帮我们创建好了git-test的远程仓库。 三、push 推送本地库到远程库 注意&#xff1a;push是将本地库代码推送到远程库&#xff0c;如果本地库代码跟远程库代码版本不一致&#xff0c; push的操作是会被拒绝的…
阅读更多...
go 性能分析pprof和trace

go 性能分析pprof和trace

runtime/pprof&#xff1a;采集程序&#xff08;非 Server&#xff09;的运行数据进行分析&#xff0c;用于可结束的代码块&#xff0c;如一次编解码操作等net/http/pprof&#xff1a;采集 HTTP Server 的运行时数据进行分析。用于不可结束的代码块&#xff0c;如 web 应用等 使…
阅读更多...
​工程师如何对待开源

​工程师如何对待开源

工程师如何对待开源 本文是笔者作为一个在知名科技企业内从事开源相关工作超过 20 年的工程师&#xff0c;亲身经历或者亲眼目睹很多工程师对待开源软件的优秀实践&#xff0c;也看到了很多 Bad Cases&#xff0c;所以想把自己的一些心得体会写在这里&#xff0c;供工程师进行…
阅读更多...
linux的shell的概述

linux的shell的概述

Shell 教程 Shell 是一个用 C 语言编写的程序&#xff0c;它是用户使用 Linux 的桥梁。Shell 既是一种命令语言&#xff0c;又是一种程序设计语言。 Shell 是指一种应用程序&#xff0c;这个应用程序提供了一个界面&#xff0c;用户通过这个界面访问操作系统内核的服务。 Ke…
阅读更多...
各种颜色的代码

各种颜色的代码

颜色代码对照表如下&#xff1a; 关于16进制颜色代码&#xff1a; 这有必要了解一颜色系统的概念&#xff1a; RGB&#xff1a;RGB色彩模式是工业界的一种颜色标准&#xff0c;是通过对红(R)、绿(G)、蓝(B)三个颜色通道的变化以及它们相互之间的叠加来得到各式各样的颜色的&a…
阅读更多...
MySQL的一些有意思的指令和函数

MySQL的一些有意思的指令和函数

这个里面我准备记录一些比较有意思的MySQL的指令和函数&#xff0c;当然使用函数的时候我们要注意&#xff0c;会不会因为函数导致不走索引&#xff0c;走全表扫描的情况。 因为对索引字段做函数操作&#xff0c;可能会破坏索引值的有序性&#xff0c;因此优化器就决定放弃走树…
阅读更多...
文本分类（LSTM+PyTorch）

文本分类（LSTM+PyTorch）

本文的配套代码已上传至github&#xff0c;链接在文末&#xff0c;同时附带中文数据集。 一、传统方法的基本步骤 预处理&#xff1a;首先进行分词&#xff0c;然后是除去停用词&#xff1b;将文本表示成向量&#xff0c;常用的就是文本表示向量空间模型&#xff1b;进行特征…
阅读更多...
回调函数、qsort函数、sort函数与lambda表达式

回调函数、qsort函数、sort函数与lambda表达式

目录 目录 1、回调函数 2、sort函数 3、lambda表达式 4、qsort与sort函数使用lambda表达式 1、回调函数 回调函数就是一个通过函数指针调用的函数。如果你把函数的指针&#xff08;地址&#xff09;作为参数传递给另一 个函数&#xff0c;当这个指针被用来调用其所指向的函…
阅读更多...
凝心聚力 开源共建 | 统信软件参与成立OpenKunlun开源固件社区

凝心聚力 开源共建 | 统信软件参与成立OpenKunlun开源固件社区

11月22日&#xff0c;统信软件携手国内固件厂商、处理器厂商、外设板卡厂商等数十家产业同仁参与共建的OpenKunlun开源固件社区正式成立&#xff01; OpenKunlun社区是在自愿、开源、平等和协作的基础上&#xff0c;由基础软硬件企业、高等院校、个人开发者共同参与的非营利性开…
阅读更多...
STM32——STM32中断系统与EXTI外部中断

STM32——STM32中断系统与EXTI外部中断

文章目录一、中断系统二、STM32中断系统三、NVIC&#xff08;嵌套中断向量控制器&#xff09;NVIC基本结构NVIC优先级分组四、EXTI&#xff08;外部中断&#xff09;EXTI简介EXTI基本结构AFIO复用IO口EXTI框图五、对射式红外传感器计次电路设计关键函数EXTI库函数文件&#xff…
阅读更多...
SpringMVC与SpringBoot响应请求的流程

SpringMVC与SpringBoot响应请求的流程

SpringMVC是基于Servlet的MVC模型&#xff0c;Model&#xff1a;一个或多个javabean对象&#xff0c;用于存储数据和业务逻辑&#xff1b;View&#xff1a;一个或多个jsp页面&#xff0c;拿到控制器提交的数据为模型提供数据显示&#xff1b;Controller&#xff1a;一个或多个s…
阅读更多...
【消息中间件】RabbitMQ的工作模式

【消息中间件】RabbitMQ的工作模式

前 言 &#x1f349; 作者简介&#xff1a;半旧518&#xff0c;长跑型选手&#xff0c;立志坚持写10年博客&#xff0c;专注于java后端 ☕专栏简介&#xff1a;深入、全面、系统的介绍消息中间件 &#x1f330; 文章简介&#xff1a;本文将介绍RabbitMQ的工作模式 &#x1f353…
阅读更多...
cubeIDE开发， stm32的CRC计算CubeMX配置及HAL库底层实现分析

cubeIDE开发， stm32的CRC计算CubeMX配置及HAL库底层实现分析

一、stm32的CRC 1.1 CRC的简介及MCU关联说明 STM32的CRC(Cyclic Redundancy Check&#xff0c;循环冗余校验)计算单元使用一个固定的多项式发生器&#xff0c;从一个32位的数据字产生一个CRC码。在业务开发应用中&#xff0c;会基于CRC的技术用于验证数据传输或存储完整性。在E…
阅读更多...
【python基础_05】面向对象1_对象和类、魔术方法

【python基础_05】面向对象1_对象和类、魔术方法

文章目录1. 类和对象1.1 使用对象组织数据的模版1.2 成员变量和成员方法1.3 实现代码2. 内置方法&#xff08;魔术方法&#xff09;2.1 构造方法&#xff1a; __init__()2.2 __call__()2.3 __len__()2.3 __str__()2.4 __getitem__()2.5 __setitem__()2.6 __delitem__()2.7 __lt…
阅读更多...
【从零开始学习深度学习】35. 门控循环神经网络之门控循环单元（gated recurrent unit，GRU）介绍、Pytorch实现GRU并进行训练预测

【从零开始学习深度学习】35. 门控循环神经网络之门控循环单元（gated recurrent unit，GRU）介绍、Pytorch实现GRU并进行训练预测

在循环神经网络中&#xff0c;当时间步数较大或者时间步较小时&#xff0c;循环神经网络的梯度较容易出现衰减或爆炸。上一篇文章中介绍的裁剪梯度可以应对梯度爆炸&#xff0c;但无法解决梯度衰减的问题。因此&#xff0c;循环神经网络在实际中较难捕捉时间序列中时间步距离较…
阅读更多...
Elastic-Job分布式任务调度（1）：概述

Elastic-Job分布式任务调度（1）：概述

1 什么是任务调度 我们可以先思考一下下面业务场景的解决方案&#xff1a; 某电商系统需要在每天上午10点&#xff0c;下午3点&#xff0c;晚上8点发放一批优惠券。某银行系统需要在信用卡到期还款日的前三天进行短信提醒。某财务系统需要在每天凌晨0:10结算前一天的财务数据…
阅读更多...
【自学Python】Linux安装Python

【自学Python】Linux安装Python

Linux安装Python Python下载 Python下载地址 https://www.python.org/ftp/python/3.7.4/Python-3.7.4.tar.xzPython下载 我们在 Linux 终端中&#xff0c;直接使用 wget 命令&#xff0c;下载 Linux 版 Python 的安装包&#xff0c;我们在终端输入以下命令&#xff1a; wg…
阅读更多...
PAT乙级｜1094 谷歌的招聘

PAT乙级｜1094 谷歌的招聘

题源https://pintia.cn/problem-sets/994805260223102976/exam/problems/1071785997033074688 提交1&#xff1a;一个用例没过 提交2&#xff1a;AC 错因&#xff1a;输出需为字符串&#xff0c;例如在 200236 中找 4 位素数&#xff0c;解是0023 关键&#xff1a;第33行代码…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023