type Kubelet struct {
	// 配置对象
	kubeletConfiguration kubeletconfiginternal.KubeletConfiguration

	// 节点名称 (指代运行所在 Node)
	nodeName        types.NodeName
	// 运行时缓存信息 (管理 CRI 相关状态和信息)
	runtimeCache    kubecontainer.RuntimeCache
	// 客户端
	kubeClient      clientset.Interface
	

	// 处理并同步 Pod 的相关事件 (Add/Update/Delete 等)
	podWorkers PodWorkers

	// 节点上面的 Pod 同步周期
	resyncInterval time.Duration
	
	// Pod 存储和状态管理
	podManager kubepod.Manager
	
	// Pod 驱逐管理
	evictionManager eviction.Manager
	
	// 容器信息收集
	cadvisor cadvisor.Interface

	// Informer 相关字段
	serviceLister serviceLister
	serviceHasSynced cache.InformerSynced
	nodeLister corelisters.NodeLister
	nodeHasSynced cache.InformerSynced
	
	// 节点标签
	nodeLabels map[string]string

	// 探针管理
	// 探针的实现原理: https://dbwu.tech/posts/k8s/source_code/prober/  
	probeManager prober.Manager
	livenessManager proberesults.Manager
	startupManager  proberesults.Manager

	// 资源垃圾回收管理
	containerGC kubecontainer.GC

	// 容器镜像管理
	imageManager images.ImageGCManager

	// 容器日志管理
	containerLogManager logs.ContainerLogManager
	
	// 容器运行时
	// Container runtime.
	containerRuntime kubecontainer.Runtime
	
	// 节点 IP
	nodeIPs []net.IP
}

func NewMainKubelet(...) (*Kubelet, error) {
    ...
	
	klet := &Kubelet{
		...
	}
	
	
	// 初始化驱逐管理器
	evictionManager, evictionAdmitHandler := eviction.NewManager(...)
    klet.evictionManager = evictionManager
	
	...
	
	return klet, nil
}

func (kl *Kubelet) Run(updates <-chan kubetypes.PodUpdate) {
	...

	if kl.kubeClient != nil {
		// 启动异步同步节点状态
		go wait.Until(kl.syncNodeStatus, kl.nodeStatusUpdateFrequency, wait.NeverStop)
		go kl.fastStatusUpdateOnce()
	}

	// 阻塞初始化&设置 iptables 规则
	if kl.makeIPTablesUtilChains {
		kl.initNetworkUtil()
	}

	...
	
	// 启动探针管理
	kl.probeManager.Start()
	
	// 核心调度方法
	kl.syncLoop(updates, kl)
}

func (kl *Kubelet) initializeRuntimeDependentModules() {
	...
	
	// 启动驱逐管理器，执行驱逐操作
	kl.evictionManager.Start(kl.StatsProvider, ...)

	...
}

type managerImpl struct {
	// Pod 驱逐 (Kill) 方法
	// 典型的 DI (依赖注入) 设计
	killPodFunc KillPodFunc
	
	// 镜像 GC 实现
	imageGC ImageGC
	// 容器 GC 实现
	containerGC ContainerGC

	...
	
    // 资源类型和对应排序方法的映射关系
	//   比如 CPU 资源的排序方法为 A
	//       内存 资源的排序方法为 B
	signalToRankFunc map[evictionapi.Signal]rankFunc
	// 回收资源的方法列表
	signalToNodeReclaimFuncs map[evictionapi.Signal]nodeReclaimFuncs
	// 最后同步资源状态时间
	lastObservations signalObservations
	// 内存资源阈值实现 列表
	thresholdNotifiers []ThresholdNotifier
	// 内存资源阈值实现 列表 最后更新时间
	thresholdsLastUpdated time.Time
}

// 公开包内私有类型
var _ Manager = &managerImpl{}

type Signal string

const (
	// 节点可用内存
	// 使用 CGroup 资源限制来计算
	//   而不是类似 free -m 的命令，因为 free -m 在容器中不起作用
	//   相同的机制原理可以参考之前的文章: https://dbwu.tech/posts/golang_automaxprocs/
	
	// 具体的计算方式可以参考
    // CGroup : https://kubernetes.io/examples/admin/resource/memory-available.sh
    // CGroup V2 版本: https://kubernetes.io/examples/admin/resource/memory-available-cgroupv2.sh
    SignalMemoryAvailable Signal = "memory.available"
	
	...
	
	// 进程 ID 最大上限
	// $ cat /proc/sys/kernel/pid_max
	SignalPIDAvailable Signal = "pid.available"
)

func (m *managerImpl) Start(diskInfoProvider DiskInfoProvider, podFunc ActivePodsFunc, podCleanedUpFunc PodCleanedUpFunc, monitoringInterval time.Duration) {
	thresholdHandler := func(message string) {
		// 将驱逐核心方法 synchronize 包装为参数
		m.synchronize(diskInfoProvider, podFunc)
	}
	
	// 如果使用内核级别的通知机制 (例如 CGroup 资源限制)
	if m.config.KernelMemcgNotification {
		for _, threshold := range m.config.Thresholds {
			// 仅处理内存通知
			if threshold.Signal == evictionapi.SignalMemoryAvailable || threshold.Signal == evictionapi.SignalAllocatableMemoryAvailable {
				notifier, err := NewMemoryThresholdNotifier(threshold, m.config.PodCgroupRoot, &CgroupNotifierFactory{}, thresholdHandler)
				if err != nil {
					klog.InfoS("Eviction manager: failed to create memory threshold notifier", "err", err)
				} else {
					// 为每个通知实现单独启动一个 goroutine 
					go notifier.Start()
					m.thresholdNotifiers = append(m.thresholdNotifiers, notifier)
				}
			}
		}
	}
	
	// 启动单独的的 goroutine 负责驱逐管理
	// start the eviction manager monitoring
	go func() {
		// 内部是一个无限循环
		for {
			// 定期执行 synchronize 方法来完成驱逐过程
			evictedPods, err := m.synchronize(diskInfoProvider, podFunc)
			if evictedPods != nil && err == nil {
				// 阻塞执行 Pod 驱逐 (Kill) 操作
				m.waitForPodsCleanup(podCleanedUpFunc, evictedPods)
			} else {
				// 如果发生错误，进入休眠
				time.Sleep(monitoringInterval)
			}
		}
	}()
}

func (m *managerImpl) synchronize(diskInfoProvider DiskInfoProvider, podFunc ActivePodsFunc) []*v1.Pod {
	...

	// 获取节点上运行的 Pod 列表
	activePods := podFunc()
	updateStats := true
	
	// 获取节点的各项资源 (CPU, 内存 ...) 使用情况
	summary, err := m.summaryProvider.Get(updateStats)
	
	// 最后资源阈值的最后更新时间超过 10 秒
	// 更新一下各项资源的阈值
	if m.clock.Since(m.thresholdsLastUpdated) > notifierRefreshInterval {
        ...
	}

	// 解析各项资源的总量、已使用量 等等 Metric
	observations, statsFunc := makeSignalObservations(summary)

	// 检测各项资源的使用情况是否已经超过阈值
	thresholds = thresholdsMet(thresholds, observations, false)

	// 检测满足驱逐条件的 Pods
	thresholds = thresholdsMetGracePeriod(thresholdsFirstObservedAt, now)

	// 加锁更新对象的相关状态字段
	m.Lock()
    
	...
	
	m.Unlock()

	// 没有需要驱逐的 Pod 时直接返回
	if len(thresholds) == 0 {
		return nil
	}

	// 根据驱逐优先级对 Pod 进行排序
	sort.Sort(byEvictionPriority(thresholds))
	// 计算接下来要驱逐的具体资源对应的 Pod
	thresholdToReclaim, resourceToReclaim, foundAny := getReclaimableThreshold(thresholds)
	
	...

	// 使用资源对应的排序方法对要驱逐的资源 Pod 进行排序
	//   比如根据内存进行排序，使用最多内存的 Pod 先被驱逐掉
	rank(activePods, statsFunc)
	
	// 每次最多驱逐一个 Pod
	for i := range activePods {
		pod := activePods[i]

		...
		
		// 调用 evictPod 方法驱逐 Pod
		if m.evictPod(pod, gracePeriodOverride, message, annotations) {
			return []*v1.Pod{pod}
		}
	}

	return nil
}

func (m *managerImpl) evictPod(pod *v1.Pod, ...) bool {
	...
	
	// 通过调用 managerImpl 对象初始化时 注入的 Pod 驱逐方法，阻塞式驱逐 Pod
	err := m.killPodFunc(pod, status, &gracePeriodOverride)

	...
}

type linuxCgroupNotifier struct {
	eventfd  int
	epfd     int
	stop     chan struct{}
	stopLock sync.Mutex
}

// 公开包内私有类型
var _ CgroupNotifier = &linuxCgroupNotifier{}

func NewCgroupNotifier(path, attribute string, threshold int64) (CgroupNotifier, error) {
	var watchfd, eventfd, epfd, controlfd int
	var err error
	
	// 创建监听文件描述符 
	watchfd, err = unix.Open(fmt.Sprintf("%s/%s", path, attribute), unix.O_RDONLY|unix.O_CLOEXEC, 0)
	
	// 创建控制文件描述符
	controlfd, err = unix.Open(fmt.Sprintf("%s/cgroup.event_control", path), unix.O_WRONLY|unix.O_CLOEXEC, 0)
	
	// 创建事件描述符
	eventfd, err = unix.Eventfd(0, unix.EFD_CLOEXEC)
	
	// 创建 epoll 文件描述符 
	epfd, err = unix.EpollCreate1(unix.EPOLL_CLOEXEC)

	// 关联各文件描述符和资源限制阈值触发通知
	config := fmt.Sprintf("%d %d %d", eventfd, watchfd, threshold)
	_, err = unix.Write(controlfd, []byte(config))
	
	// 根据已有的文件描述符构建一个新的事件通知对象
	return &linuxCgroupNotifier{
		eventfd: eventfd,
		epfd:    epfd,
		stop:    make(chan struct{}),
	}, nil
}

func (n *linuxCgroupNotifier) Start(eventCh chan<- struct{}) {
	// 将 epoll 文件描述符加入到 Linux epoll 机制，监听读取 
	err := unix.EpollCtl(n.epfd, unix.EPOLL_CTL_ADD, n.eventfd, &unix.EpollEvent{
		Fd:     int32(n.eventfd),
		Events: unix.EPOLLIN,
	})

	for {
		...
		
		// 调用 wait 等待事件到达
		event, err := wait(n.epfd, n.eventfd, notifierRefreshInterval)
		
		buf := make([]byte, eventSize)
		_, err = unix.Read(n.eventfd, buf)

		...
		
		eventCh <- struct{}{}
	}
}

func wait(epfd, eventfd int, timeout time.Duration) (bool, error) {
	events := make([]unix.EpollEvent, numFdEvents+1)
	timeoutMS := int(timeout / time.Millisecond)
	n, err := unix.EpollWait(epfd, events, timeoutMS)
	
	..
		
	for _, event := range events[:n] {
		if event.Fd == int32(eventfd) {
			if event.Events&unix.EPOLLHUP != 0 || event.Events&unix.EPOLLERR != 0 || event.Events&unix.EPOLLIN != 0 {
				// 三个标识符含义如下
				// EPOLLHUP: 正常情况下不会出现这种情况，如果正好发生了，由调用方处理

				// EPOLLERR: 就算读取到了 Error, 也可以认为是读取到了事件数据，同样也是由调用方处理

				// EPOLLIN: 读取到了事件数据
				return true, nil
			}
		}
	}
	
	return false, nil
}