etcd的mvcc源码剖析

news2024/11/22 18:46:04

mvcc简介

悲观锁
在对于一些临界资源进行读写的时候，为了防止其他人进行同步的修改数据，直接将当前的数据锁住，不让别人使用，来实现并发安全

乐观锁
在对临界资源进行操作的时候，不锁住数据，实现独占，而是判断当前数据是否有被其他人修改过，如果修改了，则修改失败

乐观锁是在操作数据之前，先获得数据的版本号或时间戳，然后在提交的时候检查数据的版本号/时间戳是否发生了变化，如果变化了则操作失败，否则就操作成功

MVCC
MVCC是一种数据库并发控制技术，为每个事务操作分配唯一的时间戳来实现并发控制，在每个事务中，只能开到在此之前已经提交的数据版本，而不会受到其他事务的干扰，

etcd的关键结构


在内存中使用一个Btree维护key的所有版本索引信息

  1. 通过某个key在btree中进行查找，获得到某个key的keyIndex信息
  2. 在当前的keyIndex中存储着某个key的KeyIndex的全部版本信息，最新的修改版本记录，以及各个generation的版本的迭代器记录
  3. 在generation中存储着某个key从创建到删除的全部版本记录，在generation中记录着当前generaatioin的创建的版本号，以及当前generation的所有的版本号信息
  4. 同时在revision版本中记录着某个具体事务的ID，和事务中某个子操作的ID

KeyValue

etcd在boltdb中存储的是key是key的版本号信息，value是当前的KeyValue结构体序列化之后的数据

type KeyValue struct {
	// key is the key in bytes. An empty key is not allowed.
	Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// create_revision is the revision of last creation on this key.
	CreateRevision int64 `protobuf:"varint,2,opt,name=create_revision,json=createRevision,proto3" json:"create_revision,omitempty"`
	// mod_revision is the revision of last modification on this key.
	ModRevision int64 `protobuf:"varint,3,opt,name=mod_revision,json=modRevision,proto3" json:"mod_revision,omitempty"`
	// version is the version of the key. A deletion resets
	// the version to zero and any modification of the key
	// increases its version.
	Version int64 `protobuf:"varint,4,opt,name=version,proto3" json:"version,omitempty"`
	// value is the value held by the key, in bytes.
	Value []byte `protobuf:"bytes,5,opt,name=value,proto3" json:"value,omitempty"`
	// lease is the ID of the lease that attached to key.
	// When the attached lease expires, the key will be deleted.
	// If lease is 0, then no lease is attached to the key.
	Lease                int64    `protobuf:"varint,6,opt,name=lease,proto3" json:"lease,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

某次操作的key信息和value信息

TreeIndex

// etcd的key索引是基础btree实现的
// etcd中的mvcc模块可以分成两个部分，索引组件+存储组件
// 首先根据key在treeindex中查找到对应的revision信息，treeindex根据查询的key从b-tree中查找到一个keyindex对象
//btree里面的key就是一个普通的keyindex匿名对象，只有一个key字段，而value就是一个keyindex对象，这个keyindex对象里面存储了当前key的revision信息
type treeIndex struct {
	sync.RWMutex
	tree *btree.BTreeG[*keyIndex] //节点的key是一个keyindex结构
	lg   *zap.Logger
}

treeIndex中存储的是一个btree，btree的key是一个keyIndex,里面只存储了一个key对象，而获得到的value里面存储的就是一个当前的具体的keyIndex的对象

KeyIndex

type keyIndex struct {
	key         []byte       //用户key的名字
	modified    Revision     // the main rev of the last modification，最后一次修改key的etcd版本号
	generations []generation //key的若干代版本号信息，每代中包含对key的多次修改的版本号列表,append递增
}

KeyIndex中包含了一个key的所有创建与删除的版本信息

generation

// generation contains multiple revisions of a key.
// 表示一个key从创建到删除的过程中，每代对应key的一个生命周期的开始与结束
// 当第一次创建一个key的时候，就会生成第0代，后续的操作都是再第0代中追加版本号
// 当把key删除掉的时候，就会生成新的的空的generation，一个key不断经历创建，删除的过程，就回u生成多个代
// etcd主要通过压缩操作来回收generation，revision和boltdb中的冗余数据
type generation struct {
	ver     int64      //表示此key在当前代，修改的次数
	created Revision   // when the generation is created (put in first revision).当前generation创建时候的版本号
	revs    []Revision //对此key的修改的版本号记录列表
}

表示一个key从创建到删除的过程中，每代对应key的一个生命周期的开始与结束
在删除某个key的时候，就会在当前的key的generation增加一个tomb，并且增加一个新的generation

Revision

type Revision struct {
	// Main is the main revision of a set of changes that happen atomically.
	Main int64 //事务内的主版本号(etcd时钟)，一个事务内的主版本号是唯一的，全局递增的，随着put/txn/delete等事务递增
	// Sub is the sub revision of a change in a set of changes that happen
	// atomically. Each change has different increasing sub revision in that
	// set.
	//一个事务内发生put，del操作的时候，从0开始递增，
	Sub int64 //事务内的子版本号
}

revision是对当前key的某个操作的版本信息
Main:某个具体的事务ID
Sub：某个事务内部的子版本号

Put

etcd在server层同样也是要开启一个事务，只不过当前是一个写事务，当前的写事务中继承了所有的事务的相关的接口


type storeTxnWrite struct {
	storeTxnCommon//事务的具体的操作
	tx backend.BatchTx
	// beginRev is the revision where the txn begins; it will write to the next revision.
	beginRev int64 //当前事务启动的时候，这个版本号信息
	changes  []mvccpb.KeyValue
}

func (tw *storeTxnWrite) put(key, value []byte, leaseID lease.LeaseID) {
	rev := tw.beginRev + 1 //在这个地方进行原子性的递增
	c := rev
	oldLease := lease.NoLease

	// if the key exists before, use its previous created and
	// get its previous leaseID
	_, created, ver, err := tw.s.kvindex.Get(key, rev) //根据给定的rev，找到比这个rev小的这个key'的事务数据，创建，和修改的次数
	if err == nil {
		c = created.Main//如果当前的key已经存在过了，就直接获得他的创建信息
		....
	}
	ibytes := NewRevBytes()                                    //版本号的字节流数据
	idxRev := Revision{Main: rev, Sub: int64(len(tw.changes))} //执行当前的put操作的执行

	//这个就是boltdb中的key：这个key是revision，
	ibytes = RevToBytes(idxRev, ibytes) //把revision转化成bytes

	ver = ver + 1          //因为是要插入数据，所以更新他的这个key的修改次数
	kv := mvccpb.KeyValue{ //mvcc当前操作的key和value的相关数据
		Key:            key,
		Value:          value,
		CreateRevision: c,   //当前的key创建的时候，所在的版本
		ModRevision:    rev, //当前的rev所在的版本
		Version:        ver, //当前key修改的次数
		Lease:          int64(leaseID),
	}

	d, err := kv.Marshal() //将上面的这些kv数据全部进行编码，boltdb中插入的数据,keyvalue序列话之后的数据
	....
	//boltdb中的key就是把revision序列话之后的数据，因为对于每一个数据的版本操作都是唯一的
	tw.tx.UnsafeSeqPut(schema.Key, ibytes, d) //把编码的数据进行插入
	tw.s.kvindex.Put(key, idxRev)             //插入完之后，修改这个key的版本信息,当前就是已经修改过了的信息
	tw.changes = append(tw.changes, kv)


	......
}
  1. 根据当前的key和rev信息，在内存中查找treeIndex，获得当前的KeyIndex对象,并在得到的keyIndex对象中查找符合条件的那个距离最近的那个generation信息，并且从当前的这个generation获得到举例当前atRev中最近的那个版本号信息，当前key一共修改的次数，以及其创建时候的版本号信息
  2. 将当前的版本号信息转化成字节流，并且生成KeyValue结构体,并将他序列化成字节流
  3. 调用UnsafeSeqPut将当前的kv数据插入到磁盘中，key：版本号的字节流信息，value：就是序列化之后keyvalue的数据,写入到底层的boltdb
  4. 最后调用 tw.s.kvindex.Put(key, idxRev) 更新treeIndex信息,包括当前操作的key，和此时对应的版本号信息
func (ti *treeIndex) Put(key []byte, rev Revision) {
	keyi := &keyIndex{key: key} //传入的就是他当前正在操作的key,以及传入当前他的revision,构造一个keyindex,每一次事务开启他的main版本号都递增

	ti.Lock()                      //上锁
	defer ti.Unlock()              //走的时候解锁
	okeyi, ok := ti.tree.Get(keyi) //因为当前的tree的key是keyindex对象,根据给定的keyindex对象获得他的value数据
	if !ok {                       //如果当前并没有找到这个keyindex的的时候，我们就可以直接插入这个数据,说明当前是第一次进来
		keyi.put(ti.lg, rev.Main, rev.Sub) //给当前的key插入版本号
		ti.tree.ReplaceOrInsert(keyi)      //插入当前key到btree中
		return
	}
	okeyi.put(ti.lg, rev.Main, rev.Sub) //否则就把这个进行插入
}
  1. 根据给定的key构造一个keyIndex的对象，并在btree中调用Get获得这个key的具体的keyIndex信息
  2. keyIndex中的put方法,传入的是当前要操作的版本号信息
// put puts a revision to the keyIndex.put每次操作的都是最后一个generation,因为最后一个generation都是最新的，一旦增加一个generation，说明都是前面的key有经历过删除的操作
func (ki *keyIndex) put(lg *zap.Logger, main int64, sub int64) {
	rev := Revision{Main: main, Sub: sub}
	//给当前的keyindex中插入一个revision
	if !rev.GreaterThan(ki.modified) { //如果插入的revision并不比之前的哪个revision大的话，就要报错
		lg.Panic(
			"'put' with an unexpected smaller revision",
			zap.Int64("given-revision-main", rev.Main),
			zap.Int64("given-revision-sub", rev.Sub),
			zap.Int64("modified-revision-main", ki.modified.Main),
			zap.Int64("modified-revision-sub", ki.modified.Sub),
		)
	}
	if len(ki.generations) == 0 {
		ki.generations = append(ki.generations, generation{}) //当前如果一个generation都没有的话，先插入一个空的generation
	}
	g := &ki.generations[len(ki.generations)-1] //获得此时正在操作的最新的的generation
	if len(g.revs) == 0 {                       // create a new key，如果当前的的generation并没有修改过,说明当前的generation是第一次进来
		keysGauge.Inc()
		g.created = rev //因为当前的genneration中一个revision都没有，说明当前就没有
	}
	g.revs = append(g.revs, rev) //将当前revision添加到当前generation代中
	g.ver++                      //更改次数增加
	ki.modified = rev            //当前修改的版本就是此时新增加的这个revision
}
  1. 获得当前最新操作的generation信息
  2. 在当前的generation中添加当前的版本号信息
  3. 并更新当前的generation信息

Read

每次range操作都会在etcd开启一个storeTxnCommon事务，调用txn的方法，可以获取到范围内的所有keyIndex信息,实现读写分离的操作


func (tr *storeTxnCommon) rangeKeys(ctx context.Context, key, end []byte, curRev int64, ro RangeOptions) (*RangeResult, error) { //currev标识是当前事务的ID，拿到了key之后以及感兴趣的revision后，我们就可以取treeindex中查找
	rev := ro.Rev
	if rev > curRev { //检查锁查找的rev是否有效，超过当前版本的不行
		return &RangeResult{KVs: nil, Count: -1, Rev: curRev}, ErrFutureRev
	}
	if rev <= 0 {
		rev = curRev //如果当前的版本小于0,更改为当前事务的版本
	}
	if rev < tr.s.compactMainRev { //在已经compact事务执行之前的版本也不行
		return &RangeResult{KVs: nil, Count: -1, Rev: 0}, ErrCompacted
	}
	//
	if ro.Count { //为真表示计算满足条件的的版本号数量，而不是检索键值对
		total := tr.s.kvindex.CountRevisions(key, end, rev) //调用这个来查找满足条件的的版本数量
		tr.trace.Step("count revisions from in-memory index tree")
		return &RangeResult{KVs: nil, Count: total, Rev: curRev}, nil
	}
	//根据指定的版本取kvindex的btree中查找，所有符合rev版本从key到end的版本信息
	revpairs, total := tr.s.kvindex.Revisions(key, end, rev, int(ro.Limit)) //获得一系列符号条件的版本信息
	tr.trace.Step("range keys from in-memory index tree")
	if len(revpairs) == 0 { //没有找到匹配的
		return &RangeResult{KVs: nil, Count: total, Rev: curRev}, nil
	}

	limit := int(ro.Limit) //这个来限制返回的版本数量
	if limit <= 0 || limit > len(revpairs) {
		limit = len(revpairs)
	}

	kvs := make([]mvccpb.KeyValue, limit) //根据配置，创建需要可以返回的kv数据
	revBytes := NewRevBytes()
	for i, revpair := range revpairs[:len(kvs)] { //截取前面的limit个进行遍历
		//遍历所有的版本
		select {
		case <-ctx.Done():
			return nil, fmt.Errorf("rangeKeys: context cancelled: %w", ctx.Err())
		default:
		}
		revBytes = RevToBytes(revpair, revBytes) //将当前的版本号revision序列化成字符串，到boltdb中查询
		//因为底层的boltdb中的key就是某次put的revisiono的序列化之后的数据，我们就是通过这个序列化之后的数据获得时局的key/value数据
		_, vs := tr.tx.UnsafeRange(schema.Key, revBytes, nil, 0) //从底层的boltdb中获得真实的key/value信息
		if len(vs) != 1 {
			tr.s.lg.Fatal(
				"range failed to find revision pair",
				zap.Int64("revision-main", revpair.Main),
				zap.Int64("revision-sub", revpair.Sub),
				zap.Int64("revision-current", curRev),
				zap.Int64("range-option-rev", ro.Rev),
				zap.Int64("range-option-limit", ro.Limit),
				zap.Binary("key", key),
				zap.Binary("end", end),
				zap.Int("len-revpairs", len(revpairs)),
				zap.Int("len-values", len(vs)),
			)
		} //判断根据这个revision从boltdb中获得的数据是否有效的序列化
		if err := kvs[i].Unmarshal(vs[0]); err != nil {
			tr.s.lg.Fatal(
				"failed to unmarshal mvccpb.KeyValue",
				zap.Error(err),
			)
		}
	}
	tr.trace.Step("range keys from bolt db")
	return &RangeResult{KVs: kvs, Count: total, Rev: curRev}, nil //获得到符合条件的信息
}
  1. 检查要查找的rev版本号是否有效，超过当前版本的不行，已经被compacted删除的也不行
  2. 调用tr.s.kvindex.Revisions在内存中的treeIndex中的btree中进行查找，找到符合条件的limit个版本信息
  3. 遍历所有符合条件的版本，UnSafeGet从底层磁盘中的boltdb中获得真实的key/value信息
func (ti *treeIndex) Revisions(key, end []byte, atRev int64, limit int) (revs []Revision, total int) {
	ti.RLock()
	defer ti.RUnlock()

	if end == nil { //end=nil，表示只需要检索key所对应的版本信息，end表示我们要检索的key的范围的结束信息
		rev, _, _, err := ti.unsafeGet(key, atRev) //根据当前的事务版本获得感兴趣的revision信息,获得当前事务的最新的modify的版本信息
		if err != nil {
			return nil, 0
		}
		return []Revision{rev}, 1
	}
	ti.unsafeVisit(key, end, func(ki *keyIndex) bool { //如果end！=nil，就需要进行一个范围检索
		if rev, _, _, err := ki.get(ti.lg, atRev); err == nil {
			if limit <= 0 || len(revs) < limit {
				revs = append(revs, rev)
			}
			total++
		}
		return true
	})
	return revs, total //返回当前符合条件的信息
}
  1. 如果当前没有作为end作为对key范围查找的结束字符串的话，就直接调用treeIndex的unsafeGet查找atRev中的一个指定的revision信息
  2. 否则就需要进行进行范围查找多个指定的revision信息
func (ti *treeIndex) unsafeGet(key []byte, atRev int64) (modified, created Revision, ver int64, err error) {
	keyi := &keyIndex{key: key}                //给定一个key，和atrev这个版本，构造一个keyindex对象，（treeindex中的btree里面的key就是这个对象）
	if keyi = ti.keyIndex(keyi); keyi == nil { //根据这个keyindex，在btree中查找，如果已经存在了的话，下面我们就可以直接使用，如果不存在的话，就返回不存在
		return Revision{}, Revision{}, 0, ErrRevisionNotFound //当前是没有找到，所以返回没有找到
	}
	return keyi.get(ti.lg, atRev) //存在这个keyindex，所以在这个keyindex中查找指定的数据
}
  1. 首先调用keyIndex获得当前key的一个keyIndex信息
  2. 并在当前的keyindex中调用get,获得某个指定的revision

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

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

相关文章

锐捷NBR 1300G路由器 越权CLI命令执行漏洞

锐捷NBR 1300G路由器 越权CLI命令执行漏洞

执行查看版本的命令不需要其它权限&#xff0c; 访问url&#xff1a; /WEB_VMS/LEVEL15/构造payload数据包&#xff1a; POST /WEB_VMS/LEVEL15/ HTTP/1.1commandshow version&strurlexec%04&mode%02PRIV_EXEC&signnameRed-Giant.回显如下&#xff1a; 测试发现…
阅读更多...
软件测试之单元测试

软件测试之单元测试

前言 为什么我们需要测试&#xff1f; 让产品可以快速迭代&#xff0c;同时还能保持高质量 对于一些相对稳定的系统级别页面&#xff0c;自动化测试在提高测试的效率的方面起到非常重要的作用。前端的自动化测试主要包括&#xff1a;浏览器测试和单元测试。Vue官方脚手架自带…
阅读更多...
Linux系统之watch命令的基本使用

Linux系统之watch命令的基本使用

Linux系统之watch命令的基本使用 一、watch命令介绍二、watch命令的使用帮助2.1 watch命令的help帮助2.2 watch命令的语法解释 三、watch命令的基本使用3.1 使用默认的2秒时间间隔执行ls命令3.2 每隔10秒执行一次ps命令3.3 每隔1秒输出一次磁盘使用情况3.4 高亮显示grep命令的输…
阅读更多...
File 复制文件

File 复制文件

一.代码 package org.example;import java.io.*;public class day05 {public static void main(String[] args) throws IOException {//复制图片//创建字节输入流管道与源文件接通final FileInputStream is new FileInputStream("D:\\temp\\day05\\图2.jpg");//创建…
阅读更多...
软考高项-计算题（2）

软考高项-计算题（2）

题4 项目的总预算是包含管理储备的&#xff0c;所以总预算应该是&#xff1a;13238102*360 ETC(BAC-EV)/CPI BAC60 EV60*0.318 CPI18/200.9 ETC42/0.9 答案选择C A 题5 因为题目中提到了“按目前的状况继续发展”&#xff0c;那么是&#xff1a;ETC(BAC-EV)/CPI EV1230*0…
阅读更多...
计算机网络基础二

计算机网络基础二

课程目标 了解 OSI 七层模型分层结构 了解 TCP/IP 协议簇四层模型分层结构 能够说出 TCP/IP 协议簇中 运输层、网络层和数据链路 层常见的 相关协议 能够说出 TCP/IP 的三次握手四次断开过程 了解 Vmware 的三种网络模式 能够使用客户端工具连接虚拟机 掌握主机名、 DNS…
阅读更多...
java原子类-Atomic

java原子类-Atomic

什么是原子类&#xff1f; java 1.5引进原子类&#xff0c;具体在java.util.concurrent.atomic包下&#xff0c;atomic包里面一共提供了13个类&#xff0c;分为4种类型&#xff0c;分别是&#xff1a; 原子更新基本类型&#xff0c;原子更新数组&#xff0c;原子更新引用&…
阅读更多...
Redis（06）| 数据结构-整数集合

Redis（06）| 数据结构-整数集合

整数集合是 Set 对象的底层实现之一。当一个 Set 对象只包含整数值元素&#xff0c;并且元素数量不大时&#xff0c;就会使用整数集这个数据结构作为底层实现。 整数集合结构设计 整数集合本质上是一块连续内存空间&#xff0c;它的结构定义如下&#xff1a; typedef struct…
阅读更多...
【黑马程序员】Springboot2 学习笔记

【黑马程序员】Springboot2 学习笔记

课程地址 1. Springboot parent和starter区别 parent&#xff1a;开发Springboot项目需要继承spring-boot-starter-parent&#xff0c;其中定义了若干个依赖管理&#xff08;坐标版本号&#xff09;&#xff0c;避免依赖版本冲突&#xff1b;starter&#xff1a;开发Springboo…
阅读更多...
提升演讲口才，助青少年踏上成功之路

提升演讲口才，助青少年踏上成功之路

提升演讲口才&#xff0c;助青少年踏上成功之路 引言&#xff1a; 青少年时期是一个人成长发展的关键阶段&#xff0c;而演讲口才的培养不仅可以帮助他们在学业和职业上取得成功&#xff0c;还能帮助他们塑造自信、提升沟通能力&#xff0c;并在社交场合中脱颖而出。本文将探讨…
阅读更多...
springboot在线招聘系统

springboot在线招聘系统

springboot在线招聘管理系统&#xff0c;java在线招聘管理系统&#xff0c;在线招聘管理系统 运行环境&#xff1a; JAVA版本&#xff1a;JDK1.8 IDE类型&#xff1a;IDEA、Eclipse都可运行 数据库类型&#xff1a;MySql&#xff08;8.x版本都可&#xff09; 硬件环境&#xf…
阅读更多...
GDB调试-链接器

GDB调试-链接器

GDB&#xff08;GNU Debugger&#xff09;是一个强大的命令行调试工具&#xff0c;用于调试C、C等编程语言的程序。以下是一些常用的GDB调试命令&#xff1a; 一、启动 GDB&#xff1a;打开终端并输入以下命令来启动GDB&#xff0c;并将可执行文件作为参数 gdb ld-new 二、运…
阅读更多...
【源码解析】Spring源码解读-beanFactory和Bean的后置处理器流程

【源码解析】Spring源码解读-beanFactory和Bean的后置处理器流程

上一篇文章&#xff0c;我们详细介绍了spring是如何通过加载xml配置文件&#xff0c;将beanfactry创建成功的&#xff0c;接着核心流程&#xff0c;我们继续说下beanFactory和Bean的后置处理流程。 //留给子类的模板方法&#xff0c;允许子类继续对工厂执行一些处理&#xff1b…
阅读更多...
二、【海报合成的创意】

二、【海报合成的创意】

文章目录 多分析他人海报&#xff0c;逐渐学会生成自己的创意关键词创意寻找素材寻找创意灵感的网站 那么如何快速生成创意&#xff1f; 多分析他人海报&#xff0c;逐渐学会生成自己的创意 关键词创意 从上图中我们可以看到&#xff0c;该海报中主要突出的主体是耳机。突出的…
阅读更多...
【Git企业开发】第一节.Git 的分支管理

【Git企业开发】第一节.Git 的分支管理

作者简介&#xff1a;大家好&#xff0c;我是未央&#xff1b; 博客首页&#xff1a;未央.303 系列专栏&#xff1a;Git企业级开发 每日一句&#xff1a;人的一生&#xff0c;可以有所作为的时机只有一次&#xff0c;那就是现在&#xff01;&#xff01;&#xff01;&#xff0…
阅读更多...
java后端返回数据给前端时去除值为空或NULL的属性、忽略某些属性

java后端返回数据给前端时去除值为空或NULL的属性、忽略某些属性

目录 一、使用场景 二、环境准备 1、引入依赖 2、实体类 三、示例 1、不返回空值 (1)方式 (2)测试 (3)说明 2、不返回部分属性 (1)方式 (2)测试 一、使用场景 在开发过程中&#xff0c;有时候需要将后端数据返回前端&#xff0c;此时有些数据为空属性不需要返回&…
阅读更多...
SSM度假村管理系统开发mysql数据库web结构java编程计算机网页源码eclipse项目

SSM度假村管理系统开发mysql数据库web结构java编程计算机网页源码eclipse项目

一、源码特点 SSM 度假村管理系统是一套完善的信息系统&#xff0c;结合SSM框架完成本系统&#xff0c;对理解JSP java编程开发语言有帮助系统采用SSM框架&#xff08;MVC模式开发&#xff09;&#xff0c;系统具有完整的源代码和数据库&#xff0c;系统主要 采用B/S模式开发…
阅读更多...
[LaTeX] [数学符号] \mathbb{1}的各种替代方案：解决在 LaTeX 中输入黑板粗体的数字

[LaTeX] [数学符号] \mathbb{1}的各种替代方案：解决在 LaTeX 中输入黑板粗体的数字

[LaTeX] [数学符号] \mathbb{1}的各种替代方案&#xff1a;解决在 LaTeX 中输入黑板粗体的数字_latex mathbb-CSDN博客文章浏览阅读5w次&#xff0c;点赞36次&#xff0c;收藏80次。本文介绍如何在 LaTeX 中输入黑板粗体的数字。_latex mathbbhttps://blog.csdn.net/xovee/arti…
阅读更多...
FRP内网穿透（待续）

FRP内网穿透（待续）

FRP内网穿透技术原理&#xff1a; FRP可以将内网服务主机以安全、便捷的方式通过具有公网 IP 节点的中转暴露到公网。 1.GITHUB下载FRP 2.云服务器安装FRP修改配置 3.本地计算机安装FRP修改配置
阅读更多...
R-FCN: Object Detection via Region-based Fully Convolutional Networks（2016.6）

R-FCN: Object Detection via Region-based Fully Convolutional Networks（2016.6）

文章目录 AbstractIntroduction当前最先进目标检测存在的问题针对上述问题&#xff0c;我们提出... Our approachOverviewBackbone architecturePosition-sensitive score maps & Position-sensitive RoI pooling Related WorkExperimentsConclusion 原文链接 源代码 Abstr…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023