为什么go不需要动态加载外部库

Go语言不需要动态加载外部库的原因主要源于其静态编译的设计哲学和语言的核心特性。以下是详细的原因和解释：

全部依赖打包进可执行文件： Go 编译器会将所有依赖的库和运行时组件（runtime）打包到最终的可执行文件中。 因此，生成的二进制文件是一个完整的、独立的程序，运行时不需要额外的动态链接库（如 .so、.dll 文件）。 无需动态链接：

  • 在编译阶段，所有的符号解析和链接工作都已经完成。
  • 可执行文件在运行时直接运行，不依赖外部库。

运行时的独立性

内置运行时（runtime）： Go 自带垃圾回收（GC）和协程调度（goroutine scheduler）等运行时特性，这些特性不依赖操作系统或动态库。 与需要外部运行时支持（如 JVM、.NET CLR 或 Python 解释器）的语言相比，Go 程序更加独立。 跨版本兼容性：

  • 动态库的一个问题是库的 API 和 ABI 可能会随着版本升级而变化。
  • 静态编译的 Go 程序避免了这个问题，因为它已经将代码和依赖打包到一起。

垃圾回收机制：

  • JVM使用垃圾回收器（如G1、CMS等）来自动管理内存。它通过标记-清除、复制和分代收集等算法来回收不再使用的对象。
  • 垃圾回收的触发条件包括内存不足、系统调用等。

单核心CPU

问题考点的深度知识讲解：单核CPU的运作涉及几个核心概念：

  1. 进程与线程：进程是操作系统分配资源的基本单位，而线程是进程内的执行单位。单核CPU在执行时，只能在多个进程/线程之间快速切换。

  2. 时间片：为了实现看似并发的执行，操作系统为每个进程分配一个时间片。时间片是一个小时间段，CPU在这个时间段内执行一个进程，完成后暂停该进程并切换到下一个进程。

  3. 调度算法：调度算法决定了哪个进程在何时获得CPU的控制权。常见的调度算法有：

  • 先来先服务（FCFS）：按照进程到达的顺序来执行。
  • 最短作业优先（SJF）：选择执行时间最短的进程。
  • 时间片轮转（RR）：为每个进程分配相同的时间片，循环执行。

多核CPU的工作原理主要依赖于以下几个方面：

  1. 并行处理：多核CPU可以同时运行多个线程或进程，这样可以有效地利用CPU资源。例如，在一个四核CPU上，理论上可以同时执行四个独立的任务。

  2. 共享资源：多个核心通常共享某些资源，如缓存（L1、L2、L3）。这意味着核心之间可以快速共享数据，而不需要通过主内存进行繁琐的读写，从而减少延迟。

  3. 负载均衡：操作系统和应用程序需要对任务进行合理调度，以确保各个核心的负载尽可能均衡。这通常通过调度算法来实现，比如轮询调度、最小负载优先等。

  4. 编程模型：为了充分利用多核CPU，开发者需要使用并行编程的模型，如多线程编程、分布式计算等。这需要对程序的设计进行考虑，以确保可以在多个核心上有效执行。

伪代码示例： 假设我们有一个简单的任务需要在多个核心上并行执行，可以如下设计伪代码：

中断是什么 执行过程？

  1. 中断请求：当外部设备需要CPU处理某个任务时，会发送中断请求信号。

  2. CPU检测中断：CPU在执行指令时会定期检查是否有中断请求。

  3. 保存上下文：如果检测到中断请求，CPU会保存当前的执行上下文（如程序计数器PC、寄存器等），以便在中断处理完毕后能够恢复。

  4. 跳转到中断向量表：每种中断都有一个对应的中断向量，CPU会根据中断类型找到相应的中断服务例程（ISR），并跳转到该地址执行。

  5. 执行中断处理程序：ISR会处理具体的中断事件，比如读取输入数据、发送输出等。

  6. 恢复上下文：处理完成后，CPU会恢复之前保存的上下文，继续执行被中断的程序。

通过这种机制，操作系统能够有效管理多任务、响应用户输入和处理外部事件，从而实现更高效的计算和资源利用。了解中断的工作原理对于深入理解操作系统、实时系统和嵌入式系统等领域非常重要。

MQ如果消费异常会怎么样

当消费异常发生时，MQ系统通常会有以下几种处理机制：

  1. 消息重试：大多数MQ系统会将消费失败的消息重新放回队列，允许消费者再次尝试消费。重试次数通常是有限制的，超过次数后可能会将消息转移到“死信队列”。
  2. 死信队列：这是一个特殊的队列，用于存放那些经过多次重试仍然无法处理的消息。开发者可以定期检查死信队列，并手动处理这些消息。
  3. 监控与报警：可以设置监控机制，当消费异常发生时，及时报警，方便开发人员进行排查和修复。

如果一个接口有高并发流量过来 你要怎么保障数据库高可用性

  1. 数据库负载均衡：通过使用负载均衡器，将请求分发到多个数据库实例，避免单个数据库实例过载。可以使用像Nginx或HAProxy这样的负载均衡工具。

  2. 数据库连接池：使用连接池技术来管理数据库连接，避免频繁创建和销毁连接造成的性能开销。可以使用像HikariCP或Druid这样的连接池。

  3. 数据库读写分离：将读请求和写请求分开，使用主从复制架构，将读请求分发到从数据库，从而减轻主数据库的压力。

  4. 数据库缓存：引入缓存机制（如Redis或Memcached），对于频繁访问的数据进行缓存，减少对数据库的直接访问。

  5. 数据库分片：对数据进行分片，将数据分布到多个数据库中，从而提升并发处理能力。

讲一下协程和线程的区别？从多个角度说明，讲一下golang协程是如何调度的，和java线程的区别

  1. 基本概念：
  • 线程是操作系统提供的基本执行单位，具有独立的栈空间和程序计数器，由操作系统内核管理。
  • 协程是用户级别的轻量级线程，由程序运行时（如Go运行时）管理，多个协程通常共享同一线程的栈空间。
  1. 创建和销毁成本：
  • 创建一个线程的开销相对较大，通常在几百KB内存，并且需要操作系统调度。
  • 创建协程的开销非常小，通常在几KB内存，且创建和销毁速度快。
  1. 调度机制：
  • Java的线程调度由操作系统内核负责，采用抢占式调度，线程状态转换相对较慢。
  • Go的协程调度是由Go运行时（runtime）实现的，使用M:N调度模型，其中M表示系统线程数，N表示协程数。Go运行时会根据协程的执行状态和I/O操作来动态调度协程，优化CPU的使用效率。
  1. 上下文切换：

  • 线程的上下文切换涉及到内核态和用户态的切换，开销较大。

  • 协程的上下文切换在用户态完成，不涉及内核的切换，因此开销非常小。

  • Java线程之间通常使用锁和条件变量来实现同步，容易导致死锁等问题。

  • Go语言使用通道（channel）来实现协程之间的通信，具有更高的安全性和易用性。

操作系统内核态和用户态的区别，何时进入内核态or用户态 解题思路 踩一下 正确答案：操作系统内核态和用户态的区别在于它们的运行权限和访问资源的能力。内核态拥有对系统硬件和资源的完全控制权限，而用户态则受到限制，不能直接访问硬件资源。进程在执行系统调用、产生中断或异常时会从用户态切换到内核态；而在完成任务后，进程又会从内核态返回到用户态。

解答思路：首先，可以从定义入手，解释内核态和用户态各自的功能和权限。其次，举例说明何时发生态的切换，以及切换的机制。最后，可以探讨切换带来的性能影响和安全性。

问题考点的深度知识讲解：

  1. 内核态和用户态的定义：
  • 内核态（Kernel Mode）：操作系统内核运行的模式，允许执行任何CPU指令和访问任何内存地址。此态下，程序可以直接与硬件交互，包括访问文件系统、网络等。
  • 用户态（User Mode）：应用程序运行的模式，受限于内核的保护机制，不能直接访问硬件，只能通过系统调用与内核进行交互。
  1. 切换机制：
  • 切换到内核态：当用户程序需要访问硬件资源或执行特权操作时，会使用系统调用（如read、write等）。此时，CPU会产生一个软中断，进入内核态。
  • 切换到用户态：完成内核操作后，系统会通过返回指令（如ret）将控制权转回用户程序，切换到用户态。
  1. 性能影响和安全性：
  • 切换的频繁发生会增加上下文切换的开销，影响系统性能，因此在设计操作系统时需要尽量减少不必要的切换。
  • 内核态和用户态的划分是操作系统实现安全性的重要策略，防止用户程序对系统资源的直接访问，降低潜在的安全风险。

slice和array的区别，讲一下底层的结构 array本质是一个固定数组, 内存层面就是一块固定的内存区域,不会改变, 传递的时候是拷贝一份完整数据. slice本质上是一个动态数组的封装,底层指向不是一个固定内存,可以重新指向新的内存,传递的时候底层指向相同的内存.

channel的用途和使用上要注意的点，底层的结构是怎样的 channel是golang中协程之间的数据交互的重要工具,相当于与进程内的一个消息队列. 注意点: 最重要的是chan的close处理, 不然很容易出现异常, 1写数据goroutine中调用close, 2不要多次调用close, 3使用信号通知chan close了 底层结构: 环形队列(缓存数据, 无缓存的时候用不上), 读goroutine 队列(链表), 写goroutine 队列(链表), 锁

作者：忧桑ing 链接：https://www.nowcoder.com/feed/main/detail/553bd5956bad4548a5fabb2c1f97bb29?sourceSSR=search 来源：牛客网

go逃逸分析情况

  1. 作用域分析：编译器会分析变量的作用域，判断它是否会在函数返回后继续存在。

  2. 数据流分析：通过跟踪变量的使用情况，编译器能够检测出变量是否在闭包、 goroutine 等结构中被引用。

  3. 栈和堆的管理：在Go语言中，栈内存的分配和释放是非常高效的，通常在函数调用结束后自动回收。而堆则需要更复杂的垃圾回收机制，因此在性能要求较高的场景下，优先选择栈分配可以减少内存管理的开销。

伪代码示例：

1
2
3
4
5
6
7

func escapeAnalysisExample() {
x := 10 // x 是局部变量，逃逸分析后可以在栈上分配
go func() {
// 这里的 x 会逃逸，因为 goroutine 会在函数外部运行
fmt.Println(x)
}()
}

在这个例子中，变量 x 在 goroutine 中被引用，因此在逃逸分析中，编译器会决定将 x 分配在堆上，而不是栈上。通过这样的分析，Go语言的编译器能够优化内存使用，提高程序性能。

GMP 模型的整个过程

每个 M执行P的本地队列的G, 执行完成之后去全局队列上锁 并且获取G 并且执行

如果全局队列也没有任务调度了，就去其他 的 P的队列中 获取 G来执行 ，工作窃取机制。

如果全局队列为空，就会让自身进入自旋状态，等待新的 G执行。

G 阻塞时的行为 当一个 Goroutine （G）阻塞，例如等待 I/O、系统调用，或者 sync.Mutex 等操作，会触发以下过程：

当前 G 暂停执行

当前正在运行的 G 被标记为阻塞。 G 的状态从“运行中”变为“等待”。 如果阻塞是可预测的（如 I/O 或系统调用），调度器会尝试将 M 转为处理其他任务。 G 从 P 中解除绑定

P 上的当前 G（正在运行的）会从 P 中解除绑定。 P 此时会尝试从其本地队列中取出下一个 G，继续执行。 M 的行为

如果 M 因 G 阻塞无法运行其他 G： 系统调用等场景：M 会停留并等待系统调用返回。 可恢复阻塞：M 会返回 G 的控制权，切换至下一个可运行的 G。 M 不会闲置，而是尝试从全局队列、其他 P 的队列中窃取任务。 阻塞的 G 的处理

阻塞的 G 被放到一个等待队列中，等待解锁/事件触发。 当阻塞结束（如系统调用完成或信号触发），此 G 会被放回到就绪队列中。 调度器分配资源

当 G 恢复时，调度器会检查哪个 P/M 空闲，重新分配资源，让 G 继续运行。

页的概念

页是计算机操作系统中的内存管理单位，在虚拟内存系统中起核心作用。它将虚拟地址空间划分为大小相等的块（称为页），并将内存（物理地址空间）也划分为相同大小的块（称为页框，Page Frame）。页使得虚拟地址到物理地址的映射变得高效。

虚拟内存管理： 进程的虚拟内存空间通过页表映射到物理内存，允许不同进程共享物理内存。 内存保护： 每个页都有访问权限（如读、写、执行），防止进程非法访问。 减少内存碎片： 页的固定大小可以更好地组织和分配内存资源，减少内存碎片问题。 内存与磁盘的交换（分页机制）： 当内存不足时，页可以被写入磁盘的交换空间，腾出内存空间。

内存置换页算法（Page Replacement Algorithm）是在操作系统中用于管理虚拟内存的一类算法。当物理内存满了，需要从内存中移除一个页面以便加载新的页面时，操作系统使用这些算法决定哪个页面应该被置换。

以下是常见的内存置换算法：

Page Fault 缺页中断

缺页中断是操作系统中虚拟内存管理的一种机制，当一个进程尝试访问的虚拟地址不在物理内存中时，硬件触发的一种异常。这种异常通常用于将需要的页面从磁盘加载到内存中。

缺页中断通常在以下情况下发生：

页面未加载：访问的虚拟页不在物理内存中。 无效页表项：页表中对应虚拟地址的页表项标记为无效（如未映射或被换出）。 权限问题：试图以未授权的方式访问页面（例如写入一个只读页面）。

  1. 缺页中断的分类 根据页面是否在磁盘上，缺页中断可以分为以下两类：
  • 软缺页（Soft Page Fault）： 页面并未真正缺失，可能仍在缓存中（例如文件系统的缓存）。 操作系统直接更新页表，无需从磁盘加载。
  • 硬缺页（Hard Page Fault）： 页面确实不存在于物理内存中，需要从磁盘读取页面到内存。 硬缺页开销较大，读取磁盘的 I/O 操作耗时远高于内存访问。

https://docs.qq.com/sheet/DQkRORVFKc2dTeXlB?_t=1734282520091&tab=BB08J2

总结 缺页中断是虚拟内存系统中实现页面换入换出的关键机制，核心作用是：

提供虚拟内存的扩展能力。 动态分配内存，优化资源使用。 但需要有效的内存管理策略来减少缺页中断的开销，否则可能出现性能问题，如换页抖动（Thrashing）。

sync.Map原理

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

// [the Go memory model]: https://go.dev/ref/mem
type Map struct {
	mu Mutex

	// read contains the portion of the map's contents that are safe for
	// concurrent access (with or without mu held).
	//
	// The read field itself is always safe to load, but must only be stored with
	// mu held.
	//
	// Entries stored in read may be updated concurrently without mu, but updating
	// a previously-expunged entry requires that the entry be copied to the dirty
	// map and unexpunged with mu held.
	read atomic.Pointer[readOnly]

	// dirty contains the portion of the map's contents that require mu to be
	// held. To ensure that the dirty map can be promoted to the read map quickly,
	// it also includes all of the non-expunged entries in the read map.
	//
	// Expunged entries are not stored in the dirty map. An expunged entry in the
	// clean map must be unexpunged and added to the dirty map before a new value
	// can be stored to it.
	//
	// If the dirty map is nil, the next write to the map will initialize it by
	// making a shallow copy of the clean map, omitting stale entries.
	dirty map[any]*entry

	// misses counts the number of loads since the read map was last updated that
	// needed to lock mu to determine whether the key was present.
	//
	// Once enough misses have occurred to cover the cost of copying the dirty
	// map, the dirty map will be promoted to the read map (in the unamended
	// state) and the next store to the map will make a new dirty copy.
	misses int
}