高频写入场景：持续持有StreamWriter还是每次新建？

我开发了一款应用，需要通过不同Task每秒向12个不同文件各写入一次数千字符的字符串，最多会扩展到36个文件，最长需保持文件写入状态8小时。核心需求是性能，目前纠结两种实现方案：复用已创建的StreamWriter，还是每次写入时新建StreamWriter？

两种方案实现代码 #

案例1 - 复用已创建的StreamWriter #

public static Dictionary<string, StreamWriter> writers = new Dictionary<string, StreamWriter>();

public static void Main()
{
    Dictionary<string, object> Param1 = new Dictionary<string, object>();
    string Param2 = "a path";
    bool Param3 = false;

    StreamWriter wr = new StreamWriter(Param2);
    string key = "a key";
    writers.Add(key, wr);

    Timer timer = new Timer();
    timer.Interval = 100;
    timer.Elapsed += new ElapsedEventHandler((sender, e) => { Task.Run(() => SampleMethod(Param1, Param2, Param3, key)); });
    timer.Enabled = false;
}

public static void SampleMethod(Dictionary<string, object> collection, string path, bool check, string key)
{
    if (check)
    {
        writers[key].WriteLine(JsonConvert.SerializeObject(collection));
    }
}

案例2 - 每次写入新建StreamWriter #

public static void Main()
{
    Dictionary<string, object> Param1 = new Dictionary<string, object>();
    string Param2 = "a path";
    bool Param3 = false;

    Timer timer = new Timer();
    timer.Interval = 100;
    timer.Elapsed += new ElapsedEventHandler((sender, e) => { Task.Run(() => SampleMethod(Param1, Param2, Param3)); });
    timer.Enabled = false;
}

public static void SampleMethod(Dictionary<string, object> collection, string path, bool check)
{
    if (check)
    {
        using (StreamWriter writer = new StreamWriter(path))
        {
            writer.WriteLine(JsonConvert.SerializeObject(collection));
        }
    }
}

方案对比与结论 #

复用StreamWriter的优劣势 #

性能上绝对占优：

• 省去了每次创建销毁StreamWriter、打开关闭文件句柄的重复开销，高频写入（每秒1次）场景下，系统调用次数会大幅减少，吞吐量明显提升。
• 减少文件系统元数据操作（比如权限检查、文件指针定位），机械硬盘上这种差异会更显著。

需要解决的问题：

• 线程安全：StreamWriter不是线程安全的，多个Task写同一个文件必须加锁，比如给每个Writer配独立的锁对象，避免全局锁拖慢速度。
• 资源泄漏：长期持有文件句柄（最长8小时），程序正常退出时必须显式调用Dispose()关闭所有Writer；异常退出的话可能残留句柄，要做好兜底清理。
• 缓存刷新：默认有缓存，数据不会立即落地。如果要实时持久化就得调用Flush()，但会牺牲点性能；能接受短暂延迟的话，依赖系统自动刷新就行。

每次新建StreamWriter的优劣势 #

性能拉胯：

• 每秒几十次的文件打开/关闭操作，加上每次的指针定位，高频场景下额外开销非常大，文件数量到36个时会明显拖慢整体速度。另外注意，你的代码里StreamWriter(path)默认是覆盖文件，要追加的话得用StreamWriter(path, true)。

唯一好处：

• 不用手动管线程安全（每个Task独立操作，系统会处理锁冲突，但冲突时会抛IO异常，得自己处理），也不会留文件句柄，退出时不用额外清理。

最终选择 #

结合你的核心需求（性能）和场景，复用StreamWriter是必选方案，只要处理好线程安全和资源管理就行。

优化后的复用示例代码 #

public static Dictionary<string, (StreamWriter Writer, object LockObj)> writers = new Dictionary<string, (StreamWriter, object)>();

public static void Main()
{
    Dictionary<string, object> Param1 = new Dictionary<string, object>();
    string filePath = "a path";
    string key = "a key";
    // 用追加模式避免覆盖原有内容
    var writer = new StreamWriter(filePath, true);
    // 每个文件配独立的锁对象，避免全局锁瓶颈
    writers.Add(key, (writer, new object()));

    Timer timer = new Timer();
    timer.Interval = 1000; // 按需求调整间隔，原代码是100ms即10次/秒
    timer.Elapsed += (sender, e) => { Task.Run(() => SampleMethod(Param1, key)); };
    timer.Enabled = true;
}

public static void SampleMethod(Dictionary<string, object> collection, string key)
{
    if (writers.TryGetValue(key, out var entry))
    {
        lock (entry.LockObj)
        {
            entry.Writer.WriteLine(JsonConvert.SerializeObject(collection));
            // 按需开启实时刷新，不需要的话可以注释掉
            // entry.Writer.Flush();
        }
    }
}

// 程序退出时调用，确保所有文件句柄被释放
public static void Cleanup()
{
    foreach (var entry in writers.Values)
    {
        entry.Writer.Dispose();
    }
    writers.Clear();
}

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