python 回收机制

• 引用计数
  • 每个对象维护一个 ob_refcnt 字段。每当对象被引用时计数加 1，引用失效时减 1。
• 标记清楚
  • 寻找根对象：从全局变量、调用栈等根集合出发。
  • 标记：遍历所有可达对象并打上标记。
  • 清除：遍历内存中所有对象，将没有标记（不可达）的对象销毁。
• 分代回收
  • 将内存对象分为三代（0代、1代、2代）。
  • 0代：新创建的对象。
  • 1代：在一次 GC 中幸存的对象。
  • 2代：多次 GC 后依然存活的常驻对象。
  • 策略：存活时间越久的对象越不可能是垃圾。因此，0代回收最频繁，2代回收频率最低。当某一代的对象数量达到预设阈值（Threshold）时，触发该代及更年轻代的回收。

参考文章

什么是agent

Agent = LLM（大模型）+ Planning（规划）+ Memory（记忆）+ Tools（工具）

向量数据库

• 向量检索，看的是语义相似度

prompt 太长会怎么样

• 注意力稀释，导致出现幻觉
  • case ： 会议太长，无法记住所有内容，迷失在中间（只能记住头尾记不住中间的所有内容）
• 物理缓存瓶颈
  • case： 后台分配巨大的缓存空间

prompt怎么写（怎么优化）

• zero-shot 零样本提示 ： 直接向模型提问，只能回答简单的问题，无法解决无法的场景，比如算术题
• few-shot 少样本提示： 给出一些样本（几个高质量的问答），解决不了链路很长的场景
• chain-of-thought（CoT） 思维链 (相当于给样本的时候，同时给出了解题步骤)

top K值怎么设置

• 两阶段阈值
  • 先进行粗排Recall（保召回），然后进行精排ReRank（保质量）
• 动态阈值
  • 定义一个分数线标准，如果任然不符合标准, 有多少符合，就选多少个

Step-back prompting（后退一步提问）

• 先引导模型思考一个与当前具体任务相关的通用性问题，
• 然后将该通用问题的答案作为上下文，
• 输入到后续处理具体任务的prompt中，从而提升模型表现。

golang实现快速排序

• 什么是快速排序
  • 从数组中选中一个基准值，递归遍历数组的值和基准值作对比，分为比基准值大的，比基准值小的数组后合并

js
package main

import "fmt"

func quickSort(arr []int, low, high int) {
	if low < high {
		// 获取分区后的基准索引
		pivotIndex := partition(arr, low, high)
		
		// 递归排序左半部分
		quickSort(arr, low, pivotIndex-1)
		// 递归排序右半部分
		quickSort(arr, pivotIndex+1, high)
	}
}

func partition(arr []int, low, high int) int {
	// 选择最右侧元素作为基准
	pivot := arr[high]
	i := low - 1 // i 指向小于基准的区域边界

	for j := low; j < high; j++ {
		// 如果当前元素小于或等于基准
		if arr[j] <= pivot {
			i++
			// 交换元素
			arr[i], arr[j] = arr[j], arr[i]
		}
	}
	// 将基准值交换到中间正确的位置
	arr[i+1], arr[high] = arr[high], arr[i+1]
	return i + 1
}

func main() {
	data := []int{34, 7, 23, 32, 5, 62}
	fmt.Println("排序前:", data)
	
	quickSort(data, 0, len(data)-1)
	
	fmt.Println("排序后:", data)
}

cpu异常如何排查

golang为例，可能存在的问题

• 存在死循环或者忙等待
• gorontinue的数量太多
• GC过于频繁：大量对象创建导致 GC 压力大
• 锁竞争严重
• 频繁的系统调用
• Channel 阻塞 / select 空转

一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和及最大子数组，case： nums = [-2,1,-3,4,-1,2,1,-5,4]​

js
package main

import (
	"fmt"
)

// maxSubArray 求最大连续子数组和
func maxSubArray(nums []int) int {
	if len(nums) == 0 {
		return 0
	}

	currentSum := nums[0]
	maxSum := nums[0]

	for i := 1; i < len(nums); i++ {
		// 当前和要么接着加，要么从当前元素重新开始
		if currentSum < 0 {
			currentSum = nums[i]
		} else {
			currentSum += nums[i]
		}

		// 更新最大值
		if currentSum > maxSum {
			maxSum = currentSum
		}
	}

	return maxSum
}

func main() {
	nums := []int{-2, 1, -3, 4, -1, 2, 1, -5, 4}
	result := maxSubArray(nums)
	fmt.Println("最大连续子数组和为:", result)
}