Question

我的任务是显示同步和非同步多线程之间的区别。因此，我写了一个模拟从客户的银行账户中提取资金的申请。一些线程中的每一个都选择随机用户并从账户中提取资金。每个帖子都应该撤回一次帐户。第一次线程同步，但第二次它们不同步。因此，同步和非同步线程撤销的帐户之间必须存在差异。对于不同数量的用户和线程，差异必须不同。但在我的应用程序中，我只有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 ms，并在处理完毕之后等待_pause ms。

Answer 1

您的代码没有做任何有用的事情，也没有显示同步和非同步访问之间的区别。你需要解决许多问题。

代码中的注释表示_used是线程访问过的用户列表。你显然是在每个线程的基础上创建它。如果这是真的，我不知道如何。从事物的外观我会说_used可供所有线程访问。我没有看到你在创建该列表的每个线程版本的任何地方。命名约定表明它在类范围内。

如果该列表不是每个线程，那将大大有助于解释为什么您的数据始终相同。你在这里也有一个真正的竞争条件，因为你正在从多个线程更新列表。

确保_used确实是每线程数据结构。。

您有以下代码：

        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;
            }
        }

这两者都提供同步。在isSync情况下，如果线程已经锁定了用户，则第二个线程将无法进行更新。在第二种情况下，第二个线程将等待第一个完成，然后将进行更新。在任何一种情况下，使用Monitor或lock都会阻止并发更新。

但是，如果多个线程可能同时执行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();
        }
    }

所以在IsSync的情况下，你启动一个线程，然后在你启动另一个线程之前等待它完成。 您的代码不是多线程的。在“未同步”的情况下，您使用lock来阻止并发更新。因此，在一种情况下，您通过一次只运行一个线程来阻止并发更新，而在另一种情况下，您可以使用lock来阻止并发更新。没有区别。

值得注意的是，您随机选择用户的方法效率很低，可能是您所看到的问题的一部分。基本上你正在做的是选择一个随机数并检查它是否在列表中。如果是，你再试一次，等等。这个名单不断增长。快速实验表明，在获得所有这些之前，我必须在0到1,000之间生成7,000个随机数。因此，您的主题花费了大量时间来尝试查找下一个未使用的帐户，这意味着他们同时处理相同用户帐户的可能性较小。

你需要做三件事。首先，更改您的Withdrawl方法，以便执行此操作：

        if (isSync) //isSync = if threads syncroized
        {
            // synchronized. prevent concurrent updates.
            lock (users[ind])
            {
                users[ind].FinishSync = users[ind].FinishSync - sum;
            }
        }
        else
        {
            // unsynchronized. It's a free-for-all.
            users[ind].FinishUnsync = users[ind].FinishUnsync - sum;
        }

无论Withdrawing是否为真，您的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, false); }));
            _threads[i].Name = i.ToString();
            _threads[i].Start();
        }

现在你总是有多个线程在运行。唯一的区别是对用户帐户的访问是否同步。

最后，将_used列表列入users列表中的索引列表。类似的东西：

_used = new List<int>(users.Count);
for (int i = 0; i < _used.Count; ++i)
{
    _used[i] = i;
}

现在，当您选择用户时，请执行以下操作：

var x = rnd.Next(_used.Count);
ind = _used[x];
// now remove the item from _used
_used[x] = _used[_used.Count-1];
_used.RemoveAt(_used.Count-1);

这样您就可以更有效地生成所有用户。生成n个用户需要n个随机数。

一些挑剔：

我不知道你为什么在Thread.Sleep方法中进行Withdraw调用。你认为它提供了什么好处？

没有理由将DateTime.Now.Millisecond传递给Random构造函数。只需致电new Random()即可使用Environment.TickCount作为种子。除非你真的想将种子限制在0到1,000之间的数字。

多线程访问列表C＃

1 个答案: