C# 线程/锁混淆

Question

我有以下代码：

var items = new List<string> {"1", "2", "3"}; // 200 items
foreach(var item in items) {
  ThreadPool.QueueUserWorkItem((DoWork), item);
}

private void DoWork(object obj)
{
  lock(this)
  {
    using(var sw = File.AppendText(@"C:\somepath.txt")
    {
      sw.WriteLine(obj);
    }
  }
}

由于线程，出于某种原因，我得到了写入文件的 200 个项目的随机数。 60 或 127 或有时只有 3。如果我删除 ThreadPool 并仅在原始 foreach 循环内写入，则所有 200 项都已成功写入。

不知道为什么会这样？

感谢您的帮助。

Answer 1

MSDN documentation on ThreadPool 的以下注释说明了一切：

托管线程池中的线程是后台线程。也就是说，它们的IsBackground 属性为真。 这意味着在所有前台线程都退出后，ThreadPool 线程将不会继续运行应用程序。

您的应用程序会在您的线程完成运行之前退出（到达Main 的末尾）。

Answer 2

这是我所暗示的一个简单版本。它使用单个事件并且不轮询或旋转，并且它的编写是为了可重用以及同时允许多个工作集。 lambda 表达式可以被分解，如果这样更方便调试的话。

class Program
{
    static void Main(string[] args)
    {
        var items = new string[] { "1", "2", "3", "300" };
        using (var outfile = File.AppendText("file.txt"))
        {
            using (var ws = new WorkSet<string>(x =>
                    { lock (outfile) outfile.WriteLine(x); }))
                foreach (var item in items)
                    ws.Process(item);
        }
    }

    public class WorkSet<T> : IDisposable
    {
        #region Interface

        public WorkSet(Action<T> action)
        { _action = action; }

        public void Process(T item)
        {
            Interlocked.Increment(ref _workItems);
            ThreadPool.QueueUserWorkItem(o =>
                    { try { _action((T)o); } finally { Done(); } }, item);
        }

        #endregion
        #region Advanced
        public bool Done()
        {
            if (Interlocked.Decrement(ref _workItems) != 0)
                return false;

            _finished.Set();
            return true;
        }

        public ManualResetEvent Finished
        { get { return _finished; } }

        #endregion
        #region IDisposable

        public void Dispose()
        {
            Done();
            _finished.WaitOne();
        }

        #endregion
        #region Fields

        readonly Action<T> _action;
        readonly ManualResetEvent _finished = new ManualResetEvent(false);
        int _workItems = 1;

        #endregion
    }
}

Answer 3

又短又甜怎么样？

    static int wrkThreads = 0;
    static readonly EventWaitHandle exit = new ManualResetEvent(false);
    static readonly object syncLock = new object();

    static void Main( string[] items )
    {
        wrkThreads = items.Length;

        foreach ( var item in items )
            ThreadPool.QueueUserWorkItem(( DoWork ), item);

        exit.WaitOne();
    }

    static void DoWork( object obj )
    {
        lock ( syncLock ) {
            /* Do your file work here */
        }
        if ( Interlocked.Decrement(ref wrkThreads) == 0 )
            exit.Set();
    }