Lua性能优化技巧 - 元素码农

发布时间: 2025-03-24 12:17

↑

# Lua性能优化技巧

本文将介绍如何优化Lua代码的性能,包括代码优化、内存管理、数据结构选择等方面的最佳实践。

## 代码优化

### 1. 局部变量

```lua
-- 使用局部变量
local function test()
    local sum = 0           -- 局部变量
    for i = 1, 1000000 do
        sum = sum + i       -- 访问局部变量
    end
    return sum
end

-- 避免全局变量
function bad_test()         -- 全局函数
    sum = 0                 -- 全局变量
    for i = 1, 1000000 do
        sum = sum + i       -- 访问全局变量
    end
    return sum
end
```

### 2. 表预分配

```lua
-- 预分配表空间
local function create_large_table(size)
    local t = {}
    for i = 1, size do
        t[i] = i
    end
    return t
end

-- 优化版本
local function create_large_table_optimized(size)
    local t = table.create(size)  -- 预分配空间
    for i = 1, size do
        t[i] = i
    end
    return t
end
```

### 3. 字符串连接

```lua
-- 低效的字符串连接
local function concat_strings_bad(n)
    local s = ""
    for i = 1, n do
        s = s .. "item" .. i  -- 每次连接都创建新字符串
    end
    return s
end

-- 使用table.concat优化
local function concat_strings_good(n)
    local t = {}
    for i = 1, n do
        t[i] = "item" .. i
    end
    return table.concat(t)  -- 一次性连接
end
```

## 内存管理

### 1. 垃圾回收

```lua
-- 控制垃圾回收
local function gc_control()
    collectgarbage("stop")      -- 停止自动GC
    
    -- 执行内存密集操作
    local data = process_large_data()
    
    collectgarbage("restart")   -- 重启自动GC
    collectgarbage("collect")   -- 强制完整GC
end

-- 设置GC参数
local function tune_gc()
    collectgarbage("setpause", 110)   -- 设置GC暂停比例
    collectgarbage("setstepmul", 200) -- 设置GC步进倍率
end
```

### 2. 对象池

```lua
-- 对象池实现
local ObjectPool = {}
ObjectPool.__index = ObjectPool

function ObjectPool.new(create_func, max_size)
    return setmetatable({
        create = create_func,
        pool = {},
        max_size = max_size or 1000
    }, ObjectPool)
end

function ObjectPool:acquire()
    if #self.pool > 0 then
        return table.remove(self.pool)
    end
    return self.create()
end

function ObjectPool:release(obj)
    if #self.pool < self.max_size then
        table.insert(self.pool, obj)
    end
end

-- 使用示例
local pool = ObjectPool.new(function()
    return {x = 0, y = 0}
 end, 100)

local obj = pool:acquire()
-- 使用对象
pool:release(obj)
```

## 数据结构优化

### 1. 数组操作

```lua
-- 高效的数组操作
local function array_ops()
    local arr = {}
    
    -- 插入元素
    table.insert(arr, 1)        -- 末尾插入
    table.insert(arr, 1, 2)     -- 指定位置插入
    
    -- 删除元素
    table.remove(arr, 1)        -- 删除指定位置
    table.remove(arr)           -- 删除最后一个
    
    -- 高效遍历
    for i = 1, #arr do          -- 使用数字索引
        local v = arr[i]
    end
end
```

### 2. 哈希表优化

```lua
-- 哈希表键的选择
local function hash_table_keys()
    -- 好的键选择
    local t1 = {
        ["name"] = "Alice",    -- 字符串键
        [1] = 100,             -- 整数键
        [true] = "bool"        -- 布尔键
    }
    
    -- 避免的键类型
    local t2 = {
        [{x=1,y=2}] = "bad",  -- 表作为键
        [function()end] = "bad" -- 函数作为键
    }
end
```

## 算法优化

### 1. 缓存计算结果

```lua
-- 使用缓存优化
local function fibonacci_with_cache()
    local cache = {[0]=0, [1]=1}
    
    local function fib(n)
        if cache[n] then
            return cache[n]
        end
        
        cache[n] = fib(n-1) + fib(n-2)
        return cache[n]
    end
    
    return fib
end

local fib = fibonacci_with_cache()
print(fib(10))  -- 快速计算
```

### 2. 空间换时间

```lua
-- 预计算查找表
local function create_lookup_table()
    local sin_table = {}
    for i = 0, 360 do
        sin_table[i] = math.sin(math.rad(i))
    end
    return sin_table
end

local sin_lookup = create_lookup_table()

-- 快速查找而不是计算
local function fast_sin(angle)
    angle = angle % 360
    return sin_lookup[angle]
end
```

## 性能分析

### 1. 时间测量

```lua
-- 简单的性能测试函数
local function benchmark(func, iterations)
    local start = os.clock()
    
    for i = 1, iterations do
        func()
    end
    
    local elapsed = os.clock() - start
    return elapsed
end

-- 使用示例
local time = benchmark(function()
    -- 测试代码
    local t = {}
    for i = 1, 1000 do
        t[i] = i
    end
end, 1000)

print(string.format("Time: %.6f seconds", time))
```

### 2. 内存使用分析

```lua
-- 内存使用监控
local function memory_usage()
    local initial = collectgarbage("count")
    
    -- 执行代码
    local data = {}
    for i = 1, 1000000 do
        data[i] = i
    end
    
    local final = collectgarbage("count")
    return final - initial  -- 返回KB单位的内存使用量
end
```

## 常见陷阱

### 1. 闭包开销

```lua
-- 避免在循环中创建闭包
local function create_handlers_bad()
    local handlers = {}
    for i = 1, 10 do
        handlers[i] = function() return i end  -- 每次迭代创建新闭包
    end
    return handlers
end

-- 优化版本
local function create_handlers_good()
    local handlers = {}
    local function create_handler(n)
        return function() return n end
    end
    
    for i = 1, 10 do
        handlers[i] = create_handler(i)  -- 重用闭包创建函数
    end
    return handlers
end
```

### 2. 元表开销

```lua
-- 减少元表操作
local mt = {
    __index = function(t, k)
        -- 复杂的查找逻辑
        return rawget(t, "_data")[k]
    end
}

-- 优化版本
local function optimize_metatable_access()
    local t = {_data = {}}
    setmetatable(t, mt)
    
    -- 缓存频繁访问的值
    local data = t._data
    for i = 1, 1000 do
        data[i] = i  -- 直接访问而不是通过元表
    end
end
```

## 最佳实践

1. 使用局部变量代替全局变量
2. 预分配表空间
3. 使用table.concat而不是字符串连接
4. 适当控制垃圾回收
5. 实现对象池复用对象
6. 选择合适的数据结构
7. 缓存计算结果
8. 定期进行性能分析

## 下一步

现在你已经了解了Lua的性能优化技巧,可以继续学习[配置文件解析](/article/lua/practice/config-parser)来了解如何高效地处理配置文件。

## 参考资源

- [Lua性能优化指南](http://www.lua.org/gems/)
- [Programming in Lua - 优化](http://www.lua.org/pil/30.html)
- [Lua性能调优技巧](http://lua-users.org/wiki/OptimisationTips)