diff --git a/docs/blog/posts/2025/1/25-2.md b/docs/blog/posts/2025/1/25-2.md
new file mode 100644
index 00000000..8a03e5eb
--- /dev/null
+++ b/docs/blog/posts/2025/1/25-2.md
@@ -0,0 +1,122 @@
+---
+date: 2025-01-25
+authors:
+  - cloaks
+categories:
+  - Golang 编程实践
+tags:
+  - 并发编程
+comments: true
+---
+
+# 理解 Go 语言中结构体拷贝和锁的行为
+
+在 Go 语言中，结构体的拷贝是一个常见的操作，但是当结构体中包含复杂字段（如指针或 `sync.Mutex`）时，其行为可能会带来一些意想不到的问题。本文将通过几个具体问题，带你深入了解结构体拷贝、锁的独立性，以及这些设计的背后逻辑。
+
+<!-- more -->
+
+## 1. 值拷贝的基本概念
+在 Go 中，结构体的赋值操作是值拷贝。这意味着拷贝后生成一个新的结构体实例，新实例的所有字段都会被独立复制。对于基本类型（如整数、浮点数等），拷贝的值是独立的，而对于复杂类型（如切片、映射、指针等），拷贝的是引用地址。
+
+## 2. 拷贝结构体中的 `sync.Mutex`
+当一个结构体中包含 `sync.Mutex`（如下的 `SafeCounter`）时，对结构体进行拷贝会导致锁对象也被复制，但复制后的锁与原锁是完全独立的。
+
+```go
+import "sync"
+
+type SafeCounter struct {
+    mu  sync.Mutex
+    val int
+}
+
+func main() {
+    counter := SafeCounter{}
+    copyCounter := counter // 拷贝了结构体
+}
+```
+
+在上述代码中，`counter` 和 `copyCounter` 中的 `sync.Mutex` 是两个独立的锁对象。
+
+## 3. 拷贝锁的影响
+在使用 `sync.Mutex` 时，设计的初衷是保护共享资源。如果结构体被拷贝，那么新的结构体实例的锁和原实例的锁相互独立，这可能导致程序逻辑出现问题。例如：
+
+```go
+package main
+
+import (
+    "fmt"
+    "sync"
+)
+
+type SafeCounter struct {
+    mu  sync.Mutex
+    val int
+}
+
+func main() {
+    counter := SafeCounter{}
+    copyCounter := counter // 拷贝了结构体
+
+    go func() {
+        counter.mu.Lock()
+        defer counter.mu.Unlock()
+        counter.val++
+    }()
+
+    go func() {
+        copyCounter.mu.Lock() // 使用拷贝的锁
+        defer copyCounter.mu.Unlock()
+        copyCounter.val++
+    }()
+
+    fmt.Println(counter.val, copyCounter.val) // 输出可能不一致
+}
+```
+
+上述代码中，由于两个结构体实例的锁独立存在，两个 Goroutine 分别锁定了不同的 `sync.Mutex`，从而无法实现对同一资源的同步保护。
+
+## 4. 如何共享同一个锁对象
+如果需要让多个结构体实例共享同一个锁，可以将 `sync.Mutex` 定义为指针字段：
+
+```go
+type SafeCounter struct {
+    mu  *sync.Mutex
+    val int
+}
+
+func main() {
+    lock := &sync.Mutex{}
+    counter := SafeCounter{mu: lock}
+    copyCounter := SafeCounter{mu: lock}
+
+    go func() {
+        counter.mu.Lock()
+        defer counter.mu.Unlock()
+        counter.val++
+    }()
+
+    go func() {
+        copyCounter.mu.Lock()
+        defer copyCounter.mu.Unlock()
+        copyCounter.val++
+    }()
+}
+```
+
+此时，`counter` 和 `copyCounter` 共享同一个锁对象，能够正确同步对共享资源的访问。
+
+## 5. 为什么 Go 的锁设计为不可拷贝
+Go 的 `sync.Mutex` 明确不支持拷贝，背后的原因主要是为了避免拷贝带来的意外行为和数据竞争问题。拷贝锁对象可能导致：
+
+- 多个 Goroutine 操作不同的锁，逻辑错误。
+- 原锁的状态无法正确反映到拷贝锁中，导致死锁或数据竞争。
+
+因此，Go 官方明确规定，锁不能被复制。开发者可以通过 `go vet` 工具检测潜在的锁拷贝问题。
+
+## 6. 总结
+- 在 Go 中，结构体的赋值是值拷贝，`sync.Mutex` 作为字段时会被独立复制。
+- 独立复制的锁对象无法实现对同一资源的同步保护，可能引发逻辑错误。
+- 如果需要共享锁，应将 `sync.Mutex` 定义为指针字段。
+- Go 的锁设计为不可拷贝，旨在避免意外行为和数据竞争。
+
+正确理解 Go 的锁设计和拷贝机制，对于编写高效、安全的并发程序至关重要。