Go栈内存管理源码解读

基本介绍

栈内存一般是由Go编译器自动分配和释放，其中存储着函数的入参和局部变量，这些参数和变量随着函数调用而创建，当调用结束后也会随之被回收。通常开发者不需要关注内存是分配在堆上还是栈上，这部分由编译器在编译阶段通过逃逸分析来决定。但是了解其原理还是很重要的。一方面可以帮助我们有意识写出更高效的可执行代码，另一方面参考源码中的一些精妙设计也可以给自己一定的思路。

设计原理

寄存器

寄存器是CPU中的稀缺资源，他的存储能力非常有限，但是能提供最快的读写速度，充分利用寄存器的读写速度可以构建高性能的应用程序。寄存器在物理机上非常有限，然后Go的栈操作仍然用了两个以上寄存器，充分说明栈内存的重要性。

栈寄存器是CPU寄存器的一种，用于跟踪函数的调用栈。Go语言的汇编代码包括了BP和SP两个寄存器，他们分别存储了栈的基址指针和栈顶指针，BP和SP之间的部分就是函数的调用栈。

堆的内存增长是从小往大增长，而栈的增长方向是相反的，导致在做栈指令操作的时候将 SP 减小反而是将栈帧增大。这样做的好处就是便于堆和栈可动态共享那段内存区域。
在这里插入图片描述

当应用程序申请或者释放栈内存时只需要修改 SP 寄存器的值，这种线性的内存分配方式与堆内存相比更加快速，仅会带来极少的额外开销。
在这里插入图片描述

在函数执行过程中，CPU会通过栈寄存器来来访问和操作栈内存，当函数被调用时，CPU会将函数的入参和返回值地址压入栈中，并将SP指向新的栈顶。在函数内部，CPU可以通过BP来来访问栈中的参数和局部变量，当函数返回后，CPU会将栈顶元素弹出栈，将SP指针恢复到函数调用前的状态。
栈寄存器和栈内存密切相关，栈寄存器用于管理栈内存的指针，栈内存则用于存储函数调用时的参数和局部变量。

// (x86)系统下，栈帧布局
// +------------------+
// | args from caller |
// +------------------+ <- frame->argp
// |  return address  |
// +------------------+
// |  caller's BP (*) | (*) if framepointer_enabled && varp < sp
// +------------------+ <- frame->varp
// |     locals       |
// +------------------+
// |  args to callee  |
// +------------------+ <- frame->sp

栈操作

栈初始化

// linux上_NumStackOrders=4，表示四种大小的栈，分别是2kb、4kb、8kb、16kb
var stackpool [_NumStackOrders]struct {item stackpoolItem// 内存对齐_    [cpu.CacheLinePadSize - unsafe.Sizeof(stackpoolItem{})%cpu.CacheLinePadSize]byte
}func stackinit() {if _StackCacheSize&_PageMask != 0 {throw("cache size must be a multiple of page size")}for i := range stackpool {stackpool[i].item.span.init()lockInit(&stackpool[i].item.mu, lockRankStackpool)}for i := range stackLarge.free {stackLarge.free[i].init()lockInit(&stackLarge.lock, lockRankStackLarge)}
}

可以看到栈初始化过程中有两个关键变量，stackpool和stackLarge，其中stackpool是全局的栈缓存，用来分配小于32k的内存，stackLarge是大栈缓存，用来分配大于32k的内存（此处可见栈分配部分代码），这两部分的内存都是从全局的heap_中申请，所以也可以认为Go中的栈内存也是分配在堆上的。

如果仅仅用这两个全局变量来分配栈内存，那么可预见的是在程序运行期间申请和释放栈空间，必然需要频繁加锁，会影响程序执行效率，所以Go在mcache，线程缓存级别增加了一级栈缓存，在创建goroutine的时候会给自己分配一个栈空间，详见malg()，大部分情况下每个goroutine只需要在自己的栈空间申请内存即可，不需要再竞争锁。具体结构可见。mache中的栈缓存并非单独从mheap中申请，

stackinit函数在schedinit中调用

func schedinit() {...stackinit()...
}

运行时使用全局的 runtime.stackpool 和线程缓存中的空闲链表分配 32KB 以下的栈内存，使用全局的 runtime.stackLarge 和堆内存分配 32KB 以上的栈内存，提高本地分配栈内存的性能。

栈分配

在这里插入图片描述

运行会在创建goroutine的时候调用runtime.stackalloc来预先分配一个大小足够的内存空间。

// Allocate a new g, with a stack big enough for stacksize bytes.
// newproc()调用newproc1()，newproc1()调用malg()，在调用malg的时候会传入_StackMin = 2048，即最小栈2k
func malg(stacksize int32) *g {newg := new(g)if stacksize >= 0 {// 这里会在 stacksize 的基础上为每个栈预留系统调用所需的内存大小 // _StackSystem在 Linux/Darwin 上（ _StackSystem == 0 ）本行不改变 stacksize 的大小stacksize = round2(_StackSystem + stacksize)systemstack(func() {// 为新分配的G对象分配栈内存newg.stack = stackalloc(uint32(stacksize))})newg.stackguard0 = newg.stack.lo + _StackGuardnewg.stackguard1 = ^uintptr(0)// Clear the bottom word of the stack. We record g// there on gsignal stack during VDSO on ARM and ARM64.*(*uintptr)(unsafe.Pointer(newg.stack.lo)) = 0}return newg
}

_StackGuard在linux上默认大小是928个字节，所以初始化分配的2kb栈内存，只有1120个字节可用，所以在实际使用中，如果栈的长度达到1120，那么就会触发栈扩容。

stackalloc会根据分配栈内存的大小，分别用不同的方案分配栈内存

  1. 如果申请的栈内存<32k，会从全局栈缓存stackpool或线程缓存的栈上分配
  2. 否则会直接从大栈stackLarge分配
func stackalloc(n uint32) stack {thisg := getg()...// 在linux上_FixedStack=2048，_NumStackOrders=4，_StackCacheSize=32 * 1024// 如果申请的栈内存<32k，则通过stackpool或mcache上的缓存栈分配if n < _FixedStack<<_NumStackOrders && n < _StackCacheSize {order := uint8(0)n2 := n// 一直除到n<=2048，order记录除了几次// order=0表示2kb，order=1表示4kb，以此类推for n2 > _FixedStack {order++n2 >>= 1}// stackNoCache表示是否禁止线程缓存上的栈，常量，默认值是0// thisg.m.p = 0会在系统调用和改变P的个数的时候调用，满足条件就从stackpool上分配// preemptoff != "", 在 GC 的时候会进行设置,表示如果在 GC 那么从 stackpool 分配if stackNoCache != 0 || thisg.m.p == 0 || thisg.m.preemptoff != "" {lock(&stackpool[order].item.mu)// 从stackpool中分配对应大小的栈，如果stackpool空间不足，会从堆上申请x = stackpoolalloc(order)unlock(&stackpool[order].item.mu)} else {// 获取执行g的P上的mcachec := thisg.m.p.ptr().mcache// 在线程缓存上获取预分配大小的栈x = c.stackcache[order].listif x.ptr() == nil {// 从堆上申请新的内存填充到线程缓存中stackcacherefill(c, order)x = c.stackcache[order].list}// 移除空闲栈链表上的第一个节点，表示已分配c.stackcache[order].list = x.ptr().next// 更新分配栈后的空闲栈大小c.stackcache[order].size -= uintptr(n)}// 如果>=32k，则通过stackLarge分配} else {var s *mspannpage := uintptr(n) >> _PageShiftlog2npage := stacklog2(npage)// Try to get a stack from the large stack cache.lock(&stackLarge.lock)// 如果有空闲的栈内存，直接从stackLarge中分配if !stackLarge.free[log2npage].isEmpty() {s = stackLarge.free[log2npage].firststackLarge.free[log2npage].remove(s)}unlock(&stackLarge.lock)// 如果没有空闲的栈，则直接从堆上申请新的if s == nil {// Allocate a new stack from the heap.s = mheap_.allocManual(npage, spanAllocStack)if s == nil {throw("out of memory")}osStackAlloc(s)s.elemsize = uintptr(n)}}
}

需要注意的是，因为 OpenBSD 6.4+ 对栈内存有特殊的需求，所以只要我们从堆上申请栈内存，需要调用 runtime.osStackAlloc 做一些额外处理，然而其他的操作系统就没有这种限制了。
stackalloc中有两个重要的函数调用再展开看看

// 从stackpool中分配栈
func stackpoolalloc(order uint8) gclinkptr {// 获取对应大小的栈链表，并拿到第一个节点list := &stackpool[order].item.spans := list.firstif s == nil {// 如果没有空闲的栈，则从堆中申请新的mspans = mheap_.allocManual(_StackCacheSize>>_PageShift, spanAllocStack)...osStackAlloc(s)s.elemsize = _FixedStack << order// 新申请的栈内存，写入manualFreeList，manualFreeList是一个单向链表for i := uintptr(0); i < _StackCacheSize; i += s.elemsize {x := gclinkptr(s.base() + i)x.ptr().next = s.manualFreeLists.manualFreeList = x}// 插入stackpoollist.insert(s)}// 从mspan获取object（可见mspan的定义：mspan是一串连续page，然后按照size_class分割成固定大小的object），manualFreeList用来维护栈内存x := s.manualFreeListif x.ptr() == nil {throw("span has no free stacks")}// 从manualFreeList上删除第一个节点s.manualFreeList = x.ptr().next// mspan分配对象+1s.allocCount++// 如果分配完，mspan中栈对象已分配完，从stackpool中删除该mspanif s.manualFreeList.ptr() == nil {// all stacks in s are allocated.list.remove(s)}return x
}
// 填充mcache中的栈缓存
func stackcacherefill(c *mcache, order uint8) {if stackDebug >= 1 {print("stackcacherefill order=", order, "\n")}// Grab some stacks from the global cache.// Grab half of the allowed capacity (to prevent thrashing).var list gclinkptrvar size uintptrlock(&stackpool[order].item.mu)// _StackCacheSize=32k，此处先从stackpool中获取一半即16k大小，组成单向链表，放到mcache中// 猜测这里的一半是和空间利用率有关，直接分配全部32k可能会造成浪费，如果当前栈内存使用率不足1/4，那么也会触发缩容，每次缩1/2for size < _StackCacheSize/2 {x := stackpoolalloc(order)x.ptr().next = listlist = x// _FixedStack=2048size += _FixedStack << order}unlock(&stackpool[order].item.mu)// 放入mcache中c.stackcache[order].list = listc.stackcache[order].size = size
}

栈分配时的order和堆分配的sizeclass有异曲同工之妙，一方面可以减少不同goroutine获取不同大小栈的锁冲突，另一方面可以预先缓存对应大小的内存以便快速获取。在Go的内存分配中有很多类似的思路：通过预分配，分级等减少锁冲突，提高内存分配效率

栈扩容

在这里插入图片描述

编译器会在 cmd/internal/obj/x86.stacksplit 中为函数调用插入 runtime.morestack 运行时检查，它会在几乎所有的函数调用之前检查当前 Goroutine 的栈内存是否充足，如果当前栈需要扩容，我们会保存一些栈的相关信息并调用 runtime.newstack 创建新的栈：

func newstack() {thisg := getg()... // 校验逻辑gp := thisg.m.curg...morebuf := thisg.m.morebuf// 初始化寄存器相关变量thisg.m.morebuf.pc = 0thisg.m.morebuf.lr = 0thisg.m.morebuf.sp = 0thisg.m.morebuf.g = 0// 校验是否被抢占preempt := stackguard0 == stackPreemptif preempt {// 校验M是否可以被安全抢占，如果不可以安全抢占，那么就不执行抢占，让当前goroutine继续执行，等下次再抢占// canPreemptM：return mp.locks == 0 && mp.mallocing == 0 && mp.preemptoff == "" && mp.p.ptr().status == _Prunning// 如果M上没有锁，或没有在进行内存分配，或没有禁止抢占，或P的状态是Running，认为可以安全抢占if !canPreemptM(thisg.m) {// Let the goroutine keep running for now.// gp->preempt is set, so it will be preempted next time.gp.stackguard0 = gp.stack.lo + _StackGuard// 触发调度器调度gogo(&gp.sched) // never return}}// 如果被抢占，且可以安全抢占，说明当前goroutine不需要执行，也不需要栈扩容if preempt {// 需要收缩栈if gp.preemptShrink {// We're at a synchronous safe point now, so// do the pending stack shrink.gp.preemptShrink = falseshrinkstack(gp)}// 被runtime.suspendG挂起后，被动让出当前处理器的控制权if gp.preemptStop {preemptPark(gp) // never returns}// 主动让出当前处理器的控制权gopreempt_m(gp) // never return}// 到此处，如果当前goroutine不需要被抢占，那么就说明需要新的栈内存来执行代码和初始化变量，此时继续往下执行进行扩容oldsize := gp.stack.hi - gp.stack.lo// 新栈空间按照原来的2倍扩容newsize := oldsize * 2// 如果仍然不够用，则继续按照2倍扩容if f := findfunc(gp.sched.pc); f.valid() {max := uintptr(funcMaxSPDelta(f))needed := max + _StackGuardused := gp.stack.hi - gp.sched.spfor newsize-used < needed {newsize *= 2}}...// 栈溢出检测// maxstacksize 64位是1G，maxstackceiling=2*maxstacksize// maxstackceiling 用来兜底，防止用户调用runtime.setMaxStack()把maxstacksize设置得过大if newsize > maxstacksize || newsize > maxstackceiling {...}// 状态置为_Gcopystackcasgstatus(gp, _Grunning, _Gcopystack)// The concurrent GC will not scan the stack while we are doing the copy since// the gp is in a Gcopystack status.// 扩容并拷贝copystack(gp, newsize)if stackDebug >= 1 {print("stack grow done\n")}// 状态置为_Grunningcasgstatus(gp, _Gcopystack, _Grunning)// 触发调度器调度gogo(&gp.sched)
}

newstack主要流程：

  1. 校验是否可以被安全抢占，如果可以被安全抢占，就直接调用runtime.gogo触发调度器的调度
  2. 如果GC的时候被runtime.scanstack 标记了需要收缩栈，则调用shrinkstack()缩容，并把preemptShrink状态标记为false，等待下次GC扫描
  3. 如果GC的时候当前goroutine被runtime.suspendG挂起，则被动让出当前处理器的控制权，并把状态置为_Gpreempted，之后会在下一次调用runtime.suspendG的时候把状态改回到_GWaiting，
  4. 调用gopreempt_m，主动让出当前处理器的控制权
    如果当前gorouine不需要被抢占，那么就说明需要扩容新的栈空间，来执行函数代码和变量初始化

接下来再看copystack，调用该函数之前需要先把g的状态置为Gcopystack

func copystack(gp *g, newsize uintptr) {old := gp.stack...// 旧栈高位指针-G对象栈顶指针，计算当前已使用栈内存大小（参考上面寄存器和栈帧布局理解）used := old.hi - gp.sched.sp// 分配新的栈空间new := stackalloc(uint32(newsize))// 借助adjustinfo来调整栈空间var adjinfo adjustinfo// 存放旧栈adjinfo.old = old// 新旧栈的调整距离，用该值控制指针移动距离adjinfo.delta = new.hi - old.hi// sudog represents a g in a wait list, such as for sending/receiving on a channel.ncopy := usedif !gp.activeStackChans {adjustsudogs(gp, &adjinfo)} else {// 到这里代表有被阻塞的 G 在当前 G 的channel 中，所以要防止并发操作，需要获取 channel 的锁// 在所有 sudog 中找到地址最大的指针adjinfo.sghi = findsghi(gp, old)// 对所有 sudog 关联的 channel 上锁，然后调整指针，并且复制 sudog 指向的部分旧栈的数据到新的栈上ncopy -= syncadjustsudogs(gp, used, &adjinfo)}// 将旧栈中的数据整片拷贝到新栈中memmove(unsafe.Pointer(new.hi-ncopy), unsafe.Pointer(old.hi-ncopy), ncopy)// 调整ctxt，defer和panic的指针// 调用 runtime.adjustpointer，该函数会利用 runtime.adjustinfo 计算的新栈和旧栈之间的内存地址差来调整指针adjustctxt(gp, &adjinfo)adjustdefers(gp, &adjinfo)adjustpanics(gp, &adjinfo)// 把G上的栈替换为新栈gp.stack = newgp.stackguard0 = new.lo + _StackGuard // NOTE: might clobber a preempt requestgp.sched.sp = new.hi - usedgp.stktopsp += adjinfo.delta// 调整新栈上的指针gentraceback(^uintptr(0), ^uintptr(0), 0, gp, 0, nil, 0x7fffffff, adjustframe, noescape(unsafe.Pointer(&adjinfo)), 0)// 释放旧栈空间stackfree(old)
}

总结一下栈扩容的步骤：

  1. 前置校验，如果当前goroutine可以被抢占，那么就停止栈扩容
  2. 按照最小两倍来重新计算需要的栈内存
  3. 暂停当前goroutine的执行
  4. 新建一个栈空间并迁移数据：复制旧栈数据到新栈，更改指向旧栈空间的指针指向新栈空间
  5. 触发系统调度，恢复当前goroutine的执行

栈缩容

栈的缩容发生在GC扫描阶段，在scanstack函数内触发缩容

func scanstack(gp *g, gcw *gcWork) int64 {// 当我们拥有所有栈帧的精确指针映射时，认为是此时收缩栈是安全的if isShrinkStackSafe(gp) {// 直接缩容shrinkstack(gp)} else {// 在newobject中执行缩容gp.preemptShrink = true}
}

接下来看具体是怎么缩容的

func shrinkstack(gp *g) {... // 校验逻辑oldsize := gp.stack.hi - gp.stack.lo// 缩容到原来的一半newsize := oldsize / 2// 如果缩容的大小小于栈的最小值（2KB），就停止if newsize < _FixedStack {return}avail := gp.stack.hi - gp.stack.lo// 如果已使用内存超过可用空间的1/4，也停止缩容if used := gp.stack.hi - gp.sched.sp + _StackLimit; used >= avail/4 {return}// 调用copystack开辟新的栈，并复制数据copystack(gp, newsize)
}

逃逸分析

代码中如果某个对象被分配到堆上，那么就称该对象发生了内存逃逸
在编译器优化中，逃逸分析是用来决定指针动态作用域的方法。Go 语言的编译器使用逃逸分析决定哪些变量应该在栈上分配，哪些变量应该在堆上分配，其中包括使用 new、make 和字面量等方法隐式分配的内存，Go 语言的逃逸分析遵循以下两个不变性（/src/cmd/compile/internal/gc/escape.go）：

  1. 指向栈对象的指针不能存在于堆中（pointers to stack objects cannot be stored in the heap）；
  2. 指向栈对象的指针不能在栈对象回收后存活（pointers to a stack object cannot outlive that object）；
    在这里插入图片描述
  • 如果违反第一条原则，函数调用结束后，函数内分配的局部变量会被回收，那么绿色指针指向的指将不合法
  • 如果违反第二条原则，函数调用结束后，粉色部分内存被回收，如果指向栈对象的指针仍然存活，那么黄色指针指向的值也将不合法

内存逃逸的影响

如果频繁发生内存逃逸，本可以分配在栈上的变量分配在了堆上，就会存在下面问题：

  • 内存占用增加，由于Go的内存分配策略，堆扩容后并不会马上把内存归还给系统，所以会导致Go程序持有的内存不断增长，对于长时间不更新的系统来说，内存必然会持续增长，进而触发资源报警
  • GC压力增加，分配到堆上的对象不会随着函数调用结束而释放，而会等待GC标记、扫描等步骤后才回收，会导致垃圾回收器频繁操作，影响服务稳定性
  • 性能下降，堆内存分配比栈内存分配需要更多的CPU和内存资源，会导致程序性能变差

内存逃逸的原因及优化思路

以下是一些内存逃逸的case：

  • 变量的生命周期超出了其作用域，当一个变量在函数外部被引用，比如被赋值给一个包级别的变量或者作为返回值，这个变量就会发生逃逸。
    • 要严格限制作用域，仅在函数内部使用的变量，不要返回给外部
    • 使用值而不是指针，传值会拷贝整个对象，传指针只需要拷贝指针地址，但会增加GC压力，因此需要平衡考虑，对于小对象，推荐使用值传递（参考benchmark，28B是分界线，供参考）
  • 大对象的分配，对于大型的数据结构，Go 有时会选择在堆上分配内存，即使它们没有在函数外部被引用。
    • 对于频繁创建和销毁的对象，可以池化，减少在堆上分配和GC的次数
  • 闭包引用，如果一个函数返回一个闭包，并且该闭包引用了函数的局部变量，那么这些变量也会逃逸到堆上。
    • 应当尽量避免在大循环或频繁调用的函数中使用闭包
  • 接口动态分配，当一个具体类型的变量被赋值给接口类型时，由于接口的动态特性，具体的值可能会发生逃逸。
    • 对于频繁创建的对象，应当尽量使用确定的类型
  • 切片和 map 操作，如果对切片进行操作可能导致其重新分配内存，或者向 map 中插入数据，这些操作可能导致逃逸。
    • 对于切片，如果是确定的长度，推荐使用数组
    • 如果可以确定大小，在对象初始化的时候就分配好容量，避免在运行期间频繁扩容

参考

https://www.luozhiyun.com/archives/513
https://draveness.me/golang/docs/part3-runtime/ch07-memory/golang-stack-management/
https://zhuanlan.zhihu.com/p/386769009?utm_id=0
https://zhuanlan.zhihu.com/p/672733054

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

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

相关文章

Android Studio学习笔记——广播机制Broadcast

Android Studio学习笔记——广播机制Broadcast

Android Studio学习笔记——广播机制 5.1 广播机制简介5.2 接收系统广播5.2.1 动态注册监听网络变化5.2.2 静态注册实现开机启动 5.3 发送自定义广播5.3.1 发送标准广播5.3.2 发送有序广播 5.4 使用本地广播5.5 广播的最佳实践——强制下线功能 5.1 广播机制简介 安卓每个应用…
阅读更多...
web server apache tomcat11-08-JNDI Resources

web server apache tomcat11-08-JNDI Resources

前言 整理这个官方翻译的系列&#xff0c;原因是网上大部分的 tomcat 版本比较旧&#xff0c;此版本为 v11 最新的版本。 开源项目 从零手写实现 tomcat minicat 别称【嗅虎】心有猛虎&#xff0c;轻嗅蔷薇。 系列文章 web server apache tomcat11-01-官方文档入门介绍 web…
阅读更多...
spring boot后端开发基础

spring boot后端开发基础

spring boot后端开发基础 Spring Boot一、开发步骤二、Web分析三、跨域问题四、HTTP协议五、Web服务器六、响应前端请求七、springboot常用注解创建一个简单的RESTful API服务层和数据访问层配置类和Bean定义响应体和路径变量 Spring Boot 一、开发步骤 创建项目 添加依赖 项…
阅读更多...
k8s部署Eureka集群

k8s部署Eureka集群

部署有状态负载 镜像配置&#xff1a; 环境变量如下&#xff1a; AUTHENTICATE_ENABLEtrue JAVA_OPTS-Dauth.userName账号 -Dauth.password密码 MY_POD_NAMEmetadata.name BOOL_REGISTERtrue BOOL_FETCHtrue APPLICATION_NAME负载名称 EUREKA_INSTANCE_HOSTNAME${MY_POD_NA…
阅读更多...
webpack源码分析——enhanced-resolve库之getType、normalize、join和cachedJoin函数

webpack源码分析——enhanced-resolve库之getType、normalize、join和cachedJoin函数

一、PathType 路径类型 const PathType Object.freeze({Empty: 0, // 空Normal: 1, // 默认值Relative: 2, // 相对路径AbsoluteWin: 3, // win 下的绝对路径AbsolutePosix: 4, // posix 下的绝对路径Internal: 5 // enhanced-resolve 内部自定义的一种类型&#xff0c;具体是…
阅读更多...
小程序AI智能名片S2B2C商城系统：做内容、造IP、玩社群打造私域流量的新营销秘籍

小程序AI智能名片S2B2C商城系统：做内容、造IP、玩社群打造私域流量的新营销秘籍

在数字化浪潮汹涌的新时代&#xff0c;小程序AI智能名片S2B2C商城系统正以其独特的魅力&#xff0c;引领着营销领域的新变革。这套系统不仅将人工智能与小程序技术完美结合&#xff0c;更通过创新的S2B2C模式&#xff0c;为企业打开了一扇通往成功的大门。 面对激烈的市场竞争&…
阅读更多...
SQL注入作业

SQL注入作业

目录 一、万能密码和二阶注入测试 1.万能密码 2.二阶注入测试 二、联合查询注入测试 1.判断注入点 2.判断当前查询语句的列数 3.查询数据库基本信息 4.查询数据库中的数据 三、报错注入 1. 报错注入函数EXTRATVALUE 2.UPDATEXML 四、盲注测试 1.布尔盲注 判断数据…
阅读更多...
Linux搭建Discuz论坛

Linux搭建Discuz论坛

搭建一个论坛 —接上篇博客 改名/etc/httpd/conf.d/vhosts.conf 》/etc/httpd/conf.d/vhosts.conf.bak [rootlocalhost conf.d]# mv /etc/httpd/conf.d/vhosts.conf /etc/httpd/conf.d/vhosts.conf.bak此时的vhosts.conf是一个新创建的文件&#xff0c;之前的vhosts.conf已经…
阅读更多...
使用 Godot 游戏引擎为 Apple 的 visionOS 创建游戏和应用的平台

使用 Godot 游戏引擎为 Apple 的 visionOS 创建游戏和应用的平台

借助GodotVision ，您可以使用Godot 游戏引擎为 Apple VisionOS创建游戏和应用程序。 保卫牛城堡，一款使用 GodotVision 制作的 VisionOS 游戏 GodotVision 运行一个控制本机RealityKit 视图的无头 Godot实例。粗略地说：Godot 是后端，
阅读更多...
毅速3D打印随形透气钢：革新传统，引领未来

毅速3D打印随形透气钢：革新传统，引领未来

透气钢&#xff0c;这种多孔金属材料&#xff0c;既融合了金属材料的坚固性&#xff0c;又具备了透气材料的通透性。尤其在注塑模具的制造中&#xff0c;透气钢的作用不可忽视。通过镶嵌透气钢&#xff0c;能够有效解决因困气产生的注塑问题&#xff0c;使成型加工更为完善&…
阅读更多...
【机器学习】机器学习学习笔记 - 监督学习 - 逻辑回归分类朴素贝叶斯分类支持向量机 SVM (可分类、可回归) - 04

【机器学习】机器学习学习笔记 - 监督学习 - 逻辑回归分类朴素贝叶斯分类支持向量机 SVM (可分类、可回归) - 04

逻辑回归分类 import numpy as np from sklearn import linear_modelX np.array([[4, 7], [3.5, 8], [3.1, 6.2], [0.5, 1], [1, 2], [1.2, 1.9], [6, 2], [5.7, 1.5], [5.4, 2.2]]) y np.array([0, 0, 0, 1, 1, 1, 2, 2, 2])# 逻辑回归分类器 # solver&#xff1a;求解器&a…
阅读更多...
C字符串操作strlenstrnlen_s详解

C字符串操作strlenstrnlen_s详解

前言 strcat、strcpy、strcmp、strlen是C中针对字符串的库函数&#xff0c;这四个函数不安全&#xff0c;然后C针对这个情况整出strcat_s、strcpy_s、strncmp、strnlen_s(这个并不是替代stelen的)来弥补。 这篇文章主要讲&#xff1a;strlen以及strnlen_s的用法。 详见C字符串…
阅读更多...
SpringBoot项目整合Knife4j接口文档

SpringBoot项目整合Knife4j接口文档

文章目录 什么是接口文档&#xff1f;谁用接口文档为什么需要接口文档怎么做接口文档springboot如何整合knife4j?1.引入依赖2.在config目录下创建Knife4j配置依赖3.在appliacation.yml中进行配置4.启动Spring Boot工程&#xff0c;在浏览器中访问&#xff1a;http://localhost…
阅读更多...
文件传输服务器是否支持文件的增量备份？

文件传输服务器是否支持文件的增量备份？

文件传输服务器通常并不直接支持增量备份&#xff0c;因为文件传输服务器的主要功能是提供文件传输服务&#xff0c;而不是备份服务。然而&#xff0c;你可以在文件传输服务器上实现增量备份的功能&#xff0c;方法如下&#xff1a; 使用备份软件&#xff1a;安装并配置专门的备…
阅读更多...
机器学习鸢尾花使用csv

机器学习鸢尾花使用csv

操作流程 下载鸢尾花数据集导入需要的包读取数据并查看数据大小和长度划分训练集和测试集使用模型评估算法 下载鸢尾花数据集 链接&#xff1a;https://pan.baidu.com/s/1RzZyXsaiJB3e611itF466Q?pwdj484 提取码&#xff1a;j484 --来自百度网盘超级会员V1的分享导入需要…
阅读更多...
【力扣 | 分享】高频 SQL 50 题（基础版）

【力扣 | 分享】高频 SQL 50 题（基础版）

题单 查询可回收且低脂的产品寻找用户推荐人大的国家文章浏览 I无效的推文 连接使用唯一标识码替换员工ID产品销售分析 I进店却未进行过交易的顾客上升的温度每台机器的进程平均运行时间员工奖金学生们参加各科测试的次数至少有5名直接下属的经理确认率有趣的电影平均售价项目员…
阅读更多...
ZCC51215同步降压芯片 输出电流30A

ZCC51215同步降压芯片 输出电流30A

描述&#xff1a; ZCC51215是一颗用于 Notebook 或Desktop的同步降压 控制器。具有 4V 到 24V 的宽输入电压范围&#xff0c;适用于锂 电池或者适配器供电。输出电压可以通过 VID0和 VID1 逻辑信号动态切换&#xff0c;电压切换斜率可以通过 VREF 引脚 的电容进行配置&…
阅读更多...
react异步组件如何定义使用 标准使用方法

react异步组件如何定义使用 标准使用方法

目录 默认导出和命名导出的格式 默认导出的组件 使用方式 命名导出的组件 使用方式 默认导出和命名导出的格式 默认导出: // person.js const person {name: Alice,age: 30 };export default person;命名导出&#xff1a; // math.js export const add (a, b) > a b; exp…
阅读更多...
矩阵混乱度（熵值）代码计算

矩阵混乱度（熵值）代码计算

1、先回顾下熵值的数据公式&#xff1a; 2、jax.numpy代码 注意的点&#xff1a;熵值计算的输入的必须是归一化的正值 import jax.numpy as jnp import jax def _entroy(probs):log_probs jnp.log2(jnp.maximum(1.0e-30, probs))mean_sum_plogp jnp.mean(- jnp.sum(log_pro…
阅读更多...
vscode+vue开发常用插件整理

vscode+vue开发常用插件整理

前言&#xff1a; vscode新机开发常用插件整理 1、chinese 简体中文配置 2、file-jump 别名跳转&#xff0c;可以把引入的组件&#xff0c;通过ctrl地址名 跳转组件内部 3、Vue Peek&#xff1a;vue项目中的一些配置&#xff0c;安装后&#xff0c;能实现 ctrl组件名 跳转…
阅读更多...
最新文章

Copyright @ 2022~2023