redis底层数据结构

底层数据结构

了解下这些咱常用的数据其底层实现是啥

在提到使用哪类数据结构之前，先来了解下redis底层到底有多少种数据结构

1，sds动态字符串
概念与由来

redis是一种使用C语言编写的nosql，redis存储的key数据均为string结构，value往往是字符串或者字符串的集合

但是redis底层未使用C语言本身的字符串，有如下几点原因

  • 获取字符串长度的需要通过运算

    • 需要一个字符串的长度时，你可能会调用strlen函数，那么这个函数是如何获取字符串的长度的呢，通过从头开始遍历，直到遍历道/0截止，这个时间复杂度为O(n),对于redis这类需高性能的nosql显然不适用

  • 非二进制安全

    • C语言字符串是使用char数组存储，以'\0'作为字符串结束，比如字符串”Redis“在C语言中存储结构就是下面这样

  因此假设有一类场景需保存0101010101这类二进制数据字符串"0101010101"

  字符串结尾以"\0"表示，因此字符串内容本身不能包含"\0"，因此不能保存二进制数据，由于这个限制使得 C 语⾔的字符串只能保存⽂本数据，不能保存像图⽚、⾳频、视频⽂化这 样的⼆进制数据

  • 不可修改

    • 字符串字面量（Literal）：在C语言中，字符串常量（例如通过双引号直接定义的字符串）存储在只读内存段中。这意味着你无法修改这些内存中的内容，因为操作系统会保护这些内存区域不被修改。

char *str = "Hello";
str[0] = 'J';  // 这将导致运行时错误，因为"Hello"存储在只读内存中

  • 字符数组的不可变内容：即使是通过字符数组定义的字符串，如果你试图修改其内容而没有正确地分配可修改的内存（例如使用malloc或strdup），也会导致运行时错误。

char str[] = "Hello";
str[0] = 'J';  // 这在某些编译器下可能编译通过，但不保证在其他编译器或环境中有效，因为编译器可能会优化存储方式

  • 每次拼接字符串的时候都需要提交扩容

  • 缓存溢出风险

    • 每次拼接字符串的时候都需要提交扩容，当需扩容的长度未知的时候则很可能会发生缓存溢出风险

因此redis构建一种全新的字符串：SDS动态字符串

struct __attribute__ ((__packed__)) sdshdr8 {uint8_t len; /* buf已保存的字符串字节数，不包含结束标示*/uint8_t alloc; /* buf申请的总的字节数，不包含结束标示*/unsigned char flags; /* 不同SDS的头类型，用来控制SDS的头大小char buf[];
};

"name"的动态字符串结构：包括

  • len：字符串的长度也就是已经使用的字节数，通过这个参数定义，能够以O(1)的时间复杂度知道字符串的长度

  • alloc：总共可用的字符空间大小，alloc-len 就是 SDS 剩余的空间大小

  • buf[]：实际存储字符串的数组

  • flags：低三位保存类型标志

动态字符串五类实现

src/sds.h

/* Note: sdshdr5 is never used, we just access the flags byte directly.* However is here to document the layout of type 5 SDS strings. */
struct __attribute__ ((__packed__)) sdshdr5 {unsigned char flags; /* 3 lsb of type, and 5 msb of string length */char buf[];
};
struct __attribute__ ((__packed__)) sdshdr8 {uint8_t len; /* used */uint8_t alloc; /* excluding the header and null terminator */unsigned char flags; /* 3 lsb of type, 5 unused bits */char buf[];
};
struct __attribute__ ((__packed__)) sdshdr16 {uint16_t len; /* used */uint16_t alloc; /* excluding the header and null terminator */unsigned char flags; /* 3 lsb of type, 5 unused bits */char buf[];
};
struct __attribute__ ((__packed__)) sdshdr32 {uint32_t len; /* used */uint32_t alloc; /* excluding the header and null terminator */unsigned char flags; /* 3 lsb of type, 5 unused bits */char buf[];
};
struct __attribute__ ((__packed__)) sdshdr64 {uint64_t len; /* used */uint64_t alloc; /* excluding the header and null terminator */unsigned char flags; /* 3 lsb of type, 5 unused bits */char buf[];
};#define SDS_TYPE_5  0
#define SDS_TYPE_8  1
#define SDS_TYPE_16 2
#define SDS_TYPE_32 3
#define SDS_TYPE_64 4

了解了动态字符串的概念了，那为啥它叫做动态字符串呢，这是由于它具备动态扩容的能力

接下来看个例子

/* Enlarge the free space at the end of the sds string so that the caller* is sure that after calling this function can overwrite up to addlen* bytes after the end of the string, plus one more byte for nul term.* If there's already sufficient free space, this function returns without any* action, if there isn't sufficient free space, it'll allocate what's missing,* and possibly more:* When greedy is 1, enlarge more than needed, to avoid need for future reallocs* on incremental growth.* When greedy is 0, enlarge just enough so that there's free space for 'addlen'.** Note: this does not change the *length* of the sds string as returned* by sdslen(), but only the free buffer space we have. */
sds _sdsMakeRoomFor(sds s, size_t addlen, int greedy) {void *sh, *newsh;size_t avail = sdsavail(s);size_t len, newlen, reqlen;char type, oldtype = s[-1] & SDS_TYPE_MASK;int hdrlen;size_t usable;/* Return ASAP if there is enough space left. */if (avail >= addlen) return s;len = sdslen(s);sh = (char*)s-sdsHdrSize(oldtype);reqlen = newlen = (len+addlen);assert(newlen > len);   /* Catch size_t overflow */if (greedy == 1) {if (newlen < SDS_MAX_PREALLOC)newlen *= 2;elsenewlen += SDS_MAX_PREALLOC;}type = sdsReqType(newlen);/* Don't use type 5: the user is appending to the string and type 5 is* not able to remember empty space, so sdsMakeRoomFor() must be called* at every appending operation. */if (type == SDS_TYPE_5) type = SDS_TYPE_8;hdrlen = sdsHdrSize(type);assert(hdrlen + newlen + 1 > reqlen);  /* Catch size_t overflow */if (oldtype==type) {newsh = s_realloc_usable(sh, hdrlen+newlen+1, &usable);if (newsh == NULL) return NULL;s = (char*)newsh+hdrlen;} else {/* Since the header size changes, need to move the string forward,* and can't use realloc */newsh = s_malloc_usable(hdrlen+newlen+1, &usable);if (newsh == NULL) return NULL;memcpy((char*)newsh+hdrlen, s, len+1);s_free(sh);s = (char*)newsh+hdrlen;s[-1] = type;sdssetlen(s, len);}usable = usable-hdrlen-1;if (usable > sdsTypeMaxSize(type))usable = sdsTypeMaxSize(type);sdssetalloc(s, usable);return s;
}
2，IntSet

注意contents采用的有符号的 占据2个字节 1个字节8个比特位，由于会区分正负数，所以占据2个字节

结构

为了方便查找，Redis会将intset中所有的整数按照升序依次保存在contents数组中

intset升级

场景：当存储的整数数据超过了当前intset的编码会进行intset升级

插入数据源码

intset *intsetAdd(intset *is, int64_t value, uint8_t *success) {uint8_t valenc = _intsetValueEncoding(value);// 获取当前值编码uint32_t pos; // 要插入的位置if (success) *success = 1;// 判断编码是不是超过了当前intset的编码if (valenc > intrev32ifbe(is->encoding)) {// 超出编码，需要升级return intsetUpgradeAndAdd(is,value);} else {// 在当前intset中查找值与value一样的元素的角标posif (intsetSearch(is,value,&pos)) {if (success) *success = 0; //如果找到了，则无需插入，直接结束并返回失败return is;}// 数组扩容is = intsetResize(is,intrev32ifbe(is->length)+1);// 移动数组中pos之后的元素到pos+1，给新元素腾出空间if (pos < intrev32ifbe(is->length)) intsetMoveTail(is,pos,pos+1);}// 插入新元素_intsetSet(is,pos,value);// 重置元素长度is->length = intrev32ifbe(intrev32ifbe(is->length)+1);return is;
}

升级

static intset *intsetUpgradeAndAdd(intset *is, int64_t value) {// 获取当前intset编码uint8_t curenc = intrev32ifbe(is->encoding);// 获取新编码uint8_t newenc = _intsetValueEncoding(value);// 获取元素个数int length = intrev32ifbe(is->length); // 判断新元素是大于0还是小于0 ，小于0插入队首、大于0插入队尾int prepend = value < 0 ? 1 : 0;// 重置编码为新编码is->encoding = intrev32ifbe(newenc);// 重置数组大小is = intsetResize(is,intrev32ifbe(is->length)+1);// 倒序遍历，逐个搬运元素到新的位置，_intsetGetEncoded按照旧编码方式查找旧元素while(length--) // _intsetSet按照新编码方式插入新元素_intsetSet(is,length+prepend,_intsetGetEncoded(is,length,curenc));/* 插入新元素，prepend决定是队首还是队尾*/if (prepend)_intsetSet(is,0,value);else_intsetSet(is,intrev32ifbe(is->length),value);// 修改数组长度is->length = intrev32ifbe(intrev32ifbe(is->length)+1);return is;
}

特点：

  • Redis会确保Intset中的元素唯一、有序

    • 可以从插入源码看出 在找到了相同的元素的时候会直接返回失败，这里保证了元素唯一不重复

// 在当前intset中查找值与value一样的元素的角标posif (intsetSearch(is,value,&pos)) {if (success) *success = 0; //如果找到了，则无需插入，直接结束并返回失败return is;}

  • 具备类型升级机制，可以节省内存空间

    • intsetUpgradeAndAdd实现

  • 底层采用二分查找方式来查询

3，dict

我们知道Redis是一个键值型（Key-Value Pair）的数据库，我们可以根据键实现快速的增删改查。而键与值的映射关系正是通过Dict来实现的。

Dict由三部分组成，分别是：哈希表（DictHashTable）、哈希节点（DictEntry）、字典（Dict）

结构

当我们向Dict添加键值对时，Redis首先根据key计算出hash值（h），然后利用 h & sizemask来计算元素应该存储到数组中的哪个索引位置。

举例：我们存储k1=v1，假设k1的哈希值h =1，则1&3 =1，因此k1=v1要存储到数组角标1位置。

Dict由三部分组成，分别是：哈希表（DictHashTable）、哈希节点（DictEntry）、字典（Dict）

typedef struct dict {dictType *type; // dict类型，内置不同的hash函数void *privdata;     // 私有数据，在做特殊hash运算时用dictht ht[2]; // 一个Dict包含两个哈希表，其中一个是当前数据，另一个一般是空，rehash时使用long rehashidx;   // rehash的进度，-1表示未进行int16_t pauserehash; // rehash是否暂停，1则暂停，0则继续
} dict;

dict内置dictht dictht内置dictEntry

所以完整的dict结构如下所示

Dict扩容

和intSet相同 当存储的数据量大于最开始定义的长度的时候会进行扩容以存储更多的数据

从dict的结构体定义来看，dictht实现是由entry数组实现，而entry是由单向链表组成

这样当集合中元素较多时，必然导致哈希冲突增多，链表过长，则查询效率会大大降低。

static int _dictExpandIfNeeded(dict *d){// 如果正在rehash，则返回okif (dictIsRehashing(d)) return DICT_OK;    // 如果哈希表为空，则初始化哈希表为默认大小：4if (d->ht[0].size == 0) return dictExpand(d, DICT_HT_INITIAL_SIZE);// 当负载因子（used/size）达到1以上，并且当前没有进行bgrewrite等子进程操作// 或者负载因子超过5，则进行 dictExpand ，也就是扩容if (d->ht[0].used >= d->ht[0].size &&(dict_can_resize || d->ht[0].used/d->ht[0].size > dict_force_resize_ratio){// 扩容大小为used + 1，底层会对扩容大小做判断，实际上找的是第一个大于等于 used+1 的 2^nreturn dictExpand(d, d->ht[0].used + 1);}return DICT_OK;
}

Dict在每次新增键值对时都会检查负载因子（LoadFactor = used/size） ，满足以下两种情况时会触发哈希表扩容：

  • 哈希表的 LoadFactor >= 1，并且服务器没有执行 BGSAVE 或者 BGREWRITEAOF 等后台进程；

  • 哈希表的 LoadFactor > 5 ；

Dict缩容

Dict除了扩容以外，每次删除元素时，也会对负载因子做检查，当LoadFactor < 0.1 时，会做哈希表收缩：

Dict的rehash

不管是扩容还是收缩，必定会创建新的哈希表，导致哈希表的size和sizemask变化，而key的查询与sizemask有关。因此必须对哈希表中的每一个key重新计算索引，插入新的哈希表，这个过程称为rehash。过程是这样的：

  1. 计算新hash表的realeSize，值取决于当前要做的是扩容还是收缩：

    1. 如果是扩容，则新size为第一个大于等于dict.ht[0].used + 1的2^n

    2. 如果是收缩，则新size为第一个大于等于dict.ht[0].used的2^n （不得小于4）

  2. 按照新的realeSize申请内存空间，创建dictht，并赋值给dict.ht[1]

  3. 设置dict.rehashidx = 0，表示开始rehash

  4. 将dict.ht[0]中的每一个dictEntry都rehash到dict.ht[1]

  5. 将dict.ht[1]赋值给dict.ht[0]，给dict.ht[1]初始化为空哈希表，释放原来的dict.ht[0]的内存

rehash过程一：

rehash过程二：

渐进式rehash

Dict的rehash并不是一次性完成的。试想一下，如果Dict中包含数百万的entry，要在一次rehash完成，极有可能导致主线程阻塞。因此Dict的rehash是分多次、渐进式的完成，因此称为渐进式rehash。流程如下：

  1. 计算新hash表的size，值取决于当前要做的是扩容还是收缩：

如果是扩容，则新size为第一个大于等于dict.ht[0].used + 1的2^n

如果是收缩，则新size为第一个大于等于dict.ht[0].used的2^n （不得小于4）

  1. 按照新的size申请内存空间，创建dictht，并赋值给dict.ht[1]

  2. 设置dict.rehashidx = 0，表示开始rehash

将dict.ht[0]中的每一个dictEntry都rehash到dict.ht[1]

  1. 每次执行新增、查询、修改、删除操作时，都检查一下dict.rehashidx是否大于-1，如果是则将dict.ht[0].table[rehashidx]的entry链表rehash到dict.ht[1]，并且将rehashidx++。直至dict.ht[0]的所有数据都rehash到dict.ht[1]

  2. 将dict.ht[1]赋值给dict.ht[0]，给dict.ht[1]初始化为空哈希表，释放原来的dict.ht[0]的内存

  3. 将rehashidx赋值为-1，代表rehash结束

  4. 在rehash过程中，新增操作，则直接写入ht[1]，查询、修改和删除则会在dict.ht[0]和dict.ht[1]依次查找并执行。这样可以确保ht[0]的数据只减不增，随着rehash最终为空

4，ZiplLst（压缩表）

ZipList 是一种特殊的“双端链表” ，由一系列特殊编码的连续内存块组成。可以在任意一端进行压入/弹出操作, 并且该操作的时间复杂度为 O(1)。

属性类型长度用途
zlbytesuint32_t4字节记录整个压缩列表占用的内存字节数
zltailuint32_t4字节记录压缩列表表尾节点距离压缩列表的起始地址有多少字节，通过这个偏移量，可以确定表尾节点的地址。
zllenuint16_t2字节记录了压缩列表包含的节点数量。 最大值为UINT16_MAX （65534），如果超过这个值，此处会记录为65535，但节点的真实数量需要遍历整个压缩列表才能计算得出。
entry列表节点不定压缩列表包含的各个节点，节点的长度由节点保存的内容决定。
zlenduint8_t1字节特殊值 0xFF（十进制 255），用于标记压缩列表的末端。

可以看到这里也有entry这个元素用来存储实际的数据，ZipList概念说可以实现任意一端进行压入/弹出操作，那相当于entry之间必然有着联系，想dict相同有next指针来指向下一个元素，可以两端操作，那这里又是通过啥来实现的呢？

  1. previous_entry_length：前一节点的长度，占1个或5个字节。

    1. 如果前一节点的长度小于254字节，则采用1个字节来保存这个长度值

    2. 如果前一节点的长度大于254字节，则采用5个字节来保存这个长度值，第一个字节为0xfe，后四个字节才是真实长度数据

  2. encoding：编码属性，记录content的数据类型（字符串还是整数）以及长度，占用1个、2个或5个字节

  3. contents：负责保存节点的数据，可以是字符串或整数

注意：ZipList中所有存储长度的数值均采用小端字节序，即低位字节在前，高位字节在后。例如：数值0x1234，采用小端字节序后实际存储值为：0x3412

Encoding编码

字符串：如果encoding是以“00”、“01”或者“10”开头，则证明content是字符串

编码编码长度字符串大小
|00pppppp|1 bytes<= 63 bytes
|01pppppp|qqqqqqqq|2 bytes<= 16383 bytes
|10000000|qqqqqqqq|rrrrrrrr|ssssssss|tttttttt|5 bytes<= 4294967295 bytes

例如，我们要保存字符串：“ab”和 “bc”

整数：如果encoding是以“11”开始，则证明content是整数，且encoding固定只占用1个字节

编码编码长度整数类型
110000001int16_t（2 bytes）
110100001int32_t（4 bytes）
111000001int64_t（8 bytes）
11110000124位有符整数(3 bytes)
1111111018位有符整数(1 bytes)
1111xxxx1直接在xxxx位置保存数值，范围从0001~1101，减1后结果为实际值

例如，一个ZipList中包含两个整数值：“2”和“5”

ZipList的连锁更新问题

现在，假设我们有N个连续的、长度为250~253字节之间的entry，因此entry的previous_entry_length属性用1个字节即可表示，如图所示：

此时插入了一条数据，长度刚好大于253 长度=254

则之前用一个字节记录前一节点的长度发生了改动，需用5个字节来记录，此时后边的记录前一节点的长度都发生了更改，都会产生内存的申请、销毁和迁移的动作会涉及到内核态的切换（操作系统原理概念）

解决：新版本listpack

5，QuickList

当需要的内存空间不大的时候可以使用连续存储空间的zipList，但是当需要的内存空间很大的时候，由于内存是碎片化的，想找到一块联系的大内存是很困难的

问题1：ZipList虽然节省内存，但申请内存必须是连续空间，如果内存占用较多，申请内存效率很低。怎么办？

为了缓解这个问题，我们必须限制ZipList的长度和entry大小。

问题2：但是我们要存储大量数据，超出了ZipList最佳的上限该怎么办？

我们可以创建多个ZipList来分片存储数据。

问题3：数据拆分后比较分散，不方便管理和查找，这多个ZipList如何建立联系？

Redis在3.2版本引入了新的数据结构QuickList，它是一个双端链表，只不过链表中的每个节点都是一个ZipList。

为了避免QuickList中的每个ZipList中entry过多，Redis提供了一个配置项：list-max-ziplist-size来限制。

如果值为正，则代表ZipList的允许的entry个数的最大值

如果值为负，则代表ZipList的最大内存大小，分5种情况：

-1：每个ZipList的内存占用不能超过4kb

-2：每个ZipList的内存占用不能超过8kb

-3：每个ZipList的内存占用不能超过16kb

-4：每个ZipList的内存占用不能超过32kb

-5：每个ZipList的内存占用不能超过64kb

其默认值为 -2：

除了控制ZipList的大小，QuickList还可以对节点的ZipList做压缩。通过配置项list-compress-depth来控制。因为链表一般都是从首尾访问较多，所以首尾是不压缩的。这个参数是控制首尾不压缩的节点个数：

0：特殊值，代表不压缩

1：标示QuickList的首尾各有1个节点不压缩，中间节点压缩

2：标示QuickList的首尾各有2个节点不压缩，中间节点压缩

以此类推

默认值：0

typedef struct quicklist {// 头节点指针quicklistNode *head; // 尾节点指针quicklistNode *tail; // 所有ziplist的entry的数量unsigned long count;    // ziplists总数量unsigned long len;// ziplist的entry上限，默认值 -2 int fill : QL_FILL_BITS;         // 首尾不压缩的节点数量unsigned int compress : QL_COMP_BITS;// 内存重分配时的书签数量及数组，一般用不到unsigned int bookmark_count: QL_BM_BITS;quicklistBookmark bookmarks[];
} quicklist;

typedef struct quicklistNode {// 前一个节点指针struct quicklistNode *prev;// 下一个节点指针struct quicklistNode *next;// 当前节点的ZipList指针unsigned char *zl;// 当前节点的ZipList的字节大小unsigned int sz;// 当前节点的ZipList的entry个数unsigned int count : 16;  // 编码方式：1，ZipList; 2，lzf压缩模式unsigned int encoding : 2;// 数据容器类型（预留）：1，其它；2，ZipListunsigned int container : 2;// 是否被解压缩。1：则说明被解压了，将来要重新压缩unsigned int recompress : 1;unsigned int attempted_compress : 1; //测试用unsigned int extra : 10; /*预留字段*/
} quicklistNode;

6，SkipList 

SkipList（跳表）首先是链表，但与传统链表相比有几点差异：

元素按照升序排列存储

节点可能包含多个指针，指针跨度不同。

// t_zset.c
typedef struct zskiplist {// 头尾节点指针struct zskiplistNode *header, *tail;// 节点数量unsigned long length;// 最大的索引层级，默认是1int level;
} zskiplist;

// t_zset.c
typedef struct zskiplistNode {sds ele; // 节点存储的值double score;// 节点分数，排序、查找用struct zskiplistNode *backward; // 前一个节点指针struct zskiplistLevel {struct zskiplistNode *forward; // 下一个节点指针unsigned long span; // 索引跨度} level[]; // 多级索引数组
} zskiplistNode;

7，LinkedList

链表和Java实现差不多

8，RedisObject

Redis中的任意数据类型的键和值都会被封装为一个RedisObject，也叫做Redis对象，源码如下：

Redis中会根据存储的数据类型不同，选择不同的编码方式，共包含11种不同类型：

编号编码方式说明
0OBJ_ENCODING_RAWraw编码动态字符串
1OBJ_ENCODING_INTlong类型的整数的字符串
2OBJ_ENCODING_HThash表（字典dict）
3OBJ_ENCODING_ZIPMAP已废弃
4OBJ_ENCODING_LINKEDLIST双端链表
5OBJ_ENCODING_ZIPLIST压缩列表
6OBJ_ENCODING_INTSET整数集合
7OBJ_ENCODING_SKIPLIST跳表
8OBJ_ENCODING_EMBSTRembstr的动态字符串
9OBJ_ENCODING_QUICKLIST快速列表
10OBJ_ENCODING_STREAMStream流

Redis中会根据存储的数据类型不同，选择不同的编码方式。每种数据类型的使用的编码方式如下：

数据类型编码方式
OBJ_STRINGint、embstr、raw
OBJ_LISTLinkedList和ZipList(3.2以前)、QuickList（3.2以后）
OBJ_SETintset、HT
OBJ_ZSETZipList、HT、SkipList
OBJ_HASHZipList、HT

参考资料：

黑马redis

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

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

ChatGPT怎么回事？

ChatGPT怎么回事？

纯属发现&#xff0c;调侃一下~ 这段时间deepseek不是特别火吗&#xff0c;尤其是它的推理功能&#xff0c;突发奇想&#xff0c;想用deepseek回答一些问题&#xff0c;回答一个问题之后就回复服务器繁忙&#xff08;估计还在被攻击吧~_~&#xff09; 然后就转向了GPT&#xf…
阅读更多...
趣味Python100例初学者练习01

趣味Python100例初学者练习01

1. 1 抓交通肇事犯 一辆卡车违反交通规则&#xff0c;撞人后逃跑。现场有三人目击该事件&#xff0c;但都没有记住车号&#xff0c;只记下了车号的一些特征。甲说&#xff1a;牌照的前两位数字是相同的&#xff1b;乙说&#xff1a;牌照的后两位数字是相同的&#xff0c;但与前…
阅读更多...
2024-我的学习成长之路

2024-我的学习成长之路

因为热爱&#xff0c;无畏山海
阅读更多...
蓝桥杯备考：高精度算法之除法

蓝桥杯备考：高精度算法之除法

我们除法的高精度其实也不完全是高精度&#xff0c;而是一个高精度作被除数除以一个低精度 模拟我们的小学除法 由于题目中我们的除数最大是1e9&#xff0c;当它真正是1e9的时候&#xff0c;t是有可能超过1e9的&#xff0c;所以要用long long
阅读更多...
Maven jar 包下载失败问题处理

Maven jar 包下载失败问题处理

Maven jar 包下载失败问题处理 1.配置好国内的Maven源2.重新下载3. 其他问题 1.配置好国内的Maven源 打开⾃⼰的 Idea 检测 Maven 的配置是否正确&#xff0c;正确的配置如下图所示&#xff1a; 检查项⼀共有两个&#xff1a; 确认右边的两个勾已经选中&#xff0c;如果没有请…
阅读更多...
【前端】ES6模块化

【前端】ES6模块化

文章目录 1. 模块化概述1.1 什么是模块化?1.2 为什么需要模块化? 2. 有哪些模块化规范3. CommonJs3.1 导出数据3.2 导入数据3.3 扩展理解3.4 在浏览器端运行 4.ES6模块化4.1 浏览器运行4.2 在node服务端运行4.3 导出4.3.1 分别导出4.3.2 统一导出4.3.3 默认导出4.3.4 混用 4.…
阅读更多...
强化学习笔记（5）——PPO

强化学习笔记（5）——PPO

PPO视频课程来源 首先理解采样期望的转换 变量x在p(x)分布下&#xff0c;函数f(x)的期望 等于f(x)乘以对应出现概率p(x)的累加 经过转换后变成 x在q(x)分布下&#xff0c;f(x)*p(x)/q(x) 的期望。 起因是&#xff1a;求最大化回报的期望&#xff0c;所以对ceta求梯度 具体举例…
阅读更多...
20-30 五子棋游戏

20-30 五子棋游戏

20-分析五子棋的实现思路_哔哩哔哩_bilibili20-分析五子棋的实现思路是一次性学会 Canvas 动画绘图&#xff08;核心精讲50个案例&#xff09;2023最新教程的第21集视频&#xff0c;该合集共计53集&#xff0c;视频收藏或关注UP主&#xff0c;及时了解更多相关视频内容。https:…
阅读更多...
【HTML入门】Sublime Text 4与 Phpstorm

【HTML入门】Sublime Text 4与 Phpstorm

文章目录 前言一、环境基础1.Sublime Text 42.Phpstorm(1)安装(2)启动Phpstorm(3)“启动”码 二、HTML1.HTML简介(1)什么是HTML(2)HTML版本及历史(3)HTML基本结构 2.HTML简单语法(1)HTML标签语法(2)HTML常用标签(3)表格(4)特殊字符 总结 前言 在当今的软件开发领域&#xff0c…
阅读更多...
Kubernetes学习之包管理工具（Helm）

Kubernetes学习之包管理工具（Helm）

一、基础知识 1.如果我们需要开发微服务架构的应用&#xff0c;组成应用的服务可能很多&#xff0c;使用原始的组织和管理方式就会非常臃肿和繁琐以及较难管理&#xff0c;此时我们需要一个更高层次的工具将这些配置组织起来。 2.helm架构&#xff1a; chart:一个应用的信息集合…
阅读更多...
Kamailio 不通过 dmq 实现注册复制功能

Kamailio 不通过 dmq 实现注册复制功能

春节期间找到一篇文章&#xff0c;需要 fg 才能看到&#xff1a; https://medium.com/tumalevich/kamailio-registration-replication-without-dmq-65e225f9a8a7 kamailio1 192.168.56.115 kamailio2 192.168.56.116 kamailio3 192.168.56.117 route[HANDLE_REPLICATION] {i…
阅读更多...
grpc 和 http 的区别---二进制vsJSON编码

grpc 和 http 的区别---二进制vsJSON编码

gRPC 和 HTTP 是两种广泛使用的通信协议&#xff0c;各自适用于不同的场景。以下是它们的详细对比与优势分析&#xff1a; 一、核心特性对比 特性gRPCHTTP协议基础基于 HTTP/2基于 HTTP/1.1 或 HTTP/2数据格式默认使用 Protobuf&#xff08;二进制&#xff09;通常使用 JSON/…
阅读更多...
Intel 与 Yocto 项目的深度融合：全面解析与平台对比

Intel 与 Yocto 项目的深度融合：全面解析与平台对比

在嵌入式 Linux 领域&#xff0c;Yocto 项目已成为构建定制化 Linux 发行版的事实标准&#xff0c;广泛应用于不同架构的 SoC 平台。Intel 作为 x86 架构的领导者&#xff0c;在 Yocto 生态中投入了大量资源&#xff0c;为其嵌入式处理器、FPGA 和 AI 加速硬件提供了完整的支持…
阅读更多...
kubernetes（二）

kubernetes（二）

文章目录 NamespacePodLabelDeploymentService Namespace 在Kubernetes系统中&#xff0c;Namespace是一种至关重要的资源类型&#xff0c;其主要功能在于实现多套环境的资源隔离或者多租户的资源隔离&#xff0c;默认情况下所有的Pod都能够相互访问&#xff0c;但如果不想让两…
阅读更多...
巧妙利用数据结构优化部门查询

巧妙利用数据结构优化部门查询

目录 一、出现的问题 部门树接口超时 二、问题分析 源代码分析 三、解决方案 具体实现思路 四、优化的效果 一、出现的问题 部门树接口超时 无论是在A项目还是在B项目中&#xff0c;都存在类似的页面&#xff0c;其实就是一个部门列表或者叫组织列表。 从页面的展示形式…
阅读更多...
【数据分析】案例04：豆瓣电影Top250的数据分析与Web网页可视化（numpy+pandas+matplotlib+flask）

【数据分析】案例04：豆瓣电影Top250的数据分析与Web网页可视化（numpy+pandas+matplotlib+flask）

豆瓣电影Top250的数据分析与Web网页可视化（numpy+pandas+matplotlib+flask） 豆瓣电影Top250官网：https://movie.douban.com/top250写在前面 实验目的：实现豆瓣电影Top250详情的数据分析与Web网页可视化。电脑系统：Windows使用软件：PyCharm、NavicatPython版本：Python 3.…
阅读更多...
【线程】基于环形队列的生产者消费者模型

【线程】基于环形队列的生产者消费者模型

1 环形队列 环形队列采用数组来模拟&#xff0c;用取模运算来模拟环状特性。 1.如何判断环形队列为空或者为满? 当环形队列为空时&#xff0c;头和尾都指向同一个位置。当环形队列为满时&#xff0c;头和尾也都指向同一个位置。 因此&#xff0c; 可以通过加计数器或者标记…
阅读更多...
Vue指令v-html

Vue指令v-html

目录 一、Vue中的v-html指令是什么&#xff1f;二、v-html指令与v-text指令的区别&#xff1f; 一、Vue中的v-html指令是什么&#xff1f; v-html指令的作用是&#xff1a;设置元素的innerHTML&#xff0c;内容中有html结构会被解析为标签。 二、v-html指令与v-text指令的区别…
阅读更多...
OPENGLPG第九版学习 - 着色器基础

OPENGLPG第九版学习 - 着色器基础

文章目录 2.1 着色器与OpenGL2.2 0penGL的可编程管线2.3 OpenGL着色语言GLSL概述2.3.1 使用GLSL构建着色器变量的声明变量的作用域变量的初始化构造函数 、 类型转换聚合类型访问向量和矩阵中的元素结构体数组多维数组 2.3.2 存储限制符const 存储限制符in 存储限制符out 存储限…
阅读更多...
路径规划之启发式算法之二十九：鸽群算法（Pigeon-inspired Optimization, PIO）

路径规划之启发式算法之二十九：鸽群算法（Pigeon-inspired Optimization, PIO）

鸽群算法（Pigeon-inspired Optimization, PIO）是一种基于自然界中鸽子群体行为的智能优化算法，由Duan等人于2014年提出。该算法模拟了鸽子在飞行过程中利用地标、太阳和磁场等导航机制的行为，具有简单、高效和易于实现的特点，适用于解决连续优化问题。 更多的仿生群体算法…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023