Julia代码运行内存耗尽求助：临时变量未释放致内存暴涨

1. 不必要的内存分配：

   • fx = zeros(size(mat)) 和 fy = zeros(size(mat)) 先分配内存后立即被覆盖，完全浪费内存。
   • 使用 collect(Iterators.flatten(fx)) 而非更高效的 vec(fx)，额外产生内存复制开销。
   • Matrix{Float64}(img) 属于冗余操作：若 img 已是浮点矩阵，会额外复制数据；若为整数矩阵，可直接在后续运算中完成类型转换，避免单独复制。
   • 手动将变量赋值为0的操作（delDensity,mat,fx,fy,range,bins = [0,0,0,0,0,0]）无效，反而可能延长变量生命周期，阻碍垃圾回收。

2. 大中间对象未及时回收：

   • 当 range 数值较大时，hist2D 生成的 delDensity 矩阵会占用大量内存。多线程环境下垃圾回收时机滞后，导致内存持续累积。
   • 每次迭代生成的 shuf 矩阵，加上 entropy 中对其的复制（mat），若未被及时回收，会持续占用内存。

3. 全局变量与多线程冲突：

   • 全局字典 ses 被多线程频繁调用 push!，不仅存在线程安全风险，还会因全局引用持续持有返回值，降低垃圾回收效率。
   • 多线程内存池累积未回收的临时对象，在2000次迭代的场景下，内存占用会逐步攀升。

1. 优化 entropy 函数，减少无效分配 #

function entropy(img)
    # 直接完成类型转换与缩放，避免额外矩阵复制
    mat = Float64.(img) .* 255
    
    # 使用@view生成子矩阵视图，避免复制
    fx = @view mat[2:end-1, 3:end] .- @view mat[2:end-1, 1:end-2]
    fy = @view mat[3:end, 2:end-1] .- @view mat[1:end-2, 2:end-1]
    
    # 用vec替代flatten，减少内存复制
    fx_vec = vec(fx)
    fy_vec = vec(fy)
    
    # 直接计算max_val，避免创建临时数组
    max_val = max(abs(minimum(fx_vec)), abs(maximum(fx_vec)), abs(minimum(fy_vec)), abs(maximum(fy_vec)))
    bins = 2 * max_val + 1
    
    # 限制bins最大值，避免生成巨型直方图（可选，根据业务需求调整）
    max_bins = 1000
    bins = min(bins, max_bins)
    
    delDensity, _, _ = hist2D(fx_vec, fy_vec, Int(bins))
    
    # 归一化并计算熵，减少中间变量
    delDensity ./= sum(delDensity)
    p = delDensity[delDensity .!= 0]
    
    return -0.5 * sum(p .* log2.(p))
end

关键优化：

• 用 @view 替代普通切片，生成子矩阵视图而非复制，大幅降低内存占用。
• 移除无效的变量清零操作，让Julia垃圾回收机制自然处理临时变量。
• 新增 max_bins 限制，避免因 range 过大生成巨型直方图矩阵。

2. 优化多线程代码，避免全局变量冲突 #

as = 0:0.0005:1

# 封装线程计算逻辑，使用线程本地数组存储结果
function compute_entropies(sys, as, img)
    n_threads = Threads.nthreads()
    systems = [deepcopy(sys) for _ in 1:n_threads]
    thread_results = [Vector{Float64}(undef, length(as)) for _ in 1:n_threads]
    
    Threads.@threads for i in eachindex(as)
        tid = Threads.threadid()
        system = systems[tid]
        set_parameter!(system, 1, as[i])
        shuf, _, _ = shuffle(img, system)
        thread_results[tid][i] = entropy(shuf)
    end
    
    # 合并线程结果
    final_results = Vector{Float64}(undef, length(as))
    chunk_size = div(length(as), n_threads)
    for tid in 1:n_threads-1
        start_idx = (tid-1)*chunk_size + 1
        end_idx = tid*chunk_size
        final_results[start_idx:end_idx] = thread_results[tid][start_idx:end_idx]
    end
    # 处理剩余元素
    final_results[(n_threads-1)*chunk_size+1:end] = thread_results[n_threads][(n_threads-1)*chunk_size+1:end]
    
    return final_results
end

# 计算两个系统的结果
ses = Dict(
    lasm => compute_entropies(lasm, as, img),
    slmm => compute_entropies(slmm, as, img)
)

关键优化：

• 使用线程本地数组存储结果，避免全局字典的 push! 操作引发的线程冲突和垃圾回收延迟。
• 每个线程使用独立的 system 实例，消除线程间资源竞争。

3. 手动触发垃圾回收（可选） #

若内存问题仍存在，可在系统循环结束后手动调用垃圾回收：

for sys in [lasm, slmm]
    ses[sys] = compute_entropies(sys, as, img)
    GC.gc()
end

注意：频繁调用会降低性能，仅在内存压力较大时使用。

4. 检查 shuffle 函数 #

确认 shuffle 函数无内存泄漏，比如是否持有不必要的全局引用，或返回的 shuf 矩阵是否能被及时回收。

内容的提问来源于stack exchange，提问作者Manav Karthikeyan