这些Java并发容器，你都了解吗？

文章目录

      • 前言
      • 并发容器
        • 1.ConcurrentHashMap 并发版 HashMap
          • 示例
        • 2.CopyOnWriteArrayList 并发版 ArrayList
          • 示例
        • 3.CopyOnWriteArraySet 并发 Set
          • 示例
        • 4.ConcurrentLinkedQueue 并发队列 (基于链表)
          • 示例
        • 5.ConcurrentLinkedDeque 并发队列 (基于双向链表)
          • 示例
        • 6.ConcurrentSkipListMap 基于跳表的并发 Map
          • 示例
        • 7.ConcurrentSkipListSet 基于跳表的并发 Set
          • 示例
        • 8.ArrayBlockingQueue 阻塞队列 (基于数组)
          • 示例
        • 9.LinkedBlockingQueue 阻塞队列 (基于链表)
          • 示例
        • 10.LinkedBlockingDeque 阻塞队列 (基于双向链表)
          • 示例
        • 11.PriorityBlockingQueue 线程安全的优先队列
          • 示例
        • 12.SynchronousQueue 数据同步交换的队列
          • 示例
        • 13.LinkedTransferQueue 基于链表的数据交换队列
          • 示例
        • 14.DelayQueue 延时队列
          • 示例
      • 总结
      • 写在最后

579a429daf314744b995f37351b46548

前言

在多线程环境下，数据的并发访问和修改是无法避免的问题。

为了解决这个问题，Java 提供了一系列并发容器，这些容器在内部已经处理了并发问题，使得我们可以在多线程环境下安全地访问和修改数据。

并发容器

1.ConcurrentHashMap 并发版 HashMap

最常见的并发容器之一，可以用作并发场景下的缓存。底层依然是哈希表，但在 JAVA 8 中有了不小的改变，而 JAVA 7 和 JAVA 8 都是用的比较多的版本，因此经常会将这两个版本的实现方式做一些比较（比如面试中）。

一个比较大的差异就是，JAVA 7 中采用分段锁来减少锁的竞争，JAVA 8 中放弃了分段锁，采用 CAS（一种乐观锁），同时为了防止哈希冲突严重时退化成链表（冲突时会在该位置生成一个链表，哈希值相同的对象就链在一起），会在链表长度达到阈值（8）后转换成红黑树（比起链表，树的查询效率更稳定）。

示例
import java.util.concurrent.*;

public class ConcurrentHashMapExample {
    public static void main(String[] args) {
        // Creating a ConcurrentHashMap
        ConcurrentHashMap<String, String> map = new ConcurrentHashMap<String, String>();

        // Adding elements to the ConcurrentHashMap
        map.put("Key1", "Value1");
        map.put("Key2", "Value2");
        map.put("Key3", "Value3");

        // Printing the ConcurrentHashMap
        System.out.println("ConcurrentHashMap: " + map);
    }
}
2.CopyOnWriteArrayList 并发版 ArrayList

并发版 ArrayList，底层结构也是数组，和 ArrayList 不同之处在于：当新增和删除元素时会创建一个新的数组，在新的数组中增加或者排除指定对象，最后用新增数组替换原来的数组。

CopyOnWriteArrayList 的主要特性是，每当列表修改时，例如添加或删除元素，它都会创建列表的一个新副本。原始列表和新副本都可以进行并发读取，这样就可以在不锁定整个列表的情况下进行并发读取。这种方法在读取操作远多于写入操作的场景中非常有用。

适用场景：由于读操作不加锁，写（增、删、改）操作加锁，因此适用于读多写少的场景。

局限：由于读的时候不会加锁（读的效率高，就和普通 ArrayList 一样），读取的当前副本，因此可能读取到脏数据。如果介意，建议不用。

看看源码感受下：

image-20201023223825079

示例
import java.util.concurrent.*;

public class CopyOnWriteArrayListExample {
    public static void main(String[] args) {
        // 创建一个 CopyOnWriteArrayList
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();

        // 向 CopyOnWriteArrayList 添加元素
        list.add("Element1");
        list.add("Element2");
        list.add("Element3");

        // 打印 CopyOnWriteArrayList
        System.out.println("CopyOnWriteArrayList: " + list);
    }
}
3.CopyOnWriteArraySet 并发 Set

基于 CopyOnWriteArrayList 实现（内含一个 CopyOnWriteArrayList 成员变量），也就是说底层是一个数组，意味着每次 add 都要遍历整个集合才能知道是否存在，不存在时需要插入（加锁）。

CopyOnWriteArraySet 的工作原理与 CopyOnWriteArrayList 类似。每当发生修改操作（如添加或删除元素）时，它都会创建集合的一个新副本。原始集合和新副本都可以进行并发读取，这样就可以在不锁定整个集合的情况下进行并发读取。这种方法在读取操作远多于写入操作的场景中非常有用。

适用场景：在 CopyOnWriteArrayList 适用场景下加一个，集合别太大（全部遍历伤不起）。

示例
import java.util.concurrent.*;

public class CopyOnWriteArraySetExample {
    public static void main(String[] args) {
        // 创建一个 CopyOnWriteArraySet
        CopyOnWriteArraySet<String> set = new CopyOnWriteArraySet<String>();

        // 向 CopyOnWriteArraySet 添加元素
        set.add("Element1");
        set.add("Element2");
        set.add("Element3");

        // 打印 CopyOnWriteArraySet
        System.out.println("CopyOnWriteArraySet: " + set);
    }
}
4.ConcurrentLinkedQueue 并发队列 (基于链表)

基于链表实现的并发队列，使用乐观锁 (CAS) 保证线程安全。因为数据结构是链表，所以理论上是没有队列大小限制的，也就是说添加数据一定能成功。

ConcurrentLinkedQueue 是 Java 并发包的一部分，它是基于链接节点的无界线程安全队列。它按照 FIFO（先进先出）的原则对元素进行排序。

ConcurrentLinkedQueue 的主要优点是它允许完全并发的插入，并且使用了一种高效的“wait-free”算法。

示例
import java.util.concurrent.*;

public class ConcurrentLinkedQueueExample {
    public static void main(String[] args) {
        // 创建一个 ConcurrentLinkedQueue
        ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<String>();

        // 向 ConcurrentLinkedQueue 添加元素
        queue.add("Element1");
        queue.add("Element2");
        queue.add("Element3");

        // 打印 ConcurrentLinkedQueue
        System.out.println("ConcurrentLinkedQueue: " + queue);
    }
}
5.ConcurrentLinkedDeque 并发队列 (基于双向链表)

基于双向链表实现的并发队列，可以分别对头尾进行操作，因此除了先进先出 (FIFO)，也可以先进后出（FILO），当然先进后出的话应该叫它栈了。

ConcurrentLinkedDeque 是 Java 并发包的一部分，它是一个基于链接节点的无界并发双端队列。在 ConcurrentLinkedDeque 中，添加、删除等操作可以在队列的两端进行，使其具有更高的并发性。

示例
import java.util.concurrent.*;

public class ConcurrentLinkedDequeExample {
    public static void main(String[] args) {
        // 创建一个 ConcurrentLinkedDeque
        ConcurrentLinkedDeque<String> deque = new ConcurrentLinkedDeque<String>();

        // 向 ConcurrentLinkedDeque 添加元素
        deque.add("Element1");
        deque.addFirst("Element2");
        deque.addLast("Element3");

        // 打印 ConcurrentLinkedDeque
        System.out.println("ConcurrentLinkedDeque: " + deque);
    }
}
6.ConcurrentSkipListMap 基于跳表的并发 Map

ConcurrentSkipListMap 是 Java 并发包的一部分，它是一个线程安全的排序映射表。它使用跳表的数据结构来保证元素的有序性和并发性。

跳表是一种可以进行二分查找的有序链表。ConcurrentSkipListMap 提供了预期的平均 log(n) 时间成本来执行 containsKey，get，put 和 remove 操作，并且它的并发性通常优于基于树的算法。

SkipList 即跳表，跳表是一种空间换时间的数据结构，通过冗余数据，将链表一层一层索引，达到类似二分查找的效果

image-20201023223853743

示例
import java.util.concurrent.*;

public class ConcurrentSkipListMapExample {
    public static void main(String[] args) {
        // 创建一个 ConcurrentSkipListMap
        ConcurrentSkipListMap<String, String> map = new ConcurrentSkipListMap<String, String>();

        // 向 ConcurrentSkipListMap 添加元素
        map.put("Key1", "Value1");
        map.put("Key2", "Value2");
        map.put("Key3", "Value3");

        // 打印 ConcurrentSkipListMap
        System.out.println("ConcurrentSkipListMap: " + map);
    }
}
7.ConcurrentSkipListSet 基于跳表的并发 Set

类似 HashSet 和 HashMap 的关系，ConcurrentSkipListSet 里面就是一个 ConcurrentSkipListMap，

ConcurrentSkipListSet 是 Java 并发包的一部分，它是一个线程安全的排序集合。它使用跳表的数据结构来保证元素的有序性和并发性。

跳表是一种可以进行二分查找的有序链表。ConcurrentSkipListSet 提供了预期的平均 log(n) 时间成本来执行 contains，add 和 remove 操作，并且它的并发性通常优于基于树的算法。

示例
import java.util.concurrent.*;

public class ConcurrentSkipListSetExample {
    public static void main(String[] args) {
        // 创建一个 ConcurrentSkipListSet
        ConcurrentSkipListSet<String> set = new ConcurrentSkipListSet<String>();

        // 向 ConcurrentSkipListSet 添加元素
        set.add("Element1");
        set.add("Element2");
        set.add("Element3");

        // 打印 ConcurrentSkipListSet
        System.out.println("ConcurrentSkipListSet: " + set);
    }
}
8.ArrayBlockingQueue 阻塞队列 (基于数组)

ArrayBlockingQueue 是 Java 并发包的一部分，它是一个基于数组的有界阻塞队列。此队列按 FIFO（先进先出）原则对元素进行排序。

ArrayBlockingQueue 在尝试插入元素到已满队列或从空队列中移除元素时，会导致线程阻塞，直到有空间或元素可用。

基于数组实现的可阻塞队列，构造时必须制定数组大小，往里面放东西时如果数组满了便会阻塞直到有位置（也支持直接返回和超时等待），通过一个锁 ReentrantLock 保证线程安全。

image-20201023223912400

乍一看会有点疑惑，读和写都是同一个锁，那要是空的时候正好一个读线程来了不会一直阻塞吗？

答案就在 notEmpty、notFull 里，这两个出自 lock 的小东西让锁有了类似 synchronized + wait + notify 的功能。传送门 → 终于搞懂了 sleep/wait/notify/notifyAll

示例
import java.util.concurrent.*;

public class ArrayBlockingQueueExample {
    public static void main(String[] args) {
        // 创建一个 ArrayBlockingQueue
        ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<String>(3);

        // 向 ArrayBlockingQueue 添加元素
        try {
            queue.put("Element1");
            queue.put("Element2");
            queue.put("Element3");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 打印 ArrayBlockingQueue
        System.out.println("ArrayBlockingQueue: " + queue);
    }
}
9.LinkedBlockingQueue 阻塞队列 (基于链表)

LinkedBlockingQueue 是 Java 并发包的一部分，它是一个基于链表的可选有界阻塞队列。此队列按照 FIFO（先进先出）的原则对元素进行排序。

LinkedBlockingQueue 在尝试插入元素到已满队列或从空队列中移除元素时，会导致线程阻塞，直到有空间或元素可用。

基于链表实现的阻塞队列，想比与不阻塞的 ConcurrentLinkedQueue，它多了一个容量限制，如果不设置默认为 int 最大值。

示例
import java.util.concurrent.*;

public class LinkedBlockingQueueExample {
    public static void main(String[] args) {
        // 创建一个 LinkedBlockingQueue
        LinkedBlockingQueue<String> queue = new LinkedBlockingQueue<String>(3);

        // 向 LinkedBlockingQueue 添加元素
        try {
            queue.put("Element1");
            queue.put("Element2");
            queue.put("Element3");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 打印 LinkedBlockingQueue
        System.out.println("LinkedBlockingQueue: " + queue);
    }
}
10.LinkedBlockingDeque 阻塞队列 (基于双向链表)

LinkedBlockingDeque 是 Java 并发包的一部分，它是一个基于链表的可选有界阻塞双端队列。此队列按照 FIFO（先进先出）的原则对元素进行排序。

LinkedBlockingDeque 在尝试插入元素到已满队列或从空队列中移除元素时，会导致线程阻塞，直到有空间或元素可用。双端队列的优势在于可以从两端插入或移除元素。

类似 LinkedBlockingQueue，但提供了双向链表特有的操作。

示例
import java.util.concurrent.*;

public class LinkedBlockingDequeExample {
    public static void main(String[] args) {
        // 创建一个 LinkedBlockingDeque
        LinkedBlockingDeque<String> deque = new LinkedBlockingDeque<String>(3);

        // 向 LinkedBlockingDeque 添加元素
        try {
            deque.putFirst("Element1");
            deque.putLast("Element2");
            deque.putFirst("Element3");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 打印 LinkedBlockingDeque
        System.out.println("LinkedBlockingDeque: " + deque);
    }
}
11.PriorityBlockingQueue 线程安全的优先队列

PriorityBlockingQueue 是 Java 并发包的一部分，它是一个无界的并发队列。它使用了和类 java.util.PriorityQueue 一样的排序规则，并且能够确保在并发环境下的线程安全。

PriorityBlockingQueue 中的元素按照自然顺序或者由比较器提供的顺序进行排序。队列不允许使用 null 元素。

构造时可以传入一个比较器，可以看做放进去的元素会被排序，然后读取的时候按顺序消费。某些低优先级的元素可能长期无法被消费，因为不断有更高优先级的元素进来。

示例
import java.util.concurrent.*;

public class PriorityBlockingQueueExample {
    public static void main(String[] args) {
        // 创建一个 PriorityBlockingQueue
        PriorityBlockingQueue<String> queue = new PriorityBlockingQueue<String>();

        // 向 PriorityBlockingQueue 添加元素
        queue.add("Element1");
        queue.add("Element2");
        queue.add("Element3");

        // 打印 PriorityBlockingQueue
        System.out.println("PriorityBlockingQueue: " + queue);
    }
}
12.SynchronousQueue 数据同步交换的队列

SynchronousQueue 是 Java 并发包的一部分，它是一个不存储元素的阻塞队列。每一个 put 操作必须等待一个 take 操作，否则不能继续添加元素，反之亦然。

这种特性使 SynchronousQueue 成为线程之间传递数据的好工具。它可以看作是一个传球手，负责把生产者线程处理的数据直接传递给消费者线程。

一个虚假的队列，因为它实际上没有真正用于存储元素的空间，每个插入操作都必须有对应的取出操作，没取出时无法继续放入。

示例
import java.util.concurrent.SynchronousQueue;

public class Main {
    
    public static void main(String[] args) {
        SynchronousQueue<Integer> queue = new SynchronousQueue<>();
        new Thread(()->{
            try{
                for(int i=0;;i++){
                    System.out.println("放入：" + i);
                    queue.put(i);
                }
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }).start();

        new Thread(()->{
            try{
                while(true){
                    System.out.println("取出：" + queue.take());
                    Thread.sleep((long)(Math.random()*2000));
                }
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }).start();
    }
}

运行结果：

取出：0
放入：0
取出：1
放入：1
放入：2
取出：2
取出：3
放入：3
取出：4
放入：4
...
...

可以看到，写入的线程没有任何 sleep，可以说是全力往队列放东西，而读取的线程又很不积极，读一个又 sleep 一会。输出的结果却是读写操作成对出现。

JAVA 中一个使用场景就是 Executors.newCachedThreadPool()，创建一个缓存线程池。

image-20201023223932760

13.LinkedTransferQueue 基于链表的数据交换队列

LinkedTransferQueue 是 Java 并发包的一部分，它是一个由链表结构组成的无界转移阻塞队列。队列按照 FIFO（先进先出）的原则对元素进行排序。

LinkedTransferQueue 的一个特性是，它可以尝试将元素直接转移给消费者，如果没有等待的消费者，元素就会被添加到队列的尾部，等待消费者来获取。

实现了接口 TransferQueue，通过 transfer 方法放入元素时，如果发现有线程在阻塞在取元素，会直接把这个元素给等待线程。如果没有人等着消费，那么会把这个元素放到队列尾部，并且此方法阻塞直到有人读取这个元素。和 SynchronousQueue 有点像，但比它更强大。

示例
import java.util.concurrent.*;

public class LinkedTransferQueueExample {
    public static void main(String[] args) {
        // 创建一个 LinkedTransferQueue
        LinkedTransferQueue<String> queue = new LinkedTransferQueue<String>();

        // 启动一个新线程来从 LinkedTransferQueue 取出元素
        new Thread(() -> {
            try {
                System.out.println("Taken: " + queue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        // 向 LinkedTransferQueue 添加一个元素
        try {
            queue.transfer("Element");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
14.DelayQueue 延时队列

DelayQueue 是 Java 并发包的一部分，它是一个无界阻塞队列，只有在延迟期满时才能从中提取元素。此队列的头部是延迟期满后保存时间最长的元素。如果延迟都还没有期满，则队列没有头部，并且 poll 将返回 null。

元素在 DelayQueue 中的顺序是按照其到期时间的先后顺序进行排序的，越早到期的元素越排在队列前面。延迟队列常用于实现定时任务功能。

可以使放入队列的元素在指定的延时后才被消费者取出，元素需要实现 Delayed 接口。

示例
import java.util.concurrent.*;

public class DelayQueueExample {
    public static void main(String[] args) {
        // 创建一个 DelayQueue
        DelayQueue<DelayedElement> queue = new DelayQueue<DelayedElement>();

        // 向 DelayQueue 添加一个元素，延迟 3 秒
        queue.put(new DelayedElement(3000, "Element"));

        // 从 DelayQueue 获取元素
        try {
            DelayedElement element = queue.take();
            System.out.println("Taken: " + element);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class DelayedElement implements Delayed {
    private long delayTime; // 延迟时间
    private long expire;  // 到期时间
    private String element; // 元素数据

    public DelayedElement(long delay, String element) {
        this.delayTime = delay;
        this.element = element;
        this.expire = System.currentTimeMillis() + delay;
    }

    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(expire - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
    }

    @Override
    public int compareTo(Delayed o) {
        return (int) (this.getDelay(TimeUnit.MILLISECONDS) - o.getDelay(TimeUnit.MILLISECONDS));
    }

    @Override
    public String toString() {
        return element;
    }
}

总结

从上面的介绍总总结有以下几种容器类

  1. ConcurrentHashMap：并发版 HashMap

  2. CopyOnWriteArrayList：并发版 ArrayList

  3. CopyOnWriteArraySet：并发 Set

  4. ConcurrentLinkedQueue：并发队列 (基于链表)

  5. ConcurrentLinkedDeque：并发队列 (基于双向链表)

  6. ConcurrentSkipListMap：基于跳表的并发 Map

  7. ConcurrentSkipListSet：基于跳表的并发 Set

  8. ArrayBlockingQueue：阻塞队列 (基于数组)

  9. LinkedBlockingQueue：阻塞队列 (基于链表)

  10. LinkedBlockingDeque：阻塞队列 (基于双向链表)

  11. PriorityBlockingQueue：线程安全的优先队列

  12. SynchronousQueue：读写成对的队列

  13. LinkedTransferQueue：基于链表的数据交换队列

  14. DelayQueue：延时队列

Java 并发容器为处理多线程环境下的数据访问和修改提供了强大的工具。

通过了解和学习这些并发容器，我们可以更好地理解并发编程，更有效地处理并发问题。

无论你是正在学习 Java，还是已经在使用 Java 进行开发，我都强烈建议你深入了解这些并发容器，它们将在你的并发编程之路上起到重要的作用。

写在最后

感谢您的支持和鼓励！ 😊🙏

如果大家对相关文章感兴趣，可以关注公众号"架构殿堂"，会持续更新AIGC，java基础面试题, netty, spring boot, spring cloud等系列文章，一系列干货随时送达!

csdn-end

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

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

相关文章

【LLM_05】使用fastgpt搭建本地离线大语言模型（Chatglm3）问答+知识库平台

【LLM_05】使用fastgpt搭建本地离线大语言模型（Chatglm3）问答+知识库平台

1、FastGPT 的知识库逻辑1.1 基础概念1.2 FastGPT知识库的导入1.3 FastGPT新建应用&#xff08;1&#xff09;创建一个知识库助手&#xff08;2&#xff09;创建一个python开发小助手 2、词向量比较测试2.1 开启词向量模型2.2 词向量模型性能比较 3、配置好之后的运行3.1 运行大…
阅读更多...
Redis ziplist源码解析

Redis ziplist源码解析

area |<---- ziplist header ---->|<----------- entries ------------->|<-end->|size 4 bytes 4 bytes 2 bytes ? ? ? ? 1 byte--------------------------------------------------------------- comp…
阅读更多...
多人聊天UDP

多人聊天UDP

服务端 package 多人聊天;import java.io.BufferedReader; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; import java.io.PrintStream; import java.net.ServerSocket; import java.net.Socket; import java.util.ArrayList;…
阅读更多...
第十六届山东省职业院校技能大赛中职组网络安全赛项竞赛正式试题

第十六届山东省职业院校技能大赛中职组网络安全赛项竞赛正式试题

第十六届山东省职业院校技能大赛中职组网络安全"赛项竞赛试题 一、竞赛时间 总计&#xff1a;360分钟 二、竞赛阶段 竞赛阶段任务阶段竞赛任务竞赛时间分值A、B模块A-1登录安全加固180分钟200分A-2本地安全策略设置A-3流量完整性保护A-4事件监控A-5服务加固A-6防火墙策…
阅读更多...
Error: Could not create the Java Virtual Machine（Linux启动tomcat成功后找不到进程8080端口）

Error: Could not create the Java Virtual Machine（Linux启动tomcat成功后找不到进程8080端口）

文章目录 问题解决问题过程Tomcat版本要求 问题解决 版本冲突&#xff0c;我的jdk是1.8.x&#xff0c; tomcat 是 10.1.x的&#xff0c;要求jdk是11。 问题过程 运行 ./startup.sh 显示如下&#xff1a; 还以为运行成功呢&#xff0c; 使用命令一查&#xff0c;根本查不到进…
阅读更多...
C语言进阶之路之内存镜像与字符操作函数篇

C语言进阶之路之内存镜像与字符操作函数篇

目录 一、学习目标&#xff1a; 二、内存镜像 什么是进程 C进程内存布局 栈内存 静态数据 数据段&#xff08;存储静态数据&#xff09;与代码段 堆内存 三、字符操作函数 函数strstr 函数strlen strlen与sizeof的区别 函数strtok 函数strcat与strncat 函数strc…
阅读更多...
记录 | python向上取整和向下取整

记录 | python向上取整和向下取整

python 向上取整和向下取整 向上取整 使用 ceil()&#xff1a; import mathx 0.55 x0 math.ceil(x)向下取整 使用 floor()&#xff1a; import mathx 0.55 x1 math.floor(x)如下&#xff1a;
阅读更多...
群聊Java

群聊Java

服务端 import java.io.*; import java.net.*; import java.util.ArrayList; public class Server{public static ServerSocket server_socket;public static ArrayList<Socket> socketListnew ArrayList<Socket>(); public static void main(String []args){try{…
阅读更多...
VR远程带看，助力线下门店线上化转型“自救”

VR远程带看，助力线下门店线上化转型“自救”

VR远程带看&#xff0c;因自身高效的沉浸式在线沟通功能&#xff0c;逐渐走进了大众的视野。身临其境的线上漫游体验以及实时同屏互联的新型交互模式&#xff0c;提升了商家同用户之间的沟通效率&#xff0c;进一步实现了远程线上一对一、一对多的同屏带看&#xff0c;用户足不…
阅读更多...
封装校验-----Vue3+ts项目

封装校验-----Vue3+ts项目

登录校验页面 <script setup lang"ts"> import { ref } from vue import { mobileRules, passwordRules } from /utils/rules const mobile ref() const password ref() </script><!-- 表单 --><van-form autocomplete"off">&l…
阅读更多...
使用Draw.io制作泳道图

使用Draw.io制作泳道图

使用Draw.io制作泳道图 一、横向泳道图1. 有标题泳道图2. 无标题泳道图3. 横纵向扩展泳道 二、纵向泳道图三、横纵交错地泳道图想做这样的图具体步骤1. 拖拽一个带标题的横向泳道图2. 拖拽一个带标题的单一图&#xff0c;并且把它放进Lane1中3. 其他注意 四、下载文件说明 一、…
阅读更多...
CSS的逻辑组合伪类

CSS的逻辑组合伪类

CSS 的逻辑组合伪类有 4 种&#xff0c;分别是&#xff1a;:not()、:is()、:where()和&#xff1a;has()。 否定伪类:not() :not 伪类选择器用来匹配不符合一组选择器的元素。由于它的作用是防止特定的元素被选中&#xff0c;它也被称为反选伪类&#xff08;negation pseudo-…
阅读更多...
走迷宫（详细分析）

走迷宫（详细分析）

目录 一、课题描述 输入样例&#xff1a; 输出样例&#xff1a; 二、需求分析 输入的形式和输入值的范围&#xff1a; 输出的形式&#xff1a; 程序所能达到的功能&#xff1a; 三、概要设计 四、流程图 五 、代码详细注释 六、测试数据和结果 一、课题描述 以一个…
阅读更多...
2024年江苏省职业院校技能大赛信息安全管理与评估 第三阶段学生组（样卷）

2024年江苏省职业院校技能大赛信息安全管理与评估 第三阶段学生组（样卷）

2024年江苏省职业院校技能大赛信息安全管理与评估 第三阶段学生组&#xff08;样卷&#xff09; 竞赛项目赛题 本文件为信息安全管理与评估项目竞赛-第三阶段样题&#xff0c;内容包括&#xff1a;网络安全渗透、理论技能与职业素养。 本次比赛时间为180分钟。 介绍 GeekSe…
阅读更多...
上海亚商投顾：沪指窄幅震荡 多只高位股午后跳水

上海亚商投顾：沪指窄幅震荡 多只高位股午后跳水

上海亚商投顾前言&#xff1a;无惧大盘涨跌&#xff0c;解密龙虎榜资金&#xff0c;跟踪一线游资和机构资金动向&#xff0c;识别短期热点和强势个股。 一.市场情绪 沪指昨日窄幅震荡&#xff0c;创业板指冲高回落。锂电池板块集体反弹&#xff0c;西藏矿业、吉翔股份、永兴材…
阅读更多...
01-Redis核心数据结构与高性能原理

01-Redis核心数据结构与高性能原理

一、Redis的单线程和高性能 1. Redis是单线程吗&#xff1f; Redis的单线程主要是指 Redis 的网络 IO 和键值对读写是由一个线程来完成的&#xff08;说白了也就是执行命令的时候是由一个线程来完成的&#xff09;&#xff0c;这也是 Redis 对外提供键值存储服务的主要流程。…
阅读更多...
基于epoll实现Reactor服务器

基于epoll实现Reactor服务器

了解epoll底层逻辑 在我们调用epoll_create的时候会创建出epoll模型&#xff0c;这个模型也是利用文件描述类似文件系统的方式控制该结构。 在我们调用epoll_create的时候&#xff0c;就会在内核管理中创建一个epoll模型&#xff0c;并且建管理模块地址给file结构体&#xff…
阅读更多...
python数据分析基础

python数据分析基础

前言 2023年10月以来&#xff0c;一位在商学院就读的可爱同学遇上了一门课——python数据分析&#xff0c;并遇到了许多问题&#xff0c;找上了我&#xff0c;就此&#xff0c;我也开始了学习之路&#xff0c;虽然很浅显&#xff0c;但这些东西对部门同学来说也是受用的&#…
阅读更多...
TypeScript中的单件设计模式

TypeScript中的单件设计模式

基本概念 &#xff08;1&#xff09; 了解设计模式 设计模式通俗的讲&#xff0c;就是一种更好的编写代码方案&#xff0c;打个比喻&#xff1a;从上海到武汉&#xff0c;你可以选择做飞机&#xff0c;做轮船&#xff0c;开车&#xff0c;骑摩托车多种方式&#xff0c;把出行…
阅读更多...
短视频购物系统源码：构建创新购物体验的技术深度解析

短视频购物系统源码：构建创新购物体验的技术深度解析

短视频购物系统作为电商领域的新宠&#xff0c;其背后的源码实现是其成功的关键。本文将深入探讨短视频购物系统的核心技术和源码设计&#xff0c;以揭示其如何构建创新购物体验的技术奥秘。 1. 技术架构与框架选择 短视频购物系统的源码首先考虑的是其技术架构。常见的选择…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站