Fix memory leaks, race conditions, and improve code robustness

[Copilot]

问题概述 (Overview)

This PR addresses several critical issues in the codebase related to memory leaks, race conditions, and code robustness that could cause problems in production environments.

主要修复 (Key Fixes)

1. 修复导入循环问题 (Fix Import Cycle)

Problem: The main.go file in the root package created an import cycle with test files in the redis package, preventing tests from running.

Solution: Moved main.go to examples/ directory and changed the package to main. This both resolves the import cycle and provides a clearer example structure.

2. 修复内存泄漏 (Fix Memory Leaks)

Time.Tick Leak in WatchDog

Problem: Using time.Tick() in startWatchDog() creates a ticker that cannot be garbage collected, causing memory leaks in long-running processes.

// Before
tick := time.Tick(expire / 3)

// After
ticker := time.NewTicker(expire / 3)
defer ticker.Stop()

Time.After Leak in Lock Loop

Problem: Using time.After() in the lock acquisition loop can accumulate timers that don't get released until they fire, especially problematic under high contention.

// Before
case <-time.After(time.Duration(val) * time.Millisecond):

// After
timer := time.NewTimer(time.Duration(val) * time.Millisecond)
select {
case <-timer.C:
    // ...
default:
    timer.Stop()  // Clean up timer when not needed
}

Goroutine and Channel Leaks

Problem: Goroutines in Subscribe() and DefaultClient.Subscribe() could leak if channels block or contexts are cancelled.

Solution:

• Added defer close() for all channels
• Added defer sub.Close() for Redis subscriptions
• Used buffered channels to prevent blocking
• Added context cancellation checks in all send operations

3. 修复竞态条件 (Fix Race Condition)

Problem: The doneC channel was accessed concurrently without synchronization in startWatchDog() and Unlock().

Solution: Added sync.Mutex to protect all access to doneC:

type Lock struct {
    // ...
    doneC chan struct{}
    mu    sync.Mutex  // Protects doneC
}

4. 提高代码健壮性 (Improve Code Robustness)

Safe Type Assertion

Problem: Direct type assertion res.Val.(int64) would panic if the type was unexpected.

// Before
val := res.Val.(int64)

// After
val, ok := res.Val.(int64)
if !ok {
    return errors.New("unexpected return type from lock script")
}

Buffered Channels

Used buffered channels to prevent goroutines from blocking indefinitely when receivers aren't ready.

验证 (Verification)

All changes have been validated with:

• ✅ go build ./... - Successful compilation
• ✅ go vet ./... - No static analysis issues
• ✅ go test -race - No race conditions detected

文档 (Documentation)

Added OPTIMIZATIONS.md with detailed explanations of all optimizations in Chinese, including code examples and rationale for each change.

影响 (Impact)

These changes significantly improve the reliability and safety of the distributed lock implementation:

• Prevents memory leaks in long-running applications
• Eliminates race conditions in concurrent usage
• Improves error handling and prevents panics
• Makes the codebase ready for production use

No breaking changes to the public API.

Original prompt

帮我看看这个仓库的代码有哪里需要优化的？

---

✨ Let Copilot coding agent set things up for you — coding agent works faster and does higher quality work when set up for your repo.