4. LockSupport与线程中断

文章目录

  • 引言
    • LockSupport
    • 线程中断机制
      • 什么是中断机制?
      • 说说一下 java.lang.Thread 类下的三个方法的区别
  • 线程中断机制
    • 中断机制相关 API 三个方法的说明
      • public void interrupt()
      • public static boolean interrupted()
      • public boolean isInterrupted()
    • 经典面试题中的中断机制考点
      • 如何停止,中断运行中的线程
      • API
      • 当前线程的中断标志位为 true,是不是线程就立刻停止?
      • 静态方法 Thread.interrupted(),谈谈你的理解
    • 小结
  • LockSupport
    • 是什么?
    • 线程等待唤醒机制
      • 3 种让线程等待和唤醒的方法
      • Object 类中 wait 和 notify 方法实现线程等待和唤醒
        • 正常情况,均在同步监视器中执行 wait 与 notify 方法,先执行 wait 方法后执行 notify 方法
        • 去除同步监视器 synchronized 的情况
        • 正常情况下,将 notify 先于 wait 执行
        • 结论
      • Condition 接口中的 await 后的 signal 方法实现线程的等待和唤醒
      • Object 类和 Condition 接口实现的限制
      • LockSupport 类中的 park 等待与 unpark 唤醒
      • LockSupport 与 Object 和 Condition 先比的优点

引言

LockSupport

image.png

线程中断机制

什么是中断机制?

  • 一个线程不应该由其他线程来强制中断或停止,应该由线程自己去停止
    • Thread.stop,Thread.suspend,Thread.resume 均已被弃用
  • Java 提供了一种协作协商机制——中断,也称为中断标识协商机制
    • 中断只是一种协商机制,Java 中没有给中断增加任何语法,中断过程完全需要程序员自己实现
    • 若要中断一个线程,需要手动调用 interrupt 方法,该方法将线程对象的中断标识设成 true,之后编写代码不断检测当前线程的标志位
      • 若为 true,表示别的线程请求被该线程中断,中断后代码由程序员实现
  • 每个线程对象均有一个中断标志位,用于表示线程是否被中断,该标志位为 true 表示中断,为 false 表示未中断
    • 通过调用线程对象 interrupt 方法将该线程的标志位设为 true,可以在别的线程中调用,也可以在自己的线程中调用

说说一下 java.lang.Thread 类下的三个方法的区别

image.png

  • 如何中断一个线程?
  • 如何停止一个线程?

线程中断机制

中断机制相关 API 三个方法的说明

image.png

public void interrupt()

  • 实例方法
  • 仅仅设置了线程状态中断状态为 true,发起一个协商,并不会立刻停止线程

如果当前线程没有中断它自己（这在任何情况下都是允许的），则该线程的 checkAccess 方法就会被调用，这可能抛出 SecurityException。
如果线程在调用 Object 类的 wait()、wait(long) 或 wait(long, int) 方法，或者该类的 join()、join(long)、join(long, int)、sleep(long) 或 sleep(long, int) 方法过程中受阻，则其中断状态将被清除，它还将收到一个 InterruptedException。
如果该线程在可中断的通道上的 I/O 操作中受阻，则该通道将被关闭，该线程的中断状态将被设置并且该线程将收到一个 ClosedByInterruptException。
如果该线程在一个 Selector 中受阻，则该线程的中断状态将被设置，它将立即从选择操作返回，并可能带有一个非零值，就好像调用了选择器的 wakeup 方法一样。
如果以前的条件都没有保存，则该线程的中断状态将被设置。
中断一个不处于活动状态的线程不需要任何作用。
抛出： SecurityException - 如果当前线程无法修改该线程

public static boolean interrupted()

  • 静态方法
  • 首次调用返回线程状态,第二次调用将线程状态置为 false,并返回 fasle

测试当前线程是否已经中断。线程的_中断状态_ 由该方法清除。换句话说，如果连续两次调用该方法，则第二次调用将返回 false（在第一次调用已清除了其中断状态之后，且第二次调用检验完中断状态前，当前线程再次中断的情况除外）。
线程中断被忽略，因为在中断时不处于活动状态的线程将由此返回 false 的方法反映出来。
**返回：**如果当前线程已经中断，则返回 true；否则返回 false。

public boolean isInterrupted()

  • 实例方法
  • 判断当前线程是否被中断(通过检查中断标志位)

测试线程是否已经中断。线程的_中断状态_ 不受该方法的影响。
线程中断被忽略，因为在中断时不处于活动状态的线程将由此返回 false 的方法反映出来。
**返回：**如果该线程已经中断，则返回 true；否则返回 false。

经典面试题中的中断机制考点

如何停止,中断运行中的线程

  • 通过一个 volatile 变量实现
    static volatile boolean isStop = false;
    private static void m1_volatile() {
        new Thread(() -> {
            while (true) {
                if (isStop) {
                    System.out.println(Thread.currentThread().getName() + "\t isStop被修改为true，程序停止");
                    break;
                }
                System.out.println("t1 -----hello volatile");
            }
        }, "t1").start();

        //暂停毫秒
        try {
            TimeUnit.MILLISECONDS.sleep(20);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            isStop = true;
        }, "t2").start();
    }
  • 运行上述 demo

image.png

  • 通过 AtomicBoolean
    • 原子布尔型,该变量的操作无需加锁
    static AtomicBoolean atomicBoolean = new AtomicBoolean(false);
    private static void m2_atomicBoolean() {
        new Thread(() -> {
            while (true) {
                if (atomicBoolean.get()) {
                    System.out.println(Thread.currentThread().getName() + "\t atomicBoolean被修改为true，程序停止");
                    break;
                }
                System.out.println("t1 -----hello atomicBoolean");
            }
        }, "t1").start();

        //暂停毫秒
        try {
            TimeUnit.MILLISECONDS.sleep(20);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            atomicBoolean.set(true);
        }, "t2").start();
    }
  • 效果

image.png

  • 通过 Thread 类自带的中断 api 实例方法实现
        Thread t1 = new Thread(() -> {
            while (true) {
                if (Thread.currentThread().isInterrupted()) {
                    System.out.println(Thread.currentThread().getName() + "\t isInterrupted()被修改为true，程序停止");
                    break;
                }
                System.out.println("t1 -----hello interrupt api");
            }
        }, "t1");
        t1.start();

        System.out.println("-----t1的默认中断标志位：" + t1.isInterrupted());

        //暂停毫秒
        try {
            TimeUnit.MILLISECONDS.sleep(20);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //t2向t1发出协商，将t1的中断标志位设为true希望t1停下来
        new Thread(() -> {
            t1.interrupt();
        }, "t2").start();
        //t1.interrupt(); //main线程中断
  • 效果

image.png

API

核心思想:在需要中断的线程中不断监听中断状态,一旦发生中断,就执行相应的中断处理业务逻辑 stop 线程

  • 实例方法
    • interrupt(),没有返回值
    • interrupted,没有返回值
  • 源码分析(interrupt)

image.png

  • Just to set the interrupt flag(只是为了设置中断标志)

image.png

  • interrupt0()为 native 方法,交由 OS 进行调度
  • 源码分析(isInterrupted)

image.png
image.png

当前线程的中断标志位为 true,是不是线程就立刻停止?

     public static void main(String[] args) {
        //实例方法interrupt()仅仅是设置线程的中断状态位设置为true，不会停止线程
        Thread t1 = new Thread(() -> {
            for (int i = 1; i <= 300; i++) {
                System.out.println("-----: " + i);
            }
            System.out.println("t1线程调用interrupt()后的的中断标识02：" + Thread.currentThread().isInterrupted());
        }, "t1");
        t1.start();

        System.out.println("t1线程默认的中断标识：" + t1.isInterrupted());//false

        //暂停毫秒
        try {
            TimeUnit.MILLISECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t1.interrupt();//true
        System.out.println("t1线程调用interrupt()后的的中断标识01：" + t1.isInterrupted());//true

        try {
            TimeUnit.MILLISECONDS.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("t1线程调用interrupt()后的的中断标识03：" + t1.isInterrupted());//????---false中断不活动的线程不会产生任何影响。
    }
  • 运行结果
t1线程默认的中断标识：false 									//活跃的线程默认中断标志位为false
-----: 1
-----: 2
-----: 3
...
-----: 132
t1线程调用interrupt()后的的中断标识01：true  	//interrupt方法仅修改中断标志位
-----: 133
-----: 134
...
-----: 300
t1线程调用interrupt()后的的中断标识02：true 	//再次监听线程中断标志位
//对于一个不活跃的线程,调用interrupt方法不产生任何运行,可以理解为恢复中断标志位默认值
t1线程调用interrupt()后的的中断标识03：false	
//线程结束
  • 案例二
    • 正常启动,正常中断
public static void main(String[] args) {
    Thread t1 = new Thread(() -> {
        while (true) {
            if (Thread.currentThread().isInterrupted()) {
                System.out.println(Thread.currentThread().getName() + "\t " +
                                   "中断标志位：" + Thread.currentThread().isInterrupted() + " 程序停止");
                break;
            }

            System.out.println("-----hello InterruptDemo3");
        }
    }, "t1");
    t1.start();

    //暂停几秒钟线程
    try {
        TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    new Thread(() -> t1.interrupt(), "t2").start();
}
  • 效果,中断之前一直执行

image.png

  • 在调用 sleep()方法过程中被中断.重置中断标志位,抛出 InteruptedException 异常
    • 此时中断标志位为 false,线程正常执行,where(true)…

image.png

  • 效果

image.png

  • 解决方案,在 catch 块中,再次调用 interrupt 方法复位中断标志位
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();//为什么要在异常处，再调用一次？？
                    e.printStackTrace();
                }
  • interupt()源码

image.png

静态方法 Thread.interrupted(),谈谈你的理解

image.png

  • demo
     public static void main(String[] args) {
        //测试当前线程是否被中断（检查中断标志），返回一个boolean并清除中断状态，
        // 第二次再调用时中断状态已经被清除，将返回一个false。


        System.out.println(Thread.currentThread().getName() + "\t" + Thread.interrupted());
        System.out.println(Thread.currentThread().getName() + "\t" + Thread.interrupted());
        System.out.println("----1");
        Thread.currentThread().interrupt();// 中断标志位设置为true
        System.out.println("----2");
        System.out.println(Thread.currentThread().getName() + "\t" + Thread.interrupted());
        System.out.println(Thread.currentThread().getName() + "\t" + Thread.interrupted());

        Thread.interrupted();//静态方法

        Thread.currentThread().isInterrupted();//实例方法
    }

image.png

  • 每次调用都指行两次操作
    • 返回但前线程中断标志位
    • 重置中断标志位(false)
  • 两个方法的区别

image.png

  • 底层private native boolean isInterrupted(boolean ClearInterrupted);方法会根据传入的ClearInterrupted 参数确定是否重置中断标志位
    • 静态方法 interupted 传入的ClearInterrupted 为 true
    • 实例方法 isInterupted 传入的ClearInterrupted 为 false

小结

  • public void interupt()是一个实例方法
    • 用于通知目标线程中断,仅仅设置目标线程中断标志位为 true
  • public boolean isInterupted()也是一个实例方法
    • 判断当前线程是否被中断,通过检查中断标志位,返回中断标志位
  • public static boolean interupted()是 Thread 类的一个静态方法
    • 先获取当前线程的中断标志位并返回,之后将当前线程的中断标志位重置为初始值(false)
    • 不管线程是否被中断,第二次调用总是得到 false

LockSupport

是什么?

image.png

  • park 方法与 unpark 方法

image.png

  • 说明
    • LockSupport 用于创建锁和其它同步类的基本线程阻塞原语
    • park 方法的作用是阻塞线程 , unpark 方法是接触阻塞线程

线程等待唤醒机制

3 种让线程等待和唤醒的方法

  • 使用 Object 类中的 wait 方法让线程等待,使用 notify 方法唤醒线程
  • 使用 JUC 包中的 Condition 接口中的 await 方法让线程等待,使用 signal 方法唤醒线程
  • 使用 LockSupport 类可以阻塞当前线程以及唤醒指定被阻塞的线程


Object 类中 wait 和 notify 方法实现线程等待和唤醒

正常情况,均在同步监视器中执行 wait 与 notify 方法,先执行 wait 方法后执行 notify 方法
    private static void syncWaitNotify() {
        Object objectLock = new Object();

        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();

        //暂停几秒钟线程
        try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

        new Thread(() -> {
            synchronized (objectLock) {
                objectLock.notify();
                System.out.println(Thread.currentThread().getName() + "\t ----发出通知");
            }
        }, "t2").start();
    }
  • 效果

image.png

  • 结果说明
    • t1 先执行,正常阻塞,
    • t2 后执行,发出通知,结束线程
    • t1 被唤醒,继续执行,结束线程
去除同步监视器 synchronized 的情况

image.png

  • 效果

image.png

  • 结果说明
    • 抛出两次异常IllegalMonitorStateException,非法的监视器状态异常
    • 带一次是调用 wait 方法,第二次是调用 notify 方法
  • 结论
    • wait 方法与 notify 方法的执行必须在当前线程已获取锁的情况下
正常情况下,将 notify 先于 wait 执行
     private static void syncWaitNotify() {
        Object objectLock = new Object();

        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } 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();

        //暂停几秒钟线程
        //try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

        new Thread(() -> {
            synchronized (objectLock) {
                objectLock.notify();
                System.out.println(Thread.currentThread().getName() + "\t ----发出通知");
            }
        }, "t2").start();
    }
  • 效果

image.png

  • 结果说明
    • t2 先执行 notify 唤醒线程,此时 t1 还没启动
    • t1 运行进入 wait,等待唤醒,t2 已经结束,t1 陷入无限等待
结论
  • Object 中的 wait 于 notify 方法的使用有以下两个限制
    • 两个方法均必须获取锁之后才能调用
    • wait 方法必须先于 notify 方法调用

Condition 接口中的 await 后的 signal 方法实现线程的等待和唤醒

  • 与 Object 类中的方法类似
    • await 对标 wait 方法
    • signal 对标 notify 方法
  • 正常情况
    private static void lockAwaitSignal() {
        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();

        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();

        //暂停几秒钟线程
        try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

        new Thread(() -> {
            lock.lock();
            try {
                condition.signal();
                System.out.println(Thread.currentThread().getName() + "\t ----发出通知");
            } finally {
                lock.unlock();
            }
        }, "t2").start();
    }

image.png

  • 无锁情况,将 lock 与 unlock 方法注掉

image.png

  • signal 先于 await 方法调用的情况
    private static void lockAwaitSignal() {
        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();

        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } 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();

        //暂停几秒钟线程
        //try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

        new Thread(() -> {
            lock.lock();
            try {
                condition.signal();
                System.out.println(Thread.currentThread().getName() + "\t ----发出通知");
            } finally {
                lock.unlock();
            }
        }, "t2").start();
    }

image.png

  • 结论
    • 与 synchronized 的类似,须在获取锁之后进行调用,先等待再唤醒

Object 类和 Condition 接口实现的限制

  • 调用之前必须获取锁对象
  • 先等待后唤醒

LockSupport 类中的 park 等待与 unpark 唤醒

  • 该类与使用它的每个线程关联一个许可证（在Semaphore类的意义上）。 如果许可证可用，将立即返回park ，并在此过程中消费; 否则可能会阻止。 如果尚未提供许可，则致电unpark获得许可。 （与Semaphores不同，许可证不会累积。最多只有一个。）可靠的使用需要使用volatile（或原子）变量来控制何时停放或取消停放。 对于易失性变量访问保持对这些方法的调用的顺序，但不一定是非易失性变量访问。
  • LockSupport 类使用了一种名为 Permit(许可)的概念做到阻塞和唤醒线程功能,每一个线程都有一个许可(permit)与 Semaphore 不同,LockSupport 许可上限是 1
  • 主要方法

  • 通过 LockSupport 调用 park 方法的执行过程

  • permit 许可证默认没有,不能放行
  • 所以一开始调用 park 方法但前线程就会阻塞,
  • 直至别的线程调用 unpark 为当前线程发放 permit,park方法才会唤醒
  • unpark 与 park 类似均调用自 UNSafe 类中的 unpark 方法

image.png

  • 基于 LockSupport 实现等待唤醒
        Thread t1 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t ----come in" + System.currentTimeMillis());
            LockSupport.park();
            System.out.println(Thread.currentThread().getName() + "\t ----被唤醒" + System.currentTimeMillis());
        }, "t1");
        t1.start();

        //暂停几秒钟线程
        try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

        new Thread(() -> {
            LockSupport.unpark(t1);
            System.out.println(Thread.currentThread().getName() + "\t ----发出通知");
        }, "t2").start();
  • 效果

image.png

  • unpark 先于 park 执行的情况

image.png

  • 效果

image.png

LockSupport 与 Object 和 Condition 先比的优点

  • 方法的调用不在依赖于锁的环境
  • LockSupport 支持先唤醒后等待
  • unpark 发放的许可上限为 1

image.png
image.png

![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/a94fa4f8e4374a4a83f7109a5bdafd5c.png#pic_center#pic_center)

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【k8s 访问控制--认证与鉴权】

【k8s 访问控制--认证与鉴权】

1、身份认证与权限 前面我们在操作k8s的所有请求都是通过https的方式进行请求&#xff0c;通过REST协议操作我们的k8s接口&#xff0c;所以在k8s中有一套认证和鉴权的资源。 Kubenetes中提供了良好的多租户认证管理机制&#xff0c;如RBAC、ServiceAccount还有各种策路等。通…
阅读更多...
Linux学习：初始Linux

Linux学习：初始Linux

目录 1. 引子&#xff1a;1.1 简述&#xff1a;操作系统1.2 学习工具 2. Linux操作系统中的一些基础概念与指令2.1 简单指令2.2 ls指令与文件2.3 cd指令与目录2.4 文件目录的新建与删除指令2.5 补充指令1&#xff1a;2.6 文件编辑与拷贝剪切2.7 文件的查看2.8 时间相关指令2.9 …
阅读更多...
基于C语言实现内存型数据库(kv存储)

基于C语言实现内存型数据库(kv存储)

基于C语言实现内存型数据库(kv存储) 文章目录 基于C语言实现内存型数据库(kv存储)1. 项目背景1.1 Redis介绍1.2 项目预期及基本架构 2. 服务端原理及代码框架2.1 网络数据回环的实现2.2 array的实现2.3 rbtree的实现2.4 btree的实现2.5 hash的实现2.6 dhash的实现2.7 skiplist的…
阅读更多...
Python并发编程：多线程-信号量，Event，定时器

Python并发编程：多线程-信号量，Event，定时器

一 信号量 信号量也是一把锁&#xff0c;可以指定信号量为5&#xff0c;对比互斥锁同一时间只能有一个任务抢到锁去执行&#xff0c;信号量同一时间可以有5个任务拿到锁去执行&#xff0c;如果说互斥锁是合租房屋的人去抢一个厕所&#xff0c;那么信号量就相当于一群路人争抢公…
阅读更多...
蓝桥杯倒计时 41天 - 二分答案-最大通过数-妮妮的月饼工厂

蓝桥杯倒计时 41天 - 二分答案-最大通过数-妮妮的月饼工厂

最大通过数 思路&#xff1a;假设左边能通过 x 关&#xff0c;右边能通过 y 关&#xff0c;x∈[0,n]&#xff0c;通过二分&#xff0c;在前缀和中枚举右边通过的关卡数&#xff0c;保存 xy 的最大值。 #include<bits/stdc.h> using namespace std; typedef long long ll…
阅读更多...
Windows下用crashRpt让C++程序崩溃自动生成dump

Windows下用crashRpt让C++程序崩溃自动生成dump

背景 我们的Windows c程序如果在客户或者没有代码调试的环境下崩溃了。我们只能从机器异常报错里得知寥寥无几的信息&#xff0c;如果程序崩溃时&#xff0c;能自动触发当前堆栈信息的收集&#xff0c;那么对于开发人员复现BUG就尤为重要 CrashRpt CrashRpt主要功能 1.崩溃报…
阅读更多...
首例以“冠状病毒”为主题的勒索病毒，篡改系统MBR

首例以“冠状病毒”为主题的勒索病毒，篡改系统MBR

前言概述 2020年勒索病毒攻击仍然是网络安全的最大威胁&#xff0c;在短短三个月的时间里&#xff0c;已经出现了多款新型的勒索病毒&#xff0c;关于2020年勒索病毒攻击新趋势&#xff0c;可以阅读笔者写的上一篇文章&#xff0c;里面有详细的分析&#xff0c;从目前观察到的…
阅读更多...
【风格迁移】AdaAttN：使用注意力机制和归一化来保持内容结构的同时转移风格特征

【风格迁移】AdaAttN：使用注意力机制和归一化来保持内容结构的同时转移风格特征

AdaAttN&#xff1a;使用注意力机制和归一化来保持内容结构的同时转移风格特征 提出背景AdaAttN 框架自适应注意力归一化&#xff08;AdaAttN&#xff09;损失函数视频风格迁移的扩展 自适应注意力归一化&#xff08;AdaAttN&#xff09;的应用场景 全流程优化基于特征相似度的…
阅读更多...
DbSchema导出HTML/PDF版表结构

DbSchema导出HTML/PDF版表结构

一、连接数据库 登录成功默认显示当前用户的所有资源&#xff08;表、视图、序列、方法、触发器等&#xff09;&#xff0c;如果不操作将导出此用户的全部信息。 至此连接数据库完成 二、表结构导出 本次不想给用户全部导出&#xff0c;只给导出几张&#xff0c;选择需要…
阅读更多...
Linux 学习笔记(10)

Linux 学习笔记(10)

十、 进程管理 进程就是运行中的程序&#xff0c;一个运行着的程序&#xff0c;可能有多个进程。 比如 LinuxSir.Org 所用的 WWW 服务器是 apache 服务器&#xff0c;当管理员启动服务后&#xff0c;可能会有好多人来访问&#xff0c;也就是说许多用户来同时请 求 htt…
阅读更多...
C-V2X系列：C-V2X芯片及模组整理总结

C-V2X系列：C-V2X芯片及模组整理总结

C-V2X、车路协同、车联网、智能网联车学习 C-V2X芯片及模组整理总结
阅读更多...
http 协议深入介绍

http 协议深入介绍

一&#xff0c;http 相关概念 &#xff08;一&#xff09;关键名词 1&#xff0c;互联网 是网络的网络&#xff0c;是所有类型网络的母集 2&#xff0c;因特网 世界上最大的互联网网络。即因特网概念从属于互联网概念。习惯上&#xff0c;大家把连接在因特网上的计算机都成…
阅读更多...
【旧文搬运】为你的 Laravel 应用添加一个基于 Swoole 的 WebSocket 服务

【旧文搬运】为你的 Laravel 应用添加一个基于 Swoole 的 WebSocket 服务

做了一个基于 Swoole 的 WebSocket 扩展包&#xff0c;可以用来做实时状态推送&#xff0c;或者自定义消息处理实现 im&#xff0c;有需要的可以看看: [giorgio-socket] 使用方法 安装 安装扩展包 composer require wu/giorgio-socket发布配置文件 php artisan vendor:pu…
阅读更多...
机器学习：数据处理基操

机器学习：数据处理基操

在处理完数据之后&#xff0c;选择好模型&#xff0c;就可以用训练集训练模型&#xff0c;用测试集输入模型 然后输出需要预测的结果啦&#xff5e; 一、模块导入 import numpy as np import pandas as pd #读入数据 二、pandas数据 一、dataframe基础 一、dataframe的创建…
阅读更多...
图像处理ASIC设计方法 笔记6 数据拼接和帧格式校正

图像处理ASIC设计方法 笔记6 数据拼接和帧格式校正

第四章大模板卷积ASIC设计方案 P80 实时图SPRM 数据位宽64bit，4个SPRAM，同时得到4行数据 绘制卷积芯片数据路径图，卷积芯片内部模块图 根据这个图，本书后续对各个模块都进行介绍。 P81 第一个模块 图像输入前端FIFO 学习图像处理中好的设计思路：帧格式校验和数据拼接 …
阅读更多...
STM32+ESP8266水墨屏天气时钟:ESP8266连接心知天气获取数据

STM32+ESP8266水墨屏天气时钟:ESP8266连接心知天气获取数据

项目背景 利用STM32F103C8T6和ESP8266模块进行通信&#xff0c;获取心知天气的数据。 硬件设计为串口1(PA9和PA10)连接ESP8266. 串口2打印 一.ESP8266连接WIFI ESP8266模块可以通过AT指令控制搭配使用源代码API函数开发&#xff0c;总体开发速度快&#xff0c;难度较低。 说…
阅读更多...
板子合集1.0

板子合集1.0

版权声明&#xff1a;本文为博主原创文章&#xff0c;遵循 CC 4.0 BY-SA 版权协议&#xff0c;转载请附上原文出处链接和本声明。 原文链接&#xff1a;https://blog.csdn.net/JK01WYX/ 文章目录 1.快速幂板子2.gcd得最大公约数3.堆优化的dijkstra板子4.线段树1板子 区间加线段…
阅读更多...
Vue--》打造简易直播应用平台项目实战

Vue--》打造简易直播应用平台项目实战

今天开始使用 vue3 + ts 搭建一个简易直播应用平台项目，因为文章会将项目的每一个地方代码的书写都会讲解到，所以本项目会分成好几篇文章进行讲解，我会在最后一篇文章中会将项目代码开源到我的github上，大家可以自行去进行下载运行，希望本文章对有帮助的朋友们能多多关注本…
阅读更多...
奇怪的需求之与图片做交互

奇怪的需求之与图片做交互

1.起因 客户想要展示自己的地图,该地图上有各种工作数据,和工作点位,已有的地图不能满足需求.于是提出将这张图片当成大背景 2.经过 鉴于文件格式和尺寸的原因,协商后客户提出将图片做成缩放效果,同时具有点击效果,原先直接进入的主页,现在为点击图片中的某条线路进入主页面…
阅读更多...
【论文阅读】多传感器SLAM数据集

【论文阅读】多传感器SLAM数据集

一、M2DGR 该数据集主要针对的是地面机器人&#xff0c;文章正文提到&#xff0c;现在许多机器人在进行定位时&#xff0c;其视角以及移动速度与车或者无人机有着较大的差异&#xff0c;这一差异导致在地面机器人完成SLAM任务时并不能直接套用类似的数据集。针对这一问题该团队…
阅读更多...
最新文章

Copyright @ 2022~2023