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

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 毫秒或更长时间？不能说)，那么将它移出锁是一个好主意，可以防止共享列表的其他使用不得不等待。