7.并发编程之并发安全问题

news2024/12/22 16:33:05

1 线程安全性

        什么是线程安全性？可以这么理解， 我们所写的代码在并发情况下使用 时，总是能表现出正确的行为；反之，未实现线程安全的代码，表现的行为是不可预知的，有可能正确，而绝大多数的情况下是错误的。 

        线程的行为(尤其是在未正确同步的情况下)可能会造成混淆并且违反直觉。

        如果要实现线程安全性，就要保证我们的类是线程安全的的。在《Java 并发 编程实战》中，定义“类是线程安全的”如下：

        当多个线程访问某个类时，不管运行时环境采用何种调度方式或者这些线程将如何交替执行，并且在调用代码中不需要任何额外的同步或者协同，这个类都 能表现出正确的行为，那么就称这个类是线程安全的。

2 如何实现线程安全？

2.1 线程封闭

        实现好的并发是一件困难的事情，所以很多时候我们都想躲避并发。避免并发最简单的方法就是线程封闭。什么是线程封闭呢？

        就是把对象封装到一个线程里， 只有这一个线程能看到此对象。那么这个对象就算不是线程安全的也不会出现任何安全问题。

2.1.1 栈封闭

        栈封闭是我们编程当中遇到的最多的线程封闭。什么是栈封闭呢？简单的说就是局部变量。多个线程访问一个方法， 此方法中的局部变量都会被拷贝一份到线程栈中。由于局部变量不被多个线程所共享的，也就不会出现并发问题。所以能用局部变量就别用全局的变量，全局变量容易引起并发问题。

2.1.2 TheadLocal

        ThreadLocal 是实现线程封闭的最好方法。ThreadLocal 内部维护了一个 Map， Map 的 key 是每个线程的名称，而 Map 的值就是我们要封闭的对象。每个线程中的对象都对应着 Map 中一个值，也就是 ThreadLocal 利用 Map 实现了对象的线程封闭。

2.1.3 无状态的类

        没有任何成员变量的类，就叫无状态的类，这种类一定是线程安全的。

/**
 * 类说明：无状态的类
 */
public class StatelessClass {
    
    public int add(int a, int b) {
        return a+b;
    }
}

        如果这个类的方法参数中使用了对象，也是线程安全的吗？比如：

/**
 * 类说明：无状态的类
 */
public class StatelessClass {

    public int add(int a, int b) {
        return a+b;
    }

    public void getUserInfo(UserVo userVo) {
        //: TODO
    }
}

        当然也是，为何？因为多线程下的使用，固然 userVo 这个对象的实例会不正常，但是对于 StatelessClass 这个类的对象实例来说，它并不持有 UserVo 的对象实例，它自己并不会有问题，有问题的是 UserVo 这个类，而非 StatelessClass 本身。

2.1.4 让类不可变

        让状态不可变，加 final 关键字，对于一个类，所有的成员变量应该是私有的， 同样的只要有可能， 所有的成员变量应该加上 final 关键字，但是加上 final ，要注意如果成员变量又是一个对象时， 这个对象所对应的类也要是不可变，才能保证整个类是不可变的。

        但是要注意， 一旦类的成员变量中有对象，上述的 final 关键字保证不可变并不能保证类的安全性。因为在多线程下，虽然对象的引用不可变，但是对象在堆上的实例是有可能被多个线程同时修改的，没有正确处理的情况下，对象实例在堆中的数据是不可预知的。

/**
 * 类说明：不可变的类
 */
public class ImmutableClass {

    private final String name = "hello world";
    private final Object obj; // 加上它就变成线程不安全了

    public ImmutableClass(Object obj) {
        this.obj = obj;
    }
}

2.2 加锁和 CAS

        我们最常使用的保证线程安全的手段， 使用 synchronized 关键字，使用显式 锁，使用各种原子变量，修改数据时使用 CAS 机制等等。

2.2.1 死锁

        死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁。

        举个例子： A 和 B 去按摩洗脚，都想在洗脚的时候，同时顺便做个头部按摩，13 技师擅长足底按摩，14 擅长头部按摩。

        这个时候 A 先抢到 14，B 先抢到 13，两个人都想同时洗脚和头部按摩，于是就互不相让， 扬言我死也不让你，这样的话，A 抢到 14，想要 13，B 抢到 13， 想要 14，在这个想同时洗脚和头部按摩的事情上 A 和 B 就产生了死锁。 怎么解 决这个问题呢？

        第一种，假如这个时候，来了个 15，刚好也是擅长头部按摩的， A 又没有两个脑袋， 自然就归了 B，于是 B 就美滋滋的洗脚和做头部按摩，剩下 A 在旁边气 鼓鼓的，这个时候死锁这种情况就被打破了，不存在了。

        第二种， C 出场了，用武力强迫 A 和 B，必须先做洗脚，再头部按摩，这种情况下， A 和 B 谁先抢到 13，谁就可以进行下去，另外一个没抢到的，就等着， 这种情况下，也不会产生死锁。

所以总结一下：

  1. 死锁是必然发生在多操作者（M>=2 个）争夺多个资源（N>=2 个，且 N<=M） 才会发生这种情况。很明显，单线程自然不会有死锁，只有 B 一个去，不要 2 个， 打十个都没问题； 单资源呢？只有 13，A 和 B 也只会产生激烈竞争， 打得不 可开交，谁抢到就是谁的，但不会产生死锁。
  2. 争夺资源的顺序不对，如果争夺资源的顺序是一样的， 也不会产生死锁； 3、争夺者对拿到的资源不放手。

学术化的定义

        死锁的发生必须具备以下四个必要条件。

  1. 互斥条件：指进程对所分配到的资源进行排它性使用，即在一段时间内 某资源只由一个进程占用。如果此时还有其它进程请求资源， 则请求者只能等待， 直至占有资源的进程用毕释放。
  2. 请求和保持条件：指进程已经保持至少一个资源，但又提出了新的资源 请求， 而该资源已被其它进程占有， 此时请求进程阻塞， 但又对自己已获得的其 它资源保持不放。
  3. 3）不剥夺条件：指进程已获得的资源，在未使用完之前，不能被剥夺，只 能在使用完时由自己释放。
  4. 环路等待条件： 指在发生死锁时， 必然存在一个进程——资源的环形链， 即进程集合{P0，P1，P2， ···，Pn}中的 P0 正在等待一个 P1 占用的资源； P1 正在等待 P2 占用的资源， ……，Pn 正在等待已被 P0 占用的资源。

        理解了死锁的原因，尤其是产生死锁的四个必要条件，就可以最大可能地避 免、预防和解除死锁。

        只要打破四个必要条件之一就能有效预防死锁的发生。

  1. 打破互斥条件：改造独占性资源为虚拟资源，大部分资源已无法改造。
  2. 打破不可抢占条件： 当一进程占有一独占性资源后又申请一独占性资源而无 法满足，则退出原占有的资源。
  3. 打破占有且申请条件： 采用资源预先分配策略， 即进程运行前申请全部资源， 满足则运行，不然就等待，这样就不会占有且申请。
  4. 打破循环等待条件： 实现资源有序分配策略， 对所有设备实现分类编号， 所 有进程只能采用按序号递增的形式申请资源。

        避免死锁常见的算法有有序资源分配法、银行家算法。

2.2.1.1 死锁的现象、危害和解决

        在我们 IT 世界有没有存在死锁的情况，有：数据库里多事务而且要同时操 作多个表的情况下。所以数据库设计的时候就考虑到了检测死锁和从死锁中恢复 的机制。比如 oracle 提供了检测和处理死锁的语句，而 mysql 也提供了“循环 依赖检测的机制”

        在 Java 世界里存在着多线程争夺多个资源，不可避免的存在着死锁。那么我们在编写代码的时候什么情况下会发生呢？

现象

2.2.1.2 简单顺序死锁
public class NormalDeadLock {

    private static Object No13 = new Object();//第一个锁
    private static Object No14 = new Object();//第二个锁

    private static void ZhangFeiDo() throws InterruptedException {
        String threadName = Thread.currentThread().getName();
        synchronized (No13){
            System.out.println(threadName + " get No13");
            Thread.sleep(100);
            synchronized (No14){
                System.out.println(threadName + " get No14");
            }
        }
    }

    private static void guanErYeDo() throws InterruptedException {
        String threadName = Thread.currentThread().getName();
        synchronized (No13){
            System.out.println(threadName + " get No13");
            Thread.sleep(100);
            synchronized (No14){
                System.out.println(threadName + " get No14");
            }
        }
    }

    private static class ZhangFei extends Thread{
        private String name;
        public ZhangFei(String name) {
            this.name = name;
        }
        @Override
        public void run() {
            Thread.currentThread().setName(name);
            try {
                ZhangFeiDo();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    private static class GuanErYe extends Thread{
        private String name;
        public GuanErYe(String name) {
            this.name = name;
        }
        @Override
        public void run() {
            Thread.currentThread().setName(name);
            try {
                guanErYeDo();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        GuanErYe guanErYe = new GuanErYe("GuanErYe");
        guanErYe.start();
        ZhangFei zhangFei = new ZhangFei("ZhangFei");
        zhangFei.start();
    }
}
2.1.2.3 动态顺序死锁

        顾名思义也是和获取锁的顺序有关，但是比较隐蔽，不像简单顺序死锁， 往往从代码一眼就看出获取锁的顺序不对。

public class DynamicDeadLock {

    private static Object No1 = new Object();//第一个锁
    private static Object No2 = new Object();//第二个锁

    /**
     * 公共业务方法
     */
    private static void businessDo(Object first,Object second) throws InterruptedException {
        String threadName = Thread.currentThread().getName();
        synchronized (first){
            System.out.println(threadName + " get first");
            Thread.sleep(100);
            synchronized (second){
                System.out.println(threadName + " get second");
            }
        }
    }

    private static class ZhangSan extends Thread{

        private String name;

        public ZhangSan(String name) {
            this.name = name;
        }

        @Override
        public void run() {
            Thread.currentThread().setName(name);
            try {
                businessDo(No1,No2);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //主线程
        Thread.currentThread().setName("lisi");
        ZhangSan zhangSan = new ZhangSan("zhangsan");
        zhangSan.start();
        businessDo(No1,No2);
    }
}

危害

  1. 线程不工作了，但是整个程序还是活着的。
  2. 没有任何的异常信息可以供我们检查。
  3. 一旦程序发生了发生了死锁，是没有任何的办法恢复的，只能重启程序，对生产平台的程序来说，这是个很严重的问题。
2.1.2.4 实际工作中的死锁

        死锁出现时间不定，不是每次必现；一旦出现没有任何异常信息，只知道这个应用的所有业务越来越慢，最后停止服务，无法确定是哪个具体业务导致的问题；测试部门也无法复现，并发量不够。

2.1.2.4.1 定位

        要解决死锁，当然要先找到死锁，通过 jps 查询应用的 id，再通过 jstack id 查看应用的锁的持有情况。

0
0
0
2.1.2.4.2 修正

        关键是保证拿锁的顺序一致。

/**
 *类说明：不会产生死锁
 */
public class SafeOperate {

    private static Object No1 = new Object();//第一个锁
    private static Object No2 = new Object();//第二个锁
    private static Object tieLock = new Object();//第三把锁

    public void transfer(Object first,Object second)
            throws InterruptedException {

        int firstHash = System.identityHashCode(first);
        int secondHash = System.identityHashCode(second);

        if(firstHash<secondHash){
            synchronized (first){
                System.out.println(Thread.currentThread().getName()+" get "+first);
                Thread.sleep(100);
                synchronized (second){
                    System.out.println(Thread.currentThread().getName()+" get "+second);
                }
            }
        }else if(secondHash<firstHash){
            synchronized (second){
                System.out.println(Thread.currentThread().getName()+" get"+second);
                Thread.sleep(100);
                synchronized (first){
                    System.out.println(Thread.currentThread().getName()+" get"+first);
                }
            }
        }else{
            synchronized (tieLock){
                synchronized (first){
                    synchronized (second){
                        System.out.println(Thread.currentThread().getName()+" get"+first);
                        System.out.println(Thread.currentThread().getName()+" get"+second);
                    }
                }
            }
        }
    }
}

两种解决方式

        内部通过顺序比较，确定拿锁的顺序；

/**
 *类说明：不会产生死锁
 */
public class SafeOperate {

    private static Object No1 = new Object();//第一个锁
    private static Object No2 = new Object();//第二个锁
    private static Object tieLock = new Object();//第三把锁

    public void transfer(Object first,Object second)
            throws InterruptedException {

        int firstHash = System.identityHashCode(first);
        int secondHash = System.identityHashCode(second);

        if(firstHash<secondHash){
            synchronized (first){
                System.out.println(Thread.currentThread().getName()+" get "+first);
                Thread.sleep(100);
                synchronized (second){
                    System.out.println(Thread.currentThread().getName()+" get "+second);
                }
            }
        }else if(secondHash<firstHash){
            synchronized (second){
                System.out.println(Thread.currentThread().getName()+" get"+second);
                Thread.sleep(100);
                synchronized (first){
                    System.out.println(Thread.currentThread().getName()+" get"+first);
                }
            }
        }else{
            synchronized (tieLock){
                synchronized (first){
                    synchronized (second){
                        System.out.println(Thread.currentThread().getName()+" get"+first);
                        System.out.println(Thread.currentThread().getName()+" get"+second);
                    }
                }
            }
        }
    }
}

        采用尝试拿锁的机制。

/**
 *类说明：演示普通账户的死锁和解决
 */
public class TryLock {
    
    private static Lock No1 = new ReentrantLock();//第一个锁
    private static Lock No2 = new ReentrantLock();//第二个锁

    // 先尝试拿No1 锁，再尝试拿No2锁，No2 锁没拿到，连同No1 锁一起释放掉
    private static void zhangsanDo() throws InterruptedException {
        String threadName = Thread.currentThread().getName();
        Random r = new Random();
        while(true){
            if(No1.tryLock()){
                System.out.println(threadName +" get 1");
                try{
                    if(No2.tryLock()){
                        try{
                            System.out.println(threadName  +" get 2");
                            System.out.println("zhangsanDo do work------------");
                            break;
                        }finally{
                            No2.unlock();
                        }
                    }
                }finally {
                    No1.unlock();
                }

            }
            //Thread.sleep(r.nextInt(3));
        }
    }

    //先尝试拿No2锁，再尝试拿No1锁，No1锁没拿到，连同No2锁一起释放掉
    private static void lisiDo() throws InterruptedException {
        String threadName = Thread.currentThread().getName();
        Random r = new Random();
        while(true){
            if(No2.tryLock()){
                System.out.println(threadName +" get 2");
                try{
                    if(No1.tryLock()){
                        try{
                            System.out.println(threadName +" get 1");
                            System.out.println("lisiDo do work------------");
                            break;
                        }finally{
                            No1.unlock();
                        }
                    }
                }finally {
                    No2.unlock();
                }

            }
            //Thread.sleep(r.nextInt(3));
        }
    }

    private static class ZhangSan extends Thread{

        private String name;

        public ZhangSan(String name) {
            this.name = name;
        }

        public void run(){
            Thread.currentThread().setName(name);
            try {
                zhangsanDo();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Thread.currentThread().setName("Monkey");
        ZhangSan zhangSan = new ZhangSan("ZhouYu");
        zhangSan.start();
        try {
            lisiDo();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

参见代码 cn.tulingxueyuan.safe.dl.TryLock 和 SafeOperate

其他安全问题

活锁

两个线程在尝试拿锁的机制中， 发生多个线程之间互相谦让， 不断发生同一 个线程总是拿到同一把锁，在尝试拿另一把锁时因为拿不到， 而将本来已经持有 的锁释放的过程。

解决办法：每个线程休眠随机数，错开拿锁的时间。

线程饥饿

低优先级的线程，总是拿不到执行时间

线程安全的单例模式

在设计模式中， 单例模式是比较常见的一种设计模式， 如何实现单例呢？ 一 种比较常见的是双重检查锁定。

双重检查锁定

0

上面的双重检查锁定却存在着线程安全问题，为什么呢？这是因为

singleDcl = new SingleDcl();

虽然只有一行代码，但是其实在具体执行的时候有好几步操作： 1 、JVM 为 SingleDcl 的对象实例在内存中分配空间

2、进行对象初始化，完成 new 操作

3 、JVM 把这个空间的地址赋给我们的引用 singleDcl

因为 JVM 内部的实现原理（指并发相关的重排序等， 后面的课程会学到） ， 会产生一种情况，第 3 步会在第 2 步之前执行。

于是在多线程下就会产生问题：A 线程正在 syn 同步块中执行 singleDcl = new SingleDcl()，此时 B 线程也来执行 getInstance()，进行了 singleDcl == null 的检查， 因为第 3 步会在第 2 步之前执行， B 线程检查发现 singleDcl 不为 null ，会直接拿 着 singleDcl 实例使用， 但是这时 A 线程还在执行对象初始化，这就导致 B 线程 拿到的 singleDcl 实例可能只初始化了一半，B 线程访问 singleDcl 实例中的对象域 就很有可能出错。

怎么解决这个问题呢？ 在前面声明 singleDcl 的位置：

private static SingleDcl singleDcl;

加上 volatile 关键字，变成 private volatile static SingleDcl singleDcl; 即可。

为何加上 volatile 关键字就行了呢，后面的课程在讲述JMM（Java 内存模型） 和 volatile 的原理会讲到。

单例模式推荐实现

懒汉式

类初始化模式，也叫延迟占位模式。在单例类的内部由一个私有静态内部类 来持有这个单例类的实例。 因为在 JVM 中， 对类的加载和类初始化，由虚拟机 保证线程安全。

0

延迟占位模式还可以用在多线程下实例域的延迟赋值。

饿汉式

在声明的时候就 new 这个类的实例，或者使用枚举也可以。

0

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

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

相关文章

九寨沟，智慧旅游新名片

九寨沟，智慧旅游新名片

九寨沟属于自然类景区&#xff0c;以优美的自然风光取胜&#xff0c;景区文化内涵相对缺失。智慧化和文旅融合是智慧文旅景区的两个必备条件&#xff0c;九寨沟在智慧文旅景区建设过程中&#xff0c;经历了两个阶段&#xff0c;先是从传统景区迈向智慧景区&#xff0c;然后是充…
阅读更多...
PostgreSQL学习笔记六：模式SCHEMA

PostgreSQL学习笔记六：模式SCHEMA

模式&#xff08;Schema&#xff09; PostgreSQL中的模式&#xff08;Schema&#xff09;是一个命名的数据库对象集合&#xff0c;包括表、视图、索引、数据类型、函数、存储过程和操作符等。模式的主要作用是组织和命名空间数据库对象&#xff0c;使得同一个数据库中可以包含…
阅读更多...
uniapp打包安卓apk步骤

uniapp打包安卓apk步骤

然后安装在手机上就可以啦
阅读更多...
MedMamba代码解释及用于糖尿病视网膜病变分类

MedMamba代码解释及用于糖尿病视网膜病变分类

MedMamba原理和用于糖尿病视网膜病变检测尝试 1.MedMamba原理 MedMamba发表于2024.9.28&#xff0c;是构建在Vision Mamba基础之上&#xff0c;融合了卷积神经网的架构&#xff0c;结构如下图&#xff1a; 原理简述就是图片输入后按通道输入后切分为两部分&#xff0c;一部分走…
阅读更多...
每日论文18-24ISCAS采用磁调谐变压器低温CMOS28GHzVCO

每日论文18-24ISCAS采用磁调谐变压器低温CMOS28GHzVCO

《28 GHz VCO Using Magnetically Tuning Trifilar Transformer in Cryogenic CMOS Application 》24ISCAS 瞟到了这篇文章&#xff0c;开关真的是可以加在任何地方哈哈哈&#xff0c;还挺特别 通过改变电感偏压来改变Var的偏压&#xff0c;来拓宽带宽&#xff0c;其实是个挺简…
阅读更多...
processing像素画教程

processing像素画教程

前提&#xff1a;各位已经安装了processing 第一步&#xff1a;创建一个简单的网格 我们首先创建一个网格来定义我们作品的像素画布。网格将帮助您在适当的位置绘制每个像素。 int gridSize 20; // 每个像素的大小 int cols, rows; void setup() {size(400, 400); // 设置画…
阅读更多...
k8s 的网络通信

k8s 的网络通信

目录 1 k8s通信整体架构 2 flannel 网络插件 2.1 flannel 插件组成 2.2 flannel 插件的通信过程 2.3 flannel 支持的后端模式 3 calico 网络插件 3.1 calico 简介 3.2 calico 网络架构 3.3 部署 calico 1 k8s通信整体架构 k8s通过CNI接口接入其他插件来实现网络通讯。目前比较…
阅读更多...
QTableView加入小灯泡

QTableView加入小灯泡

通过重载QAbstractTableModel中的data方法 QVariant CTblModel::data(const QModelIndex &index, int role) const { if (!index.isValid()) return QVariant(); int col index.column(); if (col ledColIndex && role Qt::DecorationRole) { return Q…
阅读更多...
股指期货的杠杆是怎么体现和使用的？

股指期货的杠杆是怎么体现和使用的？

股指期货的杠杆效应是通过保证金交易实现的。投资者只需支付合约价值的一小部分作为保证金&#xff0c;即可控制整个合约的价值。例如&#xff0c;如果一个股指期货合约的价值为100,000元&#xff0c;而保证金比例为10%&#xff0c;那么投资者只需支付10,000元即可控制这个合约…
阅读更多...
PPT分享：埃森哲-业务流程BPM能力框架体系

PPT分享：埃森哲-业务流程BPM能力框架体系

PPT下载链接见文末~ 业务流程管理&#xff08;BPM, Business Process Management&#xff09;的能力框架体系是一个全面、系统的流程管理方法论和工具集&#xff0c;旨在帮助企业优化和持续改进其业务流程&#xff0c;从而提升运营效率和市场竞争力。 一、BPM能力框架体系概述…
阅读更多...
云计算的江湖，风云再起

云计算的江湖，风云再起

大数据产业创新服务媒体 ——聚焦数据 改变商业 还记得当年英特尔的广告语吗&#xff1f;“Intel Inside”&#xff0c;这个标志性的标签几乎成了计算设备的象征。然而&#xff0c;随着AI大模型的迅速崛起&#xff0c;计算的核心从CPU悄然转向了GPU。一场前所未有的技术革命正…
阅读更多...
【学术会议征稿】第四届公共管理与大数据分析国际学术会议(PMBDA 2024)

【学术会议征稿】第四届公共管理与大数据分析国际学术会议(PMBDA 2024)

第四届公共管理与大数据分析国际学术会议(PMBDA 2024) 2024 4th International Conference on Public Management and Big Data Analysis 第四届公共管理与大数据分析国际学术会议 &#xff08;PMBDA 2024&#xff09;将于2024年12月20-22日在中国青岛召开。会议主题主要围绕…
阅读更多...
MySQL-表相关(DDL DML)

MySQL-表相关(DDL DML)

文章目录 表的基本操作表的创建表的删除 MySQL中的数据类型整数类型浮点数类型定点数类型日期和时间类型字符串类型charvarchartext 二进制类型 DDL语句查看建表语句修改表名新增字段修改字段(名类型)修改字段(仅类型)删除字段 表的基本操作 在介绍DDL和DQL的操作语句之前, 我…
阅读更多...
HCIP-HarmonyOS Application Developer 习题（六）

HCIP-HarmonyOS Application Developer 习题（六）

&#xff08;多选&#xff09;1、Harmonyos多窗口交互能力提供了以下哪几种交互方式? A. 平行视界 B.全局消息通知 C.分屏 D.悬浮窗 答案&#xff1a;ACD 分析&#xff1a;系统提供了悬浮窗、分屏、平行视界三种多窗口交互&#xff0c;为用户在大屏幕设备上的多任务并行、便捷…
阅读更多...
V2M2引擎传奇全套源码2024BLUE最新版 可自定义UI

V2M2引擎传奇全套源码2024BLUE最新版 可自定义UI

特点优势是最新XE10.4或者XE12编辑器&#xff0c;微端&#xff0c;各种自定义UI 无限仿GOM引擎功能下载地址:BlueCodePXL_415.rar官方版下载丨最新版下载丨绿色版下载丨APP下载-123云盘 提取码: AuX7BlueCodePXL_415.rar官方版下载丨最新版下载丨绿色版下载丨APP下载-123云盘…
阅读更多...
无需复杂计算！如何用“加法”打造高效而低功耗的语言模型

无需复杂计算！如何用“加法”打造高效而低功耗的语言模型

当我们聊到人工智能特别是语言模型时，大家脑海中可能浮现的都是庞大的计算能力、高能耗的服务器群。然而，最近有一篇有趣的论文《Addition Is All You Need for Energy-Efficient Language Models》（加法才是低能耗语言模型的关键）却颠覆了我们对语言模型的传统认知。那么，…
阅读更多...
Redis高级篇 —— 分布式缓存

Redis高级篇 —— 分布式缓存

Redis高级篇 —— 分布式缓存 文章目录 Redis高级篇 —— 分布式缓存1 Redis持久化1.1 RDB1.2 RDB的fork原理1.3 RDB总结1.4 AOF持久化1.5 RDB和AOF的对比 2 Redis主从2.1 搭建主从架构2.2 数据同步原理2.2.1 全量同步2.2.2 增量同步 3 Redis哨兵3.1 哨兵的作用和原理3.1.1 哨兵…
阅读更多...
基于IOU匹配的DeepSort目标跟踪与匈牙利算法解析

基于IOU匹配的DeepSort目标跟踪与匈牙利算法解析

在多目标跟踪任务中&#xff0c;如何将检测框与已有轨迹进行关联&#xff0c;进而维持目标的连续跟踪&#xff0c;是一个关键问题。DeepSort&#xff08;Deep Simple Online and Realtime Tracking&#xff09;是一种常用的多目标跟踪算法&#xff0c;它结合了IOU&#xff08;交…
阅读更多...
Linux搭建Hadoop集群（详细步骤）

Linux搭建Hadoop集群（详细步骤）

前言 Hadoop是一个由Apache基金会所开发的分布式系统基础架构。用户可以在不了解分布式底层细节的情况下&#xff0c;开发分布式程序。充分利用集群的威力进行高速运算和存储。 说白了就是实现一个任务可以在多个电脑上计算的过程。 一&#xff1a;准备工具 1.1 VMware 1.2L…
阅读更多...
利用内部知识库优化SOP与HR培训效果评估

利用内部知识库优化SOP与HR培训效果评估

在当今快速变化的商业环境中&#xff0c;企业运营的高效性和员工的综合能力成为决定竞争力的关键因素。SOP作为确保业务一致性和质量的基础&#xff0c;其有效执行至关重要。同时&#xff0c;HR培训作为提升员工技能和知识的重要手段&#xff0c;其效果直接影响到企业的整体绩效…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023