同步访问集合

Question

我有可能在两个不同线程上同时运行的这两段代码：

users = (from user in users
         orderby user.IsLoggedIn descending ,
                 user.Username
         select user).ToList();

和：

users=null;

第二段代码将在应用程序的主 UI 线程上运行。如何防止在 LINQ 操作完成之前将用户设置为 null？将用户集合封装在一个属性中，并在 getter 和 setter 上加锁，我认为这还不够……

编辑： 我构建了以下测试类：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;

namespace MultiThreading_Spike
{
    class Program
    {
        private static List<User> users;
        private static Timer timer;
        static void Main(string[] args)
        {

            timer=new Timer(OrderUsers,null,5,5);
            for (int i = 0; i < 10000; i++)
            {
                ResetUsers();
                Thread.Sleep(5);
                users = new List<User>
                            {
                                new User {UserName = "John"},
                                new User {UserName = "Peter"},
                                new User {UserName = "Vince"},
                                new User {UserName = "Mike"}
                            };
                Thread.Sleep(5);
            }
            ResetUsers();
            Thread.Sleep(5)
            Debug.Assert(users==null);
        }

        private static void OrderUsers(object state)
        {
            if(users==null)return;
            Thread.Sleep(2);
            try
            {
                users = (from user in users
                         orderby user.IsLoggedIn descending ,
                             user.UserName
                         select user).ToList();
            }
            catch(Exception e)
            {
                Console.WriteLine("Error: {0}",e.Message);
            }
        }

        private static void ResetUsers()
        {
            users = null;
        }
    }


    public class User
    {
        bool isLoggedIn;
        public bool IsLoggedIn
        {
            get { return isLoggedIn; }
            set { isLoggedIn = value; }

        }

        private string userName;
        public string UserName
        {
            get { return userName; }
            set { userName = value; }
        }
    }
}

此代码失败，OrderUsers 方法中出现空引用异常。 然后我实施了建议的解决方案： 解决方案一：

//identical code omitted
        private static void OrderUsers(object state)
        {
         lock(syncRoot)
         {
            if(users==null)return;
            Thread.Sleep(2);
            try
            {
                users = (from user in users
                         orderby user.IsLoggedIn descending ,
                             user.UserName
                         select user).ToList();
            }
            catch(Exception e)
            {
                Console.WriteLine("Error: {0}",e.Message);
            }
         }
      }

        private static void ResetUsers()
        {
            lock(syncRoot)
            {
               users = null;
            }
        }
    }

没有例外！

解决方案 2：

   private static void OrderUsers(object state)
    {
        if(users==null)return;
        var tempUsers = users;
        Thread.Sleep(2);
        try
        {
            tempUsers = (from user in tempUsers
                     orderby user.IsLoggedIn descending ,
                         user.UserName
                     select user).ToList();
        }
        catch(Exception e)
        {
            Console.WriteLine("Error: {0}",e.Message);
        }
        users = tempUsers;
    }

没有空引用异常，但最终用户为空的Assert可能会失败。

解决方案 3：

private static void OrderUsers(object state)
        {
            if(users==null)return;
            try
            {
                users.Sort((a, b) => Math.Sign(-2 * a.IsLoggedIn.CompareTo(b.IsLoggedIn) + a.UserName.CompareTo(b.UserName)));
            }
            catch(Exception e)
            {
                Console.WriteLine("Error: {0}",e.Message);
            }
        }

没有例外。我一直有一种烦人的感觉，即排序可能“就位”，但不一定是原子的。

解决方案 4： 我无法编译它。 VolatileRead 方法有一个重载对象，但我无法让它接受一个列表

Answer 1

您需要在执行 linq 查询之前和设置为 null 之前锁定：

lock(syncRoot) 
{
    users = null;
}

和

lock(syncRoot) 
{
    users = 
        (from user in users
         orderby user.IsLoggedIn descending,
                 user.Username
         select user).ToList(); 
}

在哪里同步根：

private static syncRoot = new object();

Answer 2

将用户保存到本地变量和操作符上，这样您就不必同步任何内容。

var tempUsers = users;
if (tempUsers != null)
{
    tempUsers = (from user in tempUsers
             orderby user.IsLoggedIn descending, user.Username
             select user).ToList()
}

Answer 3

最好的方法是调用List<T>.Sort，它对列表进行就地排序并且不需要分配。

例如：

users.Sort((a, b) => Math.Sign(
    -2 * a.IsLoggedIn.CompareTo(b.IsLoggedIn) + a.UserName.CompareTo(b.UserName)
));

（此示例假设没有一个用户为空）

如果在执行此操作时，另一个线程执行users = null，则旧的List<T> 将被排序，但users 变量不会受到影响。

Answer 4

无论users 变量是否重置为null，LINQ 查询都会完成，因为ToList() 强制进行急切评估。但是，我不确定这是否会解决您的问题：如果我理解正确，您希望确保不会在 users 中留下陈旧的集合，因为设置为 null 的时间太早了。

在这种情况下，您可能只需声明一个用户锁定对象并在 setter 和 query-and-set 语句周围对其进行同步即可。

Answer 5

你锁定什么并不重要，只要两个线程同意锁定同一个东西。

就个人而言，我会使用局部变量和无锁操作：

var localUsers = Thread.VolatileRead(ref users);
do
{
  if (null == localUsers)
  {
    break;
  }

  var newLocalUsers = (from user in localUsers 
        orderby user.IsLoggedIn descending ,                 
        user.Username         
        select user).ToList();

  var currentLocalUsers = Interlocked.CompareExchange(ref users, newLocalUsers, localUsers);
  if (currentLocalUsers == localUsers)
  {
    break;
  }
  // bummer, try again
  localUsers = currentLocalUsers;
} while(true);

还有另一个线程：

Interlocked.Exchange(ref users, null);

我从未尝试过将 Interlocked 与 var 类型一起使用，不确定编译器如何接受它还是必须将其向下转换为 object。