LRU缓存替换策略及C#实现

news2024/11/30 2:46:00

LRU缓存替换策略

缓存是一种非常常见的设计，通过将数据缓存到访问速度更快的存储设备中，来提高数据的访问速度，如内存、CPU缓存、硬盘缓存等。

但与缓存的高速相对的是，缓存的成本较高，因此容量往往是有限的，当缓存满了之后，就需要一种策略来决定将哪些数据移除出缓存，以腾出空间来存储新的数据。

这样的策略被称为缓存替换策略（Cache Replacement Policy）。

常见的缓存替换策略有：FIFO（First In First Out）、LRU（Least Recently Used）、LFU（Least Frequently Used）等。

今天给大家介绍的是LRU算法。

核心思想

LRU算法基于这样一个假设：如果数据最近被访问过，那么将来被访问的几率也更高。

大部分情况下这个假设是成立的，因此LRU算法也是比较常用的缓存替换策略。

基于这个假设，我们在实现的时候，需要维护一个有序的数据结构，来记录数据的访问历史，当缓存满了之后，就可以根据这个数据结构来决定将哪些数据移除出缓存。

不适用场景

但如果数据的访问模式不符合LRU算法的假设，那么LRU算法就会失效。

例如：数据的访问模式是周期性的，那么LRU算法就会把周期性的数据淘汰掉，这样就会导致缓存命中率的下降。

换个说法比如，如果现在缓存的数据只在白天被访问，晚上访问的是另一批数据，那么在晚上，LRU算法就会把白天访问的数据淘汰掉，第二天白天又会把昨天晚上访问的数据淘汰掉，这样就会导致缓存命中率的下降。

后面有时间会给大家介绍LFU（Least Frequently Used）算法，以及LFU和LRU的结合LFRU（Least Frequently and Recently Used）算法，可以有效的解决这个问题。

算法基本实现

上文提到，LRU算法需要维护一个有序的数据结构，来记录数据的访问历史。通常我们会用双向链表来实现这个数据结构，因为双向链表可以在O(1)的时间复杂度内往链表的头部或者尾部插入数据，以及在O(1)的时间复杂度内删除数据。

我们将数据存储在双向链表中，每次访问数据的时候，就将数据移动到链表的尾部，这样就可以保证链表的尾部就是最近访问的数据，链表的头部就是最久没有被访问的数据。

当缓存满了之后，如果需要插入新的数据，因为链表的头部就是最久没有被访问的数据，所以我们就可以直接将链表的头部删除，然后将新的数据插入到链表的尾部。

如果我们要实现一个键值对的缓存，我们可以用一个哈希表来存储键值对，这样就可以在O(1)的时间复杂度内完成查找操作，.NET 中我们可以使用 Dictionary。

同时我们使用 LinkedList 来作为双向链表的实现，存储缓存的 key，以此记录数据的访问历史。

我们在每次操作 Dictionary 进行插入、删除、查找的时候，都需要将对应的 key 也插入、删除、移动到链表的尾部。

// 实现 IEnumerable 接口，方便遍历
public class LRUCache<TKey, TValue> : IEnumerable<KeyValuePair<TKey, TValue>>
{
    private readonly LinkedList<TKey> _list;

    private readonly Dictionary<TKey, TValue> _dictionary;

    private readonly int _capacity;
    
    public LRUCache(int capacity)
    {
        _capacity = capacity;
        _list = new LinkedList<TKey>();
        _dictionary = new Dictionary<TKey, TValue>();
    }

    public TValue Get(TKey key)
    {
        if (_dictionary.TryGetValue(key, out var value))
        {
            // 在链表中删除 key，然后将 key 添加到链表的尾部
            // 这样就可以保证链表的尾部就是最近访问的数据，链表的头部就是最久没有被访问的数据
            // 但是在链表中删除 key 的时间复杂度是 O(n)，所以这个算法的时间复杂度是 O(n)
            _list.Remove(key);
            _list.AddLast(key);
            return value;
        }

        return default;
    }

    public void Put(TKey key, TValue value)
    {
        if (_dictionary.TryGetValue(key, out _))
        {
            // 如果插入的 key 已经存在，将 key 对应的值更新，然后将 key 移动到链表的尾部
            _dictionary[key] = value;
            _list.Remove(key);
            _list.AddLast(key);
        }
        else
        {          
            if (_list.Count == _capacity)
            {
                // 缓存满了，删除链表的头部，也就是最久没有被访问的数据
                _dictionary.Remove(_list.First.Value);
                _list.RemoveFirst();
            }

            _list.AddLast(key);
            _dictionary.Add(key, value);
        }
    }

    public void Remove(TKey key)
    {
        if (_dictionary.TryGetValue(key, out _))
        {
            _dictionary.Remove(key);
            _list.Remove(key);
        }
    }

    public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
    {
        foreach (var key in _list)
        {
            yield return new KeyValuePair<TKey, TValue>(key, _dictionary[key]);
        }
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

var lruCache = new LRUCache<int, int>(4);

lruCache.Put(1, 1);
lruCache.Put(2, 2);
lruCache.Put(3, 3);
lruCache.Put(4, 4);

Console.WriteLine(string.Join(" ", lruCache));
Console.WriteLine(lruCache.Get(2));
Console.WriteLine(string.Join(" ", lruCache));
lruCache.Put(5, 5);
Console.WriteLine(string.Join(" ", lruCache));
lruCache.Remove(3);
Console.WriteLine(string.Join(" ", lruCache));

输出：

[1, 1] [2, 2] [3, 3] [4, 4] // 初始化
2                           // 访问 2
[1, 1] [3, 3] [4, 4] [2, 2] // 2 移动到链表尾部
[3, 3] [4, 4] [2, 2] [5, 5] // 插入 5
[4, 4] [2, 2] [5, 5]        // 删除 3

算法优化

上面的实现中，对缓存的查询、插入、删除都会涉及到链表中数据的删除（移动也是删除再插入）。

因为我们在 LinkedList 中存储的是 key，所以我们需要先通过 key 在链表中找到对应的节点，然后再进行删除操作，这就导致了链表的删除操作的时间复杂度是 O(n)。

虽然 Dictionary 的查找、插入、删除操作的时间复杂度都是 O(1)，但因为链表操作的时间复杂度是 O(n)，整个算法的最差时间复杂度是 O(n)。

算法优化的关键在于如何降低链表的删除操作的时间复杂度。

优化思路：

  1. 在 Dictionary 中存储 key 和 LinkedList 中节点的映射关系
  2. 在 LinkedList 的节点中存储 key-value

也就是说，我们让两个本来不相关的数据结构之间产生联系。

不管是在插入、删除、查找缓存的时候，都可以通过这种联系来将时间复杂度降低到 O(1)。

  1. 通过 key 在 Dictionary 中找到对应的节点，然后再从 LinkedList 节点中取出 value，时间复杂度是 O(1)
  2. LinkedList 删除数据之前，先通过 key 在 Dictionary 中找到对应的节点，然后再删除，这样就可以将链表的删除操作的时间复杂度降低到 O(1)
  3. LinkedList 删除头部节点时，因为节点中存储了 key，所以我们可以通过 key 在 Dictionary 中删除对应的节点，时间复杂度是 O(1)
public class LRUCache_V2<TKey, TValue> : IEnumerable<KeyValuePair<TKey, TValue>>
{
    private readonly LinkedList<KeyValuePair<TKey, TValue>> _list;
    
    private readonly Dictionary<TKey, LinkedListNode<KeyValuePair<TKey, TValue>>> _dictionary;
    
    private readonly int _capacity;
    
    public LRUCache_V2(int capacity)
    {
        _capacity = capacity;
        _list = new LinkedList<KeyValuePair<TKey, TValue>>();
        _dictionary = new Dictionary<TKey, LinkedListNode<KeyValuePair<TKey, TValue>>>();
    }
    
    public TValue Get(TKey key)
    {
        if (_dictionary.TryGetValue(key, out var node))
        {
            _list.Remove(node);
            _list.AddLast(node);
            return node.Value.Value;
        }
        
        return default;
    }
    
    public void Put(TKey key, TValue value)
    {
        if (_dictionary.TryGetValue(key, out var node))
        {
            node.Value = new KeyValuePair<TKey, TValue>(key, value);
            _list.Remove(node);
            _list.AddLast(node);
        }
        else
        {
            if (_list.Count == _capacity)
            {
                _dictionary.Remove(_list.First.Value.Key);
                _list.RemoveFirst();
            }
            
            var newNode = new LinkedListNode<KeyValuePair<TKey, TValue>>(new KeyValuePair<TKey, TValue>(key, value));
            _list.AddLast(newNode);
            _dictionary.Add(key, newNode);
        }
    }
    
    public void Remove(TKey key)
    {
        if (_dictionary.TryGetValue(key, out var node))
        {
            _dictionary.Remove(key);
            _list.Remove(node);
        }
    }

    public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
    {
        return _list.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

进一步优化

因为我们对 双向链表 的存储需求是定制化的，要求节点中存储 key-value，直接使用 C# 的 LinkedList 我们就需要用 KeyValuePair 这样的结构来间接存储，会导致一些不必要的内存开销。

我们可以自己实现一个双向链表，这样就可以直接在节点中存储 key-value，从而减少内存开销。

public class LRUCache_V3<TKey, TValue>
{
    private readonly DoubleLinkedListNode<TKey, TValue> _head;

    private readonly DoubleLinkedListNode<TKey, TValue> _tail;

    private readonly Dictionary<TKey, DoubleLinkedListNode<TKey, TValue>> _dictionary;

    private readonly int _capacity;

    public LRUCache_V3(int capacity)
    {
        _capacity = capacity;
        _head = new DoubleLinkedListNode<TKey, TValue>();
        _tail = new DoubleLinkedListNode<TKey, TValue>();
        _head.Next = _tail;
        _tail.Previous = _head;
        _dictionary = new Dictionary<TKey, DoubleLinkedListNode<TKey, TValue>>();
    }

    public TValue Get(TKey key)
    {
        if (_dictionary.TryGetValue(key, out var node))
        {
            RemoveNode(node);
            AddLastNode(node);
            return node.Value;
        }

        return default;
    }

    public void Put(TKey key, TValue value)
    {
        if (_dictionary.TryGetValue(key, out var node))
        {
            RemoveNode(node);
            AddLastNode(node);
            node.Value = value;
        }
        else
        {
            if (_dictionary.Count == _capacity)
            {
                var firstNode = RemoveFirstNode();

                _dictionary.Remove(firstNode.Key);
            }

            var newNode = new DoubleLinkedListNode<TKey, TValue>(key, value);
            AddLastNode(newNode);
            _dictionary.Add(key, newNode);
        }
    }

    public void Remove(TKey key)
    {
        if (_dictionary.TryGetValue(key, out var node))
        {
            _dictionary.Remove(key);
            RemoveNode(node);
        }
    }

    private void AddLastNode(DoubleLinkedListNode<TKey, TValue> node)
    {
        node.Previous = _tail.Previous;
        node.Next = _tail;
        _tail.Previous.Next = node;
        _tail.Previous = node;
    }

    private DoubleLinkedListNode<TKey, TValue> RemoveFirstNode()
    {
        var firstNode = _head.Next;
        _head.Next = firstNode.Next;
        firstNode.Next.Previous = _head;
        firstNode.Next = null;
        firstNode.Previous = null;
        return firstNode;
    }

    private void RemoveNode(DoubleLinkedListNode<TKey, TValue> node)
    {
        node.Previous.Next = node.Next;
        node.Next.Previous = node.Previous;
        node.Next = null;
        node.Previous = null;
    }
    
    internal class DoubleLinkedListNode<TKey, TValue>
    {    
        public DoubleLinkedListNode()
        {
        }

        public DoubleLinkedListNode(TKey key, TValue value)
        {
            Key = key;
            Value = value;
        }

        public TKey Key { get; set; }
        
        public TValue Value { get; set; }

        public DoubleLinkedListNode<TKey, TValue> Previous { get; set; }

        public DoubleLinkedListNode<TKey, TValue> Next { get; set; }
    }
}

Benchmark

使用 BenchmarkDotNet 对3个版本进行性能测试对比。

[MemoryDiagnoser]
public class WriteBenchmarks
{
    // 保证写入的数据有一定的重复性，借此来测试LRU的最差时间复杂度
    private const int Capacity = 1000;
    private const int DataSize = 10_0000;
    
    private List<int> _data;

    [GlobalSetup]
    public void Setup()
    {
        _data = new List<int>();
        var shared = Random.Shared;
        for (int i = 0; i < DataSize; i++)
        {
            _data.Add(shared.Next(0, DataSize / 10));
        }
    }
    
    [Benchmark]
    public void LRUCache_V1()
    {
        var cache = new LRUCache<int, int>(Capacity);
        foreach (var item in _data)
        {
            cache.Put(item, item);
        }
    }
    
    [Benchmark]
    public void LRUCache_V2()
    {
        var cache = new LRUCache_V2<int, int>(Capacity);
        foreach (var item in _data)
        {
            cache.Put(item, item);
        }
    }
    
    [Benchmark]
    public void LRUCache_V3()
    {
        var cache = new LRUCache_V3<int, int>(Capacity);
        foreach (var item in _data)
        {
            cache.Put(item, item);
        }
    }
}

public class ReadBenchmarks
{
    // 保证写入的数据有一定的重复性，借此来测试LRU的最差时间复杂度
    private const int Capacity = 1000;
    private const int DataSize = 10_0000;
    
    private List<int> _data;
    private LRUCache<int, int> _cacheV1;
    private LRUCache_V2<int, int> _cacheV2;
    private LRUCache_V3<int, int> _cacheV3;

    [GlobalSetup]
    public void Setup()
    {
        _cacheV1 = new LRUCache<int, int>(Capacity);
        _cacheV2 = new LRUCache_V2<int, int>(Capacity);
        _cacheV3 = new LRUCache_V3<int, int>(Capacity);
        _data = new List<int>();
        var shared = Random.Shared;
        for (int i = 0; i < DataSize; i++)
        {
            int dataToPut  = shared.Next(0, DataSize / 10);
            int dataToGet = shared.Next(0, DataSize / 10);
            _data.Add(dataToGet);
            _cacheV1.Put(dataToPut, dataToPut);
            _cacheV2.Put(dataToPut, dataToPut);
            _cacheV3.Put(dataToPut, dataToPut);
        }
    }
    
    [Benchmark]
    public void LRUCache_V1()
    {
        foreach (var item in _data)
        {
            _cacheV1.Get(item);
        }
    }
    
    [Benchmark]
    public void LRUCache_V2()
    {
        foreach (var item in _data)
        {
            _cacheV2.Get(item);
        }
    }
    
    [Benchmark]
    public void LRUCache_V3()
    {
        foreach (var item in _data)
        {
            _cacheV3.Get(item);
        }
    }
}

写入性能测试结果：

|      Method |      Mean |     Error |    StdDev |    Median |     Gen0 |     Gen1 | Allocated |
|------------ |----------:|----------:|----------:|----------:|---------:|---------:|----------:|
| LRUCache_V1 | 16.890 ms | 0.3344 ms | 0.8012 ms | 16.751 ms | 750.0000 | 218.7500 |   4.65 MB |
| LRUCache_V2 |  7.193 ms | 0.1395 ms | 0.3958 ms |  7.063 ms | 703.1250 | 226.5625 |   4.22 MB |
| LRUCache_V3 |  5.761 ms | 0.1102 ms | 0.1132 ms |  5.742 ms | 585.9375 | 187.5000 |   3.53 MB |

查询性能测试结果：

|      Method |      Mean |     Error |    StdDev |    Gen0 | Allocated |
|------------ |----------:|----------:|----------:|--------:|----------:|
| LRUCache_V1 | 19.475 ms | 0.3824 ms | 0.3390 ms | 62.5000 |  474462 B |
| LRUCache_V2 |  1.994 ms | 0.0273 ms | 0.0242 ms |       - |       4 B |
| LRUCache_V3 |  1.595 ms | 0.0187 ms | 0.0175 ms |       - |       3 B |

欢迎关注博主技术公众号：EventHorizonCLI

介绍一款低调且强大的开发工具：JNPF快速开发平台。采用的是最新主流前后分离框架（SpringBoot+Mybatis-plus+Ant-Design+Vue3）。代码生成器依赖性低，灵活的扩展能力，可灵活实现二次开发。

为了支撑更高技术要求的应用开发，从数据库建模、Web API构建到页面设计，与传统软件开发几乎没有差异，只是通过低代码可视化模式，减少了构建“增删改查”功能的重复劳动。

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

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

相关文章

sqlite3交叉编译

sqlite3交叉编译

1、交叉编译sqllite3可以先从官网下载最新最新的源码进行编译。sqlite3下载sqlite3有两种版本的源代码&#xff0c;sqlite-amalgamation-3420000.zip这种是将所有的操作放到sqlite3中进行使用的。虽然官方推荐使用这种方法。但是对于嵌入式移植还是使用sqlite-autoconf-3420000…
阅读更多...
23款奔驰GLE450动感型升级柏林之声音响系统，体验不一样的感觉

23款奔驰GLE450动感型升级柏林之声音响系统，体验不一样的感觉

奔驰GLE450动感型升级柏林之声的音响效果自然非同凡响&#xff0c;在人声、交响乐音乐厅感受方面都有非常逼真的现场感受&#xff0c;结合柏林之声的界面调整&#xff0c;可以在不同方位体验的高保真的音乐之享&#xff01; 小柏林音响总共13个喇叭1台功放由4个高音、4个中音、…
阅读更多...
Linux 创建文件的12种方法总结

Linux 创建文件的12种方法总结

在Linux中&#xff0c;可以使用多种方法来创建文件。以下是一些常见的方法&#xff1a; 1. touch命令 touch filename&#xff0c;用于创建一个空文件。如果文件已存在&#xff0c;则只更新其访问时间和修改时间。 touch 命令通常用于将文件的访问和修改时间更新为当前时间。…
阅读更多...
基于知识蒸馏的去雪、去雾、去雨算法

基于知识蒸馏的去雪、去雾、去雨算法

今天来详细学习一篇去雪、去雨、去雾三合一的去噪算法 代码地址&#xff1a; https://github.com/fingerk28/Two-stage-Knowledge-For-Multiple-Adverse-Weather-Removal 论文地址&#xff1a; https://openaccess.thecvf.com/content/CVPR2022/papers/Chen_Learning_Multiple_…
阅读更多...
Python（二）：Python简介

Python（二）：Python简介

❤️ 专栏简介&#xff1a;本专栏记录了我个人从零开始学习Python编程的过程。在这个专栏中&#xff0c;我将分享我在学习Python的过程中的学习笔记、学习路线以及各个知识点。 ☀️ 专栏适用人群 &#xff1a;本专栏适用于希望学习Python编程的初学者和有一定编程基础的人。无…
阅读更多...
ELFK——ELK结合filebeat日志分析系统（纵使生活万般磨难，也要笑对生活）

ELFK——ELK结合filebeat日志分析系统（纵使生活万般磨难，也要笑对生活）

文章目录 一、filebeat二、ELFK1.原理简介 三、部署FilebeatELK1.解压安装2.设置 filebeat 的主配置文件3.启动 filebeat4&#xff0e;在 Logstash 组件所在节点上新建一个 Logstash 配置文件5&#xff0e;测试 一、filebeat Filebeat&#xff0c;轻量级的开源日志文件数据搜集…
阅读更多...
高精度电流源怎么用

高精度电流源怎么用

高精度电流源是一种用于产生高精度、高稳定性和低噪声的直流或交流电流信号的设备。它主要应用于各种实验和测试领域&#xff0c;例如半导体器件测试、传感器校准、精密测量和医疗检测等。高精度电流源的作用是提供可靠的电流输出信号&#xff0c;在实验和测试中获得精确和准确…
阅读更多...
聚焦地下停车场污染死角｜气体检测仪让您一目了然

聚焦地下停车场污染死角｜气体检测仪让您一目了然

由于地下停车场属于封闭式或半封闭式建筑&#xff0c;近年来越来越多高端住宅、办公楼宇的物业管理者收到投诉反应地下停车场的空气质量差的问题。那么地下空气污染有哪些呢&#xff1f; 根据空气监测工程师的检测表明&#xff0c;与地面不同&#xff0c;地下停车场的汽车起动…
阅读更多...
一次元数据空间内存溢出的排查记录 | 京东云技术团队

一次元数据空间内存溢出的排查记录 | 京东云技术团队

在应用中&#xff0c;我们使用的 SpringData ES的 ElasticsearchRestTemplate来做查询&#xff0c;使用方式不对&#xff0c;导致每次ES查询时都新实例化了一个查询对象&#xff0c;会加载相关类到元数据中。最终长时间运行后元数据出现内存溢出&#xff1b; 问题原因&#xf…
阅读更多...
vue 动态引入图片地址的方法

vue 动态引入图片地址的方法

我们直接使用 v-bind 的方式导入无法正常导入 <image :src"item.src" alt""/> 是因为 页面显示为htmlcssjs而vue变成我们可以看到的样子是需要打包变成htmlcssjs的&#xff0c; 在打包过程中将item.src的变量 取出变成/image/icon.svg只是 将地址…
阅读更多...
集中式自动抄表系统原理与应用

集中式自动抄表系统原理与应用

集中式自动抄表系统是一种自动采集电表、水表、气表等计量数据的系统&#xff0c;其原理是通过一定的通信方式&#xff0c;将计量数据从表端传输到数据采集器&#xff0c;再由数据采集器上传至云端或后台处理系统&#xff0c;从而实现对表数据的自动采集、统计和分析。 集中式…
阅读更多...
机器学习之随机森林（Random forest）

机器学习之随机森林（Random forest）

1 什么是随机森林 随机森林是一种监督式算法&#xff0c;使用由众多决策树组成的一种集成学习方法&#xff0c;输出是对问题最佳答案的共识。随机森林可用于分类或回归&#xff0c;是一种主流的集成学习算法。 1.1 随机森林算法原理 随机森林中有许多的分类树。我们要将一个输…
阅读更多...
【Spring】使用注解读取和存储Bean对象

【Spring】使用注解读取和存储Bean对象

哈喽&#xff0c;哈喽&#xff0c;大家好~ 我是你们的老朋友&#xff1a;保护小周ღ 谈起Java 圈子里的框架&#xff0c;最年长最耀眼的莫过于 Spring 框架啦&#xff0c;本期给大家带来的是&#xff1a; 将对象存储到 Spring 中、Bean 对象的命名规则、从Spring 中获取bean …
阅读更多...
解决github无法拉取submodule子模块的问题

解决github无法拉取submodule子模块的问题

引言 当使用git clone --recursive url 拉取一个配置了子模块的仓库后&#xff0c;会卡住。 同时在使用git clone 拉去https的url时&#xff0c;同样可能会出现一直卡在cloning int reposity...本文提供一个简单的脚本来解决该问题。 前置准备 需要配置好git的相关配置&…
阅读更多...
今年第十个零日漏洞，苹果发布紧急更新

今年第十个零日漏洞，苹果发布紧急更新

苹果于7月10日发布了新一轮快速安全响应 (RSR) 更新&#xff0c;以解决在攻击中利用的一个新零日漏洞。 苹果在iOS和macOS的更新公告中引用了一位匿名安全专家对该漏洞&#xff08;CVE-2023-37450&#xff09;的描述&#xff0c;表示“苹果已获悉有关此漏洞可能已被积极利用的…
阅读更多...
自动化测试集成指南 -- 本地单元测试

自动化测试集成指南 -- 本地单元测试

构建本地单元测试 简介&#xff1a; 单元测试(Unit Test) 是针对 程序的最小单元 来进行正确性检验的测试工作。程序单元是应用的最小可测试部件。一个单元可能是单个程序、类、对象、方法等。 如何区分单元测试和集成测试&#xff0c;一般情况下&#xff0c;单元测试应该不…
阅读更多...
jacoco merge 合并代码覆盖率（同一个项目代码没有修改）

jacoco merge 合并代码覆盖率（同一个项目代码没有修改）

相关文章&#xff1a; jacoco代码覆盖率_jacoco覆盖率_做测试的喵酱的博客-CSDN博客 一、背景 前提&#xff1a; 同一个项目&#xff0c;代码没有修改的情况下&#xff0c;合并多个代码覆盖率&#xff0c;实现全量代码覆盖率。 java -jar jacococli.jar merge jacoco.exec …
阅读更多...
PFC-34、PMO-78、HD3-AMPS比例控制阀放大器

PFC-34、PMO-78、HD3-AMPS比例控制阀放大器

比例驱动放大器 用于HD2-PS、HD3-PS、HD3-AMPS、HD3-PS8、HD5-PS、HD3-PMO、PMO-78、PRO-M24、AMF-RE、PFC-34、PFC-78、PFP3-78电磁比例阀 DIN 连接器安装 微控制器设计 独立调整&#xff08;斜坡上升 - 斜坡下降&#xff09; 3位LED显示屏 显示和调整实际值&#xff08…
阅读更多...
转换成mp4格式的方法有哪些？分享两个给大家！

转换成mp4格式的方法有哪些？分享两个给大家！

在数字化的世界中&#xff0c;我们经常需要处理各种格式的视频文件。MP4是一种非常常见的视频格式&#xff0c;由于其优秀的兼容性和较小的文件大小&#xff0c;它被广泛用于在线播放、视频编辑和共享。然而&#xff0c;我们可能会遇到一些非MP4格式的视频文件&#xff0c;这就…
阅读更多...
YOLO V5 ROS功能包配置及运行（亲测可用、附ROS功能包源码）

YOLO V5 ROS功能包配置及运行（亲测可用、附ROS功能包源码）

一、 依赖项 1. Ubuntu 18.04 安装opencv 4.2.0/4.6.0链接&#xff1a; 查看当前opencv版本 pkg-config --modversion opencv 安装opencv 4.2.0链接&#xff1a; https://note.youdao.com/s/R6ddu2ou 2. 安装PyTorch 官网链接&#xff1a; https://pytorch.org/get-started…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023