对列表 C# 的多线程访问

我有一个任务来显示同步和非同步多线程之间的差异。因此，我编写了一个模拟从客户银行账户中提取资金的应用程序。一些线程中的每一个都会选择一个随机用户并从帐户中提取资金。每个线程应该撤回每个帐户一次。线程第一次同步，但第二次不同步。因此，由同步和非同步线程撤回的帐户之间必须存在差异。对于不同数量的用户和线程，差异必须不同。但是在我的应用程序中，我只有 1000 个线程的差异。所以我需要非同步线程的结果与同步线程的结果有很大不同。类用户：

public class User : IComparable
{
    public string Name { get; set; }
    public int Start { get; set; }
    public int FinishSync { get; set; }
    public int FinishUnsync { get; set; }
    public int Hypothetic { get; set; }
    public int Differrence { get; set; }
...
}

取款方法：

public void Withdraw(ref List<User> users, int sum, bool isSync)
    {
        int ind = 0;
        Thread.Sleep(_due);
        var rnd = new Random(DateTime.Now.Millisecond);
        //used is list of users,  withrawed by the thread
        while (_used.Count < users.Count)
        {
            while (_used.Contains(ind = rnd.Next(0, users.Count))) ; //choosing a random user
            if (isSync) //isSync = if threads syncroized
            {
                if (Monitor.TryEnter(users[ind]))
                {
                    try
                    {
                        users[ind].FinishSync = users[ind].FinishSync - sum;
                    }
                    finally
                    {
                        Monitor.Exit(users[ind]);
                    }
                }
            }
            else
            {
                lock (users[ind])
                {
                    users[ind].FinishUnsync = users[ind].FinishUnsync - sum;
                }
            }
            _used.Add(ind);
        }
        done = true;
    }

线程是这样创建的：

 private void Withdrawing(bool IsSync)
    {
        if (IsSync)
        {
            for (int i = 0; i < _num; i++)
            {
                _withdrawers.Add(new Withdrawer(Users.Count, _due, _pause));
                _threads.Add(new Thread(delegate()
 { _withdrawers[i].Withdraw(ref Users, _sum, true); }));
                _threads[i].Name = i.ToString();
                _threads[i].Start();
                _threads[i].Join();
            }
        }
        else
        {
            for (int i = 0; i < _num; ++i)
            {
                _withdrawers.Add(new Withdrawer(Users.Count, _due, _pause));
                _threads.Add(new Thread(delegate()
 { _withdrawers[i].Withdraw(ref Users, _sum, false); }));
                _threads[i].Name = i.ToString();
                _threads[i].Start();
            }
        }
    }

我以这种方式更改了 Withdraw 类，bc 问题可能在于独立于委托创建线程：

class Withdrawer
{
    private List<int>[] _used;
    private int _due;
    private int _pause;
    public int done;
    private List<Thread> _threads;
    public Withdrawer(List<User> users, int n, int due, int pause, int sum)
    {
        _due = due;
        _pause = pause;
        done = 0;
        _threads = new List<Thread>(users.Count);
        InitializeUsed(users, n);
        CreateThreads(users, n, sum, false);
        _threads.Clear();
        while (done < n) ;
        Array.Clear(_used,0,n-1);
        InitializeUsed(users, n);
        CreateThreads(users, n, sum, true);
    }
    private void InitializeUsed(List<User> users, int n)
    {
        _used = new List<int>[n];
        for (int i = 0; i < n; i++)
        {
            _used[i] = new List<int>(users.Count);
            for (int j = 0; j < users.Count; j++)
            {
                _used[i].Add(j);
            }
        }
    }
    private void CreateThreads(List<User> users, int n, int sum, bool isSync)
    {
        for (int i = 0; i < n; i++)
        {
            _threads.Add(new Thread(delegate() { Withdraw(users, sum, isSync); }));
            _threads[i].Name = i.ToString();
            _threads[i].Start();
        }
    }
    public void Withdraw(List<User> users, int sum, bool isSync)
    {
        int ind = 0;
        var rnd = new Random();
        while (_used[int.Parse(Thread.CurrentThread.Name)].Count > 0)
        {
            int x = rnd.Next(_used[int.Parse(Thread.CurrentThread.Name)].Count);
            ind = _used[int.Parse(Thread.CurrentThread.Name)][x];
            if (isSync)
            {
                lock (users[ind])
                {
                    Thread.Sleep(_due);
                    users[ind].FinishSync -= sum;
                }
            }
            else
            {
                Thread.Sleep(_due);
                users[ind].FinishUnsync -= sum;
            }
            _used[int.Parse(Thread.CurrentThread.Name)][x] = _used[int.Parse(Thread.CurrentThread.Name)][_used[int.Parse(Thread.CurrentThread.Name)].Count - 1];
            _used[int.Parse(Thread.CurrentThread.Name)].RemoveAt(_used[int.Parse(Thread.CurrentThread.Name)].Count - 1);
            Thread.Sleep(_pause);
        }
        done++;
    }
}

现在的问题是 FinishUnSync 值是正确的，而 FinishSync 值绝对不是。 Thread.Sleep（_due）;和 Thread.Sleep（_pause）;

用于"持有"资源，BC 我的任务是线程应该获取资源，保持 _due 毫秒，处理后等待 _pause 毫秒再完成。