【JavaEE】Java的多线程编程基础知识 -- 多线程篇(2)

news2024/11/17 8:38:30

Java多线程编程基础知识

  • 一、多线程的创建
  • 二、Thread类常用的方法和API
    • 2.1 Thread 的几个常见的属性
    • 2.2 start 启动一个线程
    • 2.3 终止一个线程
    • 2.4 等待一个线程-join()
    • 2.5 线程休眠函数 -sleep()
  • 三、线程状态
    • 3.1 观察所有线程的状态
    • 3.2 线程状态和线程转移的意义
  • 四、线程安全（重点）
    • 4.1 观察线程不安全的现象
    • 4.2 线程安全的概念
    • 4.3 线程安全出现的原因
    • 4.4 synchronized 关键字 --加锁手段
    • 4.5 volatile关键字
  • 五、线程同步
    • wait 和 notify

一、多线程的创建

构造方法

在这里插入图片描述

Java创建多线程示例

  1. 创建一个类来继承Thread, 并重写run方法

class MyThread extends Thread {
    @Override
    public void run() {
        while (true) {
            System.out.println("hello word!");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        MyThread thread = new MyThread();
        thread.start();
        while (true) {
            System.out.println("hello main!");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
  1. 创建一个类实现Runnable, 并重写run方法
class MyRunnable implements Runnable {

    @Override
    public void run() {
        while (true) {
            System.out.println("Hello Runnable");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Test2 {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread t = new Thread(myRunnable);
        t.start();
    }
}
  1. 基于匿名内部类, 继承Thread, 并重写run方法
public class Test3 {
    public static void main(String[] args) {
        Thread t = new Thread() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("Hello anonymous");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t.start();
    }
}
  1. 基于内部类, 实现Runnable, 并重写run方法
public class Test4 {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("Hello anonymous runnable");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        t.start();
    }
}
  1. 使用lambda表达式, 来表示run方法 --推荐使用
public class Test5 {
    public static void main(String[] args) {
        Thread t = new Thread(()->{
            while (true) {
                System.out.println("Hello lambda");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        t.start();
    }
}
  1. 基于Callable

public class Test6 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 0; i <= 100; i++) {
                    sum += i;
                }
                return sum;
            }
        };

        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread t = new Thread(futureTask);
        t.start();

        Integer result = futureTask.get();
        System.out.println(result);
    }
}
  1. 基于线程池

public class Test7 {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(4);
        for (int i = 0; i < 100; i++) {
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("Hello threadPool: executorService");
                }
            });
        }
    }
}

多线程的命名

  • 多线程的默认命名是 thread + 线程编号(从0开始逐渐递增)
  • 通过构造函数来指定线程名

在这里插入图片描述

run方法 和 start方法的区别

  • 观察现象
    在这里插入图片描述
    在这里插入图片描述

  • 得出结论

    • run方法是继承Thread并重写run方法匿名类中的一个方法, 调用该方法就只是调用该方法, 并没有创建出新的线程
    • start方法是先创建出来一个新的线程, 在让该新的线程来执行run方法

二、Thread类常用的方法和API

2.1 Thread 的几个常见的属性

在这里插入图片描述

ID

这个是线程的身份标识 – 在JVM中给线程设定的标识

线程的不同身份标识:

  1. JVM有一个身份表示
  2. pthread 库(系统给程序员提供的操作线程的API), 也有一个线程的身份标识
  3. 在内核里, 针对线程的 PCB 还有身份标识

不同身份标识的意义: 可以解耦合!

状态和优先级

在这里插入图片描述

是否是后台线程 – isDaemon()

  • 前台线程: 前台线程会影响进程, 如果前台线程没有结束, 则进程就不会结束, 如果所有的前台线程都结束了, 即使还存在后台线程, 进程也会推出
  • 后台线程/守护线程: 后台线程不会影响进程的结束与否

是否存活 – isAlive()

Thread 对象, 对应的线程(系统内核中), 是否存活;

Thread 对象的生命周期, 并不是和系统中的线程完全一致的!

2.2 start 启动一个线程

之前我们已经看到了如何通过覆写 run 方法创建一个线程对象，但线程对象被创建出来并不意味着线程就开始运行了。

  • 覆盖 run 方法是提供给线程要做的事情的指令清单
  • 线程对象可以认为是把 李四、王五叫过来了
  • 而调用 start() 方法, 就是喊一声:"行动起来! " , 线程才真正独立去执行了
    在这里插入图片描述

2.3 终止一个线程

  • 线程结束的标志
    • run 函数结束
  • 此处的终止线程, 就是想办法, 让 run 能够尽快的执行完毕

终止线程的方法

  1. 程序员手动设定标志位
public class Test02 {
    private static boolean isQuit = false;

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (!isQuit) {
                System.out.println("Hello world");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();

        Thread.sleep(3000);

        isQuit = true;
        System.out.println("把t线程终止了");
    }
}

在这里插入图片描述

lambda表达式捕捉变量的理解

  • 问题提出:

    • lambda表达是可以捕获到外面的变量, 既然是lambada 表达式, 执行时机更靠后的, 这就导致了, 后续真正执行 lambda 的时候, 局部变量 isQuit 是否可能已经被销毁了呢?
    • 这种情况是客观存在的, 让 lambda 去访问一个已经被销毁了变量很明显是不合适的。

  • 问题解决

    • lambda 引入了“变量捕获”这样的机制，lambda 内部看起来是直接访问外部的变量，其实本质上是把外部的变量复制了一份，到 lambda 里面。（这样就可以解决刚才 生命周期 的问题了）
    • 所以，变量捕获这里的限制，要求捕获的变量得是 final （至少 事实上是 final）-- 就是该变量只有一次赋值操作

  • 如果这个变量想要修改，就不能进行变量捕获了

    • 为什么java这么设定？
      • 因为 java 是通过复制的方式来实现 “变量捕获”。如果外面的代码想要这个变量进行修改，就会出现一个情况，外面的变量变了，里面的没变 – 代码更容易出现歧义

  • 相比较之下，其它语言（JS）采取了更激进的设计 – 也有变量捕获，不是通过复制的方式实现，而是直接改变外部变量的生命周期从而保证 lambda 在执行的时候肯定能访问到外部的变量 – 此时JS的变量捕获就没有final的限制

  1. 直接使用 Thread 类，给我们提供好了现成的标志位，不同咱们手动设置这个标志。
public class Test03 {
    public static void main(String[] args) throws InterruptedException {
        Thread t =new Thread(() -> {
           while (!Thread.currentThread().isInterrupted()) {
               System.out.println("Hello world");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
                   break;
               }
           }
        });
        t.start();
        Thread.sleep(3000);
        t.interrupt(); // 将 Thread 中断标志位设置为 true
        System.out.println("把t线程终止了");
    }
}

运行现象

在这里插入图片描述

  • t 线程正在sleep, 然后被 interrupt 给唤醒了, 而手动设置的标志位, 此时是没法唤醒sleep的
  • 因此, 线程正在 sleep 过程中, 其它线程调用 interrupt 方法, 就会强制 sleep 抛出一个异常, sleep 就会被立即唤醒了, 但 sleep 在唤醒的同时, 会自动清除前面设置的标志位! – 这样就给程序员留下更多的操作空间
    • 我们通过 try - catch 捕获 InterruptedException 异常, 在catch 中写自己想要的处理逻辑
      • a. 立即停止循环, 立即结束线程
      • b. 继续做点别的事情, 过一会再结束线程
      • c. 忽略终止的请求, 继续循环

2.4 等待一个线程-join()

  • 问题分析
    • 多个线程是并发执行的, 具体的执行过程, 都是由操作系统负责调度的, 操作系统的调度线程的过程, 是 “随机” 的, 无法确定, 线程执行的先后顺序, 上述随机性, 程序员不太喜欢, 更喜欢的是"确定"的东西
  • 等待线程 是规划 线程结束顺序的一种手段

join() 方法的参数

在这里插入图片描述

  • 没有参数的是阻塞的等待线程结束, 就是让等待线程不在执行代码了, 不在使用CPU的资源了 – 但是死的策略不合适, 所以我们应该设定等待线程结束最大的时间 – 只要时间到, 不管来没来, 就不等了

  • join 能否被 interrupt 唤醒？ --可以的-- 会自动清除中断标志位

【使用示例】

public class Test04 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            int cnt = 5;
            while (cnt-- != 0) {
                System.out.println("Hello join");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("t thread end");
        });
        t.start();
        t.join();
        System.out.println("main thread end");
    }
}

2.5 线程休眠函数 -sleep()

  • 这是一个类方法, 调用的时候需要 Thread.sleep(long )
  • 参数是表示休眠 n 毫秒
  • 该休眠时间不是精确的, 例如: sleep(1000) – 该线程开始休眠 1000 ms, 1000 ms后, 该线程变成就绪状态, 时刻准备被CPU调度。但CPU调度也是需要时间的, 所以这其中就会出现误差
  • sleep的作用还有一个功能, 让当前线程主动放弃CPU资源; 利用这个特性, 可以 Thread.sleep(0) – 表示放弃啊CPU资源, 到就绪队列中等待CPU的重新调度。这个与 yield() 方法功能类似

三、线程状态

就绪状态、阻塞状态是系统设定的状态, Java对线程的状态的设定进行更进一步的细分.

3.1 观察所有线程的状态

线程状态是一个枚举类型 Thread.State

    public static void main(String[] args) {
        for(Thread.State x : Thread.State.values()) {
            System.out.println(x);
        }
    }
  • NEW: 安排了工作, 还未开始行动;
  • RUNNABLE: 可工作的, 又可以分成正在工作中和即将开始工作
  • BLOCKED: 表示队列排队等着其它事情 – 因为锁产生阻塞了
  • WATING: 表示队列排队等着其它事情 – 因为调用 wait 产生阻塞了
  • TIMED_WAITING: 表示队列排队等着其它事情 – 因为sleep 产生阻塞
  • TERMINATED: 工作完成了

3.2 线程状态和线程转移的意义

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

四、线程安全（重点）

4.1 观察线程不安全的现象

在这里插入图片描述
这里的结果不是预期的 100000！

4.2 线程安全的概念

  • 在多线程下，发现由于多线程执行，导致的 bug，统一成为“线程安全问题”，如果某个代码，在单线程下执行没有问题，多个线程下执行也没有问题，则成为“线程安全”，反之也可以称为“线程不安全”；

4.3 线程安全出现的原因

  1. [根本原因] 多个线程之间的调度顺序是"随机的", 操作系统使用"抢占式"执行的策略来调度线程, 罪魁祸首, 万恶资源
    • 和单线程不同的是, 多线程下, 代码的执行顺序, 产生了更多的变化, 以往只需要考虑代码在一个固定的顺序下执行, 执行正确即可, 现在则要考虑多线程下, N中执行顺序, 代码执行都得正确
    • 这件事情, 木已成舟, 无法改变, 当前主流的操作系统, 都是这样的抢占式 执行的
  2. 过个线程同时修改同一个变量, 容易产生线程安全问题 – 代码结构
    • 一个线程修改一个变量 – 没事
    • 多个线程同时读取同一变量 – 没事
    • 多个线程修改多个变量 – 没事
    • 多个线程同时修改同一个变量 – 危险
  3. 进行的修改, 不是 “原子的” – 解决线程安全主要的切入手段
    • 如果修改操作, 能够按照原子的方式来完成, 此时也不会有线程安全问题
  4. 内存可见性, 引起的线程安全问题
  5. 指令重排序, 引起的线程安全问题

解决线程安全的主要手段: 加锁, 将修改操作打包成原子性的

4.4 synchronized 关键字 --加锁手段

语法格式:

synchronized (一个对象) {
	// 代码块
}

作用 :

  1. 进入代码块就加锁
  2. 出了代码块就解锁

上述问题的解决如下:
在这里插入图片描述

  • 理解synchronized
    • synchronized 进行加锁解锁操作, 其实是以 “对象” 为维度进行展开的
    • 加锁的目的是为了互斥使用临界资源
    • 加锁规则如下:
      • 如果两个线程针对同一个对象进行加锁, 就会出现 锁竞争 / 锁冲突(一个线程能加锁成功, 另一个线程阻塞等待)
      • 如果两个线程针对的不同对象加锁, 不会产生锁竞争, 也就不会存在阻塞等待一系列的操作了
      • 具体是针对哪个对象加锁不重要, 重要的是两个线程是否是对同一个对象进行加锁!
    • synchronized 可以直接修饰方法
      • 如果修饰的普通成员方法 – 则加锁的对象就是 this 引用
      • 如果修饰的类方法 – 则加锁对象就是该类对象(.class) – 类用来实例化出对象的模板

4.5 volatile关键字

内存可见性引起的线程安全问题

问题现象指出

在这里插入图片描述

  • 问题出现:
    • 输入1, 在 main 线程中已经修改了 isQuit 的值, 但是 t 线程中没有看到isQuit 的值, 一直在循环, 没有退出
    • 不符合预期, 出现 bug , 是一个线程安全的问题
  • 问题分析:
    • 程序在编译运行的时候, Java 编辑器, 和 JVM 可能会对代码做出一些 “优化”
    • 程序员负责写代码的, 当写好一个代码之后, 人家开发 Java编辑器, 开发 JVM 的大佬, 可能会认为你这个代码写的不好, 当你的代码实际执行的时候, 编辑器/JVM 就可能把你的代码改了, 保持原有逻辑不变的情况下, 提供代码的执行效率
    • 编译器/JVM 优化的效果是非常明显的, 可以提高效率
    • 但是, 遇到了多线程, 此时的优化可能会出现差错
while (!isQuit) {}

该执行代码本质上有两个指令:

  1. load(读取内存) – 速度慢
  2. jcmp (比较并跳转) – 纯CPU, 速度贼快
  • 此时, 编译器/JVM就发现, 这个逻辑中, 代码要反复的, 快速的读取同一个内促的值, 并且, 这个内存的值, 每次读出来还是一样的!
  • 此时, 编译器就做出了一个大胆的决定, 直接 load 操作优化了, 只是执行第一次 load, 后续不在执行load, 直接拿寄存器中的数据进行比较了
  • 但是, 万万没想到, 程序员不讲武德, 搞偷袭, 在另一个线程中, 修改了 isQuit 的值!
  • 因为是通过scanner进行数据的输入, 编译器无法准确判断, main 线程 到底会不会修改 isQuit 的值, 啥时候执行, 因此就出现了误判
  • 所以虽然 main 线程把内存中的 isQuit 给改了, 但是另一个线程中, 并没有重复从内存中读取 isQuit 的值, 因此 t 线程就无法感知 main 的修改,也就出现了上述的问题

volatile 解决内存可见性的问题

  • 给要变的变量加上 volatile 关键字进行加以修饰, 说明该变量的是容易发生变化的, 就告诉编译器不要出现上述的优化, 每次都要从内存中读取变量的值
  • volatile 本质就是保证了变量的内存可见性
  • volatile 不保证原子性

在这里插入图片描述

编译器的优化是一种玄学, 为了保证代码的逻辑, 不能完全依靠编译器的优化

Java 中的内存模型

在这里插入图片描述

  • Java在主内存和CPU之间, 增加了一个 工作内存(也就是一个存储区)
  • 思考: CPU中有寄存器, 寄存器和主内存之间有1~3级的缓冲区, 为什么Java 对这些缓冲区叫做工作内存呢?
    • Java 要保证 “跨平台”
      • 支持不同的操作系统
      • 支持不同的硬件设备 (CPU)
    • 如果对每个硬件都需要特定的描述, 就会比较复杂, 因此官方直接发明了一个新的术语, “工作内存”, 同时也可以通过这个新的术语, 来屏蔽硬件的相关信息

五、线程同步

wait 和 notify

  • 多线程调度是随机的
  • 很多时候希望多个线程能够按照咱们自定的顺序来进行， 完成线程之间的配合工作
  • wait(等待) 和 notify(通知) 就是一个用来协调线程顺序的重要工具
  • 这两个方法, 都是 Object 提供的方法, 随便找个对象, 都可以使用wait 和 notify

wait

wait 在执行的时候, 会做三件事:

  1. 解锁 object,wait, 就会尝试针对 object 对象解锁
  2. 阻塞等待
  3. 当被其它线程唤醒之后, 就会尝试重新加锁, 加锁成功, wait 执行完毕, 继续往下执行其他逻辑
wait需要的注意事项
  • wait 要解锁, 就得先要加上锁
  • 所以, 先要synchronized给对象加上锁, 并在代码块里面使用wait方法等待

notify

  • 就是用来唤醒 在相应对象上 wait 的线程
  • wait 和 notify 都需要放到 synchronized 之内
    • 虽然 notify 不涉及 “解锁操作”, 但是 Java 也强制要求 notify 放到 synchronized中
  • 如果notify 的时候, 另一个线程没有处于 wait 状态, 此时notify相当于"孔大一炮", 不会有任何副作用

wait 和 notify 的控制线程的执行顺序, 解决线程饥饿的问题

wait 和 sleep 之间的区别

sleep 是有一个明确的时间, 到达时间, 自然会被唤醒, 也能提前唤醒, 使用 interrupt 就可以

wait 默认是一个死等, 一直等到有其他线程 notify . wait 也能够被 interrupt 提前唤醒.
- notify是顺理成章的唤醒, 唤醒之后该线程还需要继续工作, 后续还会进入到 wait 状态
- interrupt 告知线程要结束了, 接下来线程就要进入到收尾工作了

wait 也有一个带有超时间的版本(和 join 类似)

因此, 协调多个线程之间阿德执行顺序, 当然还是优先考虑使用 wait notify, 而不是 sleep

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

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

相关文章

pytorch 训练可视化

pytorch 训练可视化

pytorch 训练可视化 1.from torch.utils.tensorboard 1.from torch.utils.tensorboard from torch.utils.tensorboard import SummaryWriter在最新版本的pytorch中官方提供了tensorboard的api。以下是官方教程的链接 https://pytorch.org/tutorials/intermediate/tensorboard…
阅读更多...
docker企业单位私有镜像仓库 Harbor 搭建

docker企业单位私有镜像仓库 Harbor 搭建

docker私有镜像仓库 Harbor 搭建 背景说明使用环境安装部署docker安装docker-compose安装 安装 HarborHarbor UI管理docker 登录docker推送镜像和拉取镜像docker推送镜像docker 拉取镜像 背景说明 为了方便管理docker容器镜像&#xff0c;通常使用各大云平台提供的镜像服务&am…
阅读更多...
内裤洗衣机到底值不值得买？内衣洗衣机便宜好用的牌子

内裤洗衣机到底值不值得买？内衣洗衣机便宜好用的牌子

有很多姐妹上班累爆了&#xff0c;回家洗澡换下的衣物还要区分开来&#xff0c;将内衣裤用来自己手洗&#xff0c;还要专门使用杀菌洗衣液才能安心&#xff0c;而且随着科技的进步&#xff0c;现在市面上拥有了一款专门为女生设计的内衣洗衣机&#xff0c;可以解决日常手洗内衣…
阅读更多...
英语 chatGPT分析句子与验证正确性 翻译

英语 chatGPT分析句子与验证正确性 翻译

有时候我想说的时候&#xff0c;又不确定说的对不对。chatGPT知道。 “as well as” 和 “as good as” 都是英语中常见的短语&#xff0c;但它们有不同的用法和含义。 “As Well As”&#xff08;以及&#xff09;: “As well as” 是一个连接词短语&#xff0c;用来连接两…
阅读更多...
最优闭回路问题

最优闭回路问题

目录 一、欧拉回路与道路 1、欧拉回路与道路 2、欧拉图存在的条件 二、中国邮路问题 1、中国邮路问题 2、中国邮路问题求解 3、有奇点的G的中国邮路问题等价问题 例1 【问题分析】 &#xff08;1&#xff09;先求图1中任意两点之间的距离矩阵d1如表1&#xff08;Floyd算…
阅读更多...
软件测试肖sir__python之ui自动化定位方法（2）

软件测试肖sir__python之ui自动化定位方法（2）

Selenium中元素定位方法 一、定位方法 要实现UI自动化&#xff0c;就必须学会定位web页面元素&#xff0c;Selenium核心 webdriver模块提供了9种定位元素方法&#xff1a; 定位方式 提供方法 id定位 find_element_by_id() name定位 find_element_by_name() class定位 find_elem…
阅读更多...
Three.js + Tensorflow.js 构建实时人脸点云

Three.js + Tensorflow.js 构建实时人脸点云

本文重点介绍使用 Three.js 和 Tensorflow.js 实现实时人脸网格点云所需的步骤。 它假设你之前了解异步 javascript 和 Three.js 基础知识&#xff0c;因此不会涵盖基础知识。 该项目的源代码可以在此 Git 存储库中找到。 在阅读本文时查看该代码将会很有帮助&#xff0c;因为…
阅读更多...
nginx配置download模块

nginx配置download模块

nginx.conf配置 location /download{alias /usr/local/webapp/download/;sendfile on;autoindex on; # 开启目录文件列表autoindex_exact_size on; # 显示出文件的确切大小&#xff0c;单位是bytesautoindex_localtime on; # 显示的文件时间为文件的服务器时间charset utf…
阅读更多...
hexo发生错误 Error: Spawn failed

hexo发生错误 Error: Spawn failed

错误描述 仓库中有东西&#xff0c;运行如下命令后报错 hexo d报错提示: 原因分析: 看别人的博客是用git进行push或hexo d的时候改变了一些.deploy_git文件下的内容&#xff0c;这个.deploy_git的内容对于hexo来说可能是系统文件&#xff0c;这里挖坑 解决办法 一个个的…
阅读更多...
如何在不恢复出厂设置的情况下解锁 Android 手机密码？

如何在不恢复出厂设置的情况下解锁 Android 手机密码？

如何在不恢复出厂设置的情况下解锁 Android 手机密码&#xff1f; 当您忘记 Android 手机的密码时&#xff0c;可能会有压力&#xff0c;尤其是当您不想恢复出厂设置并删除所有数据时。但是&#xff0c;有一些方法可以在不诉诸如此激烈的步骤的情况下解锁手机。我们将在这篇文…
阅读更多...
平板有必要买触控笔吗？推荐的ipad手写笔

平板有必要买触控笔吗？推荐的ipad手写笔

iPad之所以能吸引这么多人&#xff0c;主要是因为它的功能出色。用来画画、做笔记&#xff0c;也是一种不错的体验。但如果只是用来看电视和打游戏的话&#xff0c;那就真的有点大材小用了。如果你不需要昂贵的苹果电容笔&#xff0c;也不需要用来专业的绘图&#xff0c;那你可…
阅读更多...
SSM+SpringBoot重点

SSM+SpringBoot重点

SSM+SpringBoot重点 0、VO DTO DO PO介绍 VO ​ vo（view object）视图对象 ​ 用于展示层，它的作用是把某个指定页面（或组件）的所有数据封装起来，一般由后端传输给前端。 DTO ​ DTO（data transfer object）数据传输对象 ​ 用于展示层和逻辑层之间的数据传输。 …
阅读更多...
视频监控这样做，简单又高效！

视频监控这样做，简单又高效！

随着技术的不断进步&#xff0c;视频监控系统已经变得更加高效和智能&#xff0c;可以提供更全面的监控和分析功能&#xff0c;有助于提高安全性、管理效率和决策支持。 客户案例 超市连锁店 福建某全国性超市连锁店面临高额商品损失、偷窃问题&#xff0c;以及对客户安全和员工…
阅读更多...
（论文翻译）UFO: Unified Feature Optimization——UFO:统一特性优化

（论文翻译）UFO: Unified Feature Optimization——UFO:统一特性优化

作者&#xff1a; Teng Xi 论文总结&#xff1a;总结 Code: https://github.com/PaddlePaddle/VIMER/tree/main/UFO 摘要&#xff1a; 本文提出了一种新的统一特征优化(Unified Feature Optimization, UFO)范式&#xff0c;用于在现实世界和大规模场景下训练和部署深度模型…
阅读更多...
Python学习基础笔记七十六——Python装饰器2

Python学习基础笔记七十六——Python装饰器2

装饰器&#xff0c;英文名字decorator。 我们开发Python代码的时候&#xff0c;经常碰到装饰器。 通常被装饰后的函数&#xff0c;会在原来的函数的基础上&#xff0c;增加一些功能。 通常装饰器本事也是一个函数&#xff0c;那么装饰器是怎么装饰另外一个函数的呢&#xff1f…
阅读更多...
Unity 镜面反射

Unity 镜面反射

放置地板和模型 首先&#xff0c;让我们放置地板和将放置在其上的 3D 模型。这次&#xff0c;我使用 Plane 作为地板。从层次视图中选择“创建”→“3D 对象”→“平面”。我们还在地板上放置了 Unity-chan、Cube 和 Sphere。 接下来&#xff0c;创建地板的材质。在项目视图中…
阅读更多...
安装 Dispatch 库

安装 Dispatch 库

首先&#xff0c;我们需要安装 Dispatch 库。在命令行中运行以下命令来安装 Dispatch&#xff1a; $ sbt console然后&#xff0c;在 Scala 控制台中&#xff0c;导入所需的库&#xff1a; import dispatch._接下来&#xff0c;我们需要设置代理服务器。在 Dispatch 中&#…
阅读更多...
个性联邦学习

个性联邦学习

Towards Personalized Federated Learning 一、背景二、解决策略 2.1 策略一.全局模型个性化2.2 策略二.学习个性化模型 三、具体方案 3.1 全局模型个性化 3.1.1 基于数据&#xff1a;减少客户端数据统计异构性3.1.2 基于模型&#xff1a;在学习一个强大的全局模型&#xff0c;…
阅读更多...
014 - ARM64上的GIC-400(GICv2)

014 - ARM64上的GIC-400(GICv2)

本章节涉及到的参考文档有三个&#xff1a; BCM2711 ARM Peripherals.pdfARM Generic Interrupt Controller Architecture Specification.pdf (简称gic_v2)CoreLink GIC-400 Generic Interrupt Controller Technical Reference Manual.pdf 1. GIC 发展历史 在早期的 ARM 系统…
阅读更多...
睿趣科技：抖音小店新手运营攻略

睿趣科技：抖音小店新手运营攻略

随着短视频平台的兴起&#xff0c;抖音已经成为了一个炙手可热的营销工具。越来越多的商家选择在抖音上开设小店&#xff0c;以此来拓展自己的业务。那么&#xff0c;作为新手&#xff0c;如何运营好自己的抖音小店呢?本文将为您提供一些实用的建议。 首先&#xff0c;要明确自…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023