c# - 如果中间有外部 api 调用，如何处理 lock 语句

Question

我有以下代码:

private static HashSet<SoloUser> soloUsers = new HashSet<SoloUser>();

    public void findNewPartner(string School, string Major)
    {
        lock (soloUsers)
        {
            SoloUser soloUser = soloUsers.FirstOrDefault(s => (s.School == School) && (s.Major == Major));
            MatchConnection matchConn;
            if (soloUser != null)
            {
                if (soloUser.ConnectionId != Context.ConnectionId)
                {                                                                     
                    soloUsers.Remove(soloUser);
                }

            }
            else
            {   string sessionId = TokenHelper.GenerateSession();                                     

                soloUser = new SoloUser
                {
                    Major = Major,
                    School = School,
                    SessionId = sessionId,
                    ConnectionId = Context.ConnectionId
                };

                soloUsers.Add(soloUser);


            }

        } 

    }

TokenHelper.GenerateToken(soloUser.Session) 和 TokenHelper.GenerateModeratorToken(session); 可能很危险，因为它们可能需要一些时间才能生成 token 。这将暂时锁定所有用户，这可能是一个问题？这个逻辑是否有任何解决方法，以便我仍然可以保持所有线程安全？

编辑: 我删除了 TokenHelper.GenerateToken(soloUser.Session) 和 TokenHelper.GenerateModeratorToken(session) ，因为我意识到它们可能发生在锁之外，但每个 SoloUser 有一个名为 SessionId 的属性，该属性是为每个用户生成的。 GenerateSession 方法也需要一些时间。每个用户在添加到集合之前都需要拥有这些 SessionId 之一

Answer 1

如果您有能力获得两次锁定，并且偶尔会生成一个 sessionId 但从未使用过也没关系，那么您可以将GenerateSession移出锁定。

类似这样的事情:

 public void findNewPartner(string School, string Major)
    {
        SoloUser soloUser = null;

        lock (soloUsers)
        {
            soloUser = soloUsers.FirstOrDefault(s => (s.School == School) && (s.Major == Major));
        }

        string sessionId = null;

        // will we be creating a new soloUser?
        if (soloUser == null)
        { 
            // then we'll need a new session for that new user
            sessionId = TokenHelper.GenerateSession();
        }

        lock (soloUsers)
        {
            soloUser = soloUsers.FirstOrDefault(s => (s.School == School) && (s.Major == Major));
            if (soloUser != null)
            {
                // woops! Guess we don't need that sessionId after all.  Oh well! Carry on...
                if (soloUser.ConnectionId != Context.ConnectionId)
                {                                                                     
                    soloUsers.Remove(soloUser);
                }

            }
            else
            {   
                // use the sessionid computed earlier
                soloUser = new SoloUser
                {
                    Major = Major,
                    School = School,
                    SessionId = sessionId,
                    ConnectionId = Context.ConnectionId
                };

                soloUsers.Add(soloUser);

        }

    } 

这基本上会进行快速锁定，以查看是否需要构造新的soloUser，如果需要，那么我们需要生成一个新 session 。新 session 的生成发生在锁之外。然后我们重新获取锁并执行原来的一组操作。当构造一个新的soloUser时，它使用在锁之外构造的sessionId。

此模式可能会生成从未使用过的 sessionId。如果两个线程同时执行此函数，且学校和专业相同，则两个线程都会生成 session id，但只有其中一个线程会成功创建一个新的 soloUser 并将其添加到集合中。失败的线程将在集合中找到soloUser并将其从集合中删除 - 并且不使用它刚刚生成的sessionId。此时，两个线程都将引用具有相同 sessionId 的同一个 soloUser，这似乎就是目标。

如果 sessionId 具有与其关联的资源(例如数据库中的条目)，但当 sessionId 过期时这些资源将被清除，那么像这样的冲突将产生一些额外的噪音，但总体上不会影响系统。

如果生成的 sessionId 没有任何需要清理或老化的关联，那么您可能会考虑丢失我的示例中的第一个锁，并且始终生成一个 sessionId，无论是否需要。这可能不太可能发生，但我之前在特殊情况下使用过这种“混杂”的技巧，以避免跳进跳出高流量锁。如果创建成本低而锁定成本高，那么就放弃创建并小心锁定。

确保GenerateSession的成本足够高，足以证明这种额外的运行是合理的。如果GenerateSession需要纳秒才能完成，那么您不需要所有这些 - 只需将其保留在最初编写的锁中即可。如果GenerateSession需要“很长一段时间”(一秒或更长？500毫秒或更多？不能说)，那么将其移出锁是一个好主意，可以防止共享列表的其他使用必须等待。