第1部分

显然，不变性可以最大程度地减少多处理器编程中对锁的需求，但是它消除了这种需求吗？还是存在仅不变性还不够的情况？在我看来，您只能推迟处理和封装状态，直到大多数程序必须实际执行某些操作（更新数据存储，生成报告，引发异常等）之前。这样的动作能否始终不加锁地进行？扔掉每个对象并创建一个新对象而不是更改原始对象（对不变性的粗略看法）的纯粹行动是否提供了对进程间争用的绝对保护，还是有些仍然需要锁定的情况？

我知道很多函数式程序员和数学家都喜欢谈论“无副作用”，但是在“现实世界”中，所有事情都有副作用，即使这是执行机器指令所需的时间。我对理论/学术答案和实际/现实答案都感兴趣。

如果不变性是安全的，那么在给定某些界限或假设的情况下，我想知道“安全区”的边界到底是什么。可能的边界的一些示例：

• 输入输出
• 异常/错误
• 与其他语言编写的程序的交互
• 与其他机器（物理，虚拟或理论上的机器）的交互

特别感谢@JimmaHoffa 的评论，这开始了这个问题！

第2部分

多处理器编程通常用作优化技术-使某些代码运行更快。什么时候使用锁和不可变对象更快？

考虑到阿姆达尔定律所规定的限制，与可变对象锁定相比，什么时候可以实现更好的整体性能（考虑或不考虑垃圾收集器）？

摘要

我将这两个问题合并为一个，以尝试了解边界不变性在哪里作为线程问题的解决方案。

如果回答得当，这是一个措辞古怪的问题，确实非常广泛。我将着重于澄清您要询问的一些细节。

不变性是设计权衡。它使某些操作变得更困难（快速修改大型对象的状态，零碎地构建对象，保持运行状态等），而使其他操作变得更困难（更轻松的调试，更容易的程序行为推理，而不必担心工作时底层的变化）并发等）。这是我们关心的最后一个问题，但我想强调一下这是一个工具。一个好工具，通常可以解决比它引起的问题更多的问题（在大多数现代程序中），但不是灵丹妙药……不是改变程序固有行为的东西。

现在，您能得到什么呢？不变性让您一件事：您可以自由阅读不可变对象，而不必担心其内部的状态发生变化（假设它确实是真正不可改变的……拥有一个可变成员的不可变对象通常会破坏交易）。而已。它使您无需管理并发（通过锁，快照，数据分区或其他机制；原来的问题侧重于锁是...鉴于问题的范围，这是不正确的）。

事实证明，尽管很多东西都可以读取对象。IO可以，但是IO本身往往不能很好地处理并发使用。几乎所有处理都可以，但是其他对象可能是可变的，或者处理本身可能使用对并发不友好的状态。在某些语言中，复制对象是一个很大的隐患，因为完整复制（几乎）绝不是原子操作。这是不可变对象为您提供帮助的地方。

至于性能，这取决于您的应用程序。锁（通常）很重。其他并发管理机制更快，但对您的设计有很大影响。通常，使用不可变对象（并避免其弱点）的高度并发设计将比锁定可变对象的高度并发设计更好。如果您的程序轻微并发，则取决于和/或无关紧要。

但是性能不是您最关心的问题。编写并发程序很难。调试并发程序很难。不可变的对象消除了手动实现并发管理错误的机会，从而帮助提高了程序的质量。它们使调试更加容易，因为您没有尝试跟踪并发程序中的状态。它们使您的设计更简单，从而消除了那里的错误。

综上所述：不变性有助于但不能消除正确处理并发所需的挑战。这种帮助往往无处不在，但是最大的收获是从质量角度而不是性能角度。不，不变性不会神奇地使您无法管理应用程序中的并发，抱歉。

一个接受某些值并返回其他值的函数，并且不会干扰该函数之外的任何东西，没有副作用，因此是线程安全的。如果您想考虑函数执行方式如何影响功耗等问题，那就是另一个问题。

我假设您所指的是图灵完备的计算机，该计算机正在执行某种定义明确的编程语言，而其中的实现细节无关紧要。换句话说，如果我用自己选择的编程语言编写的函数可以保证在该语言范围内的不变性，那么堆栈在做什么就无关紧要。当我使用高级语言编程时，我不会考虑堆栈，也不必这样做。

为了说明它是如何工作的，我将在C＃中提供一些简单的示例。为了使这些例子正确，我们必须做一些假设。首先，编译器遵循C＃规范没有错误，其次，它生成正确的程序。

假设我想要一个简单的函数，它接受一个字符串集合，并返回一个字符串，该字符串是集合中所有字符串的连接，并用逗号分隔。C＃中一个简单，简单的实现可能看起来像这样：

public string ConcatenateWithCommas(ImmutableList<string> list)
{
    string result = string.Empty;
    bool isFirst = false;

    foreach (string s in list)
    {
        if (isFirst)
            result += s;
        else
            result += ", " + s;
    }
    return result;
} 

这个例子是不可变的，表面上是相貌的。我怎么知道 因为string对象是不可变的。但是，实现并不理想。因为它result是不可变的，所以每次循环时都必须创建一个新的字符串对象，以替换result指向该对象的原始对象。这可能会对速度产生负面影响，并给垃圾收集器施加压力，因为它必须清理所有这些多余的字符串。

现在，让我说一下：

public string ConcatenateWithCommas(ImmutableList<string> list)
{
    var result = new StringBuilder();
    bool isFirst = false;

    foreach (string s in list)
    {
        if (isFirst)
            result.Append(s);
        else
            result.Append(", " + s);
    }
    return result.ToString();
} 

请注意，我已将其替换string result为可变对象StringBuilder。这是很多比第一个例子更快，因为一个新的字符串不是通过每一次循环中产生。相反，StringBuilder对象仅将每个字符串中的字符添加到字符集合中，并在最后输出整个内容。

即使StringBuilder可变，此函数是否不变？

是的。为什么？因为每次调用此函数，都会为该调用创建一个新的StringBuilder。 因此，现在我们有了一个纯函数，该函数是线程安全的，但包含可变组件。

但是，如果我这样做了怎么办？

public class Concatenate
{
    private StringBuilder result = new StringBuilder();
    bool isFirst = false;

    public string ConcatenateWithCommas(ImmutableList<string> list)
    {
        foreach (string s in list)
        {
            if (isFirst)
                result.Append(s);
            else
                result.Append(", " + s);
        }
        return result.ToString();
    } 
}

此方法是线程安全的吗？不，不是。为什么？因为该类现在保持我的方法所依赖的状态。 该方法中现在出现了竞争条件：一个线程可以修改IsFirst，但是另一个线程可以执行第一个线程Append()，在这种情况下，我现在在字符串的开头有一个逗号，该逗号不应该存在。

我为什么要这样做？好吧，我可能希望线程在result不考虑顺序或线程进入顺序的情况下将字符串累积到我的计算机中。也许是记录器，谁知道呢？

无论如何，要解决此问题，我lock在方法的内在之处发表了声明。

public class Concatenate
{
    private StringBuilder result = new StringBuilder();
    bool isFirst = false;
    private static object locker = new object();

    public string AppendWithCommas(ImmutableList<string> list)
    {
        lock (locker)
        {
            foreach (string s in list)
            {
                if (isFirst)
                    result.Append(s);
                else
                    result.Append(", " + s);
            }
            return result.ToString();
        }
    } 
}

现在，它又是线程安全的。

我的不可变方法可能无法实现线程安全的唯一方法是，如果该方法以某种方式泄漏了其实现的一部分。这会发生吗？如果编译器正确且程序正确，则不是。我是否需要对此类方法进行锁定？没有。

有关在并发场景中如何泄漏实现的示例，请参见此处。

我不确定我是否理解您的问题。

恕我直言，答案是肯定的。如果所有对象都是不可变的，则不需要任何锁。但是，如果需要保留状态（例如，实现数据库或需要汇总来自多个线程的结果），则需要使用可变性，因此还需要锁定。不变性消除了对锁的需求，但是通常您负担不起完全不变的应用程序。

第2部分的答案-锁定应始终比没有锁定慢。

将一堆相关状态封装在对一个不可变对象的单个可变引用中，可以使用以下模式无锁定地执行多种状态修改：

do
{
   oldState = someObject.State;
   newState = oldState.WithSomeChanges();
} while (Interlocked.CompareExchange(ref someObject.State, newState, oldState) != oldState;

如果两个线程都尝试someObject.state同时更新，则两个对象都将读取旧状态并确定没有彼此更改的新状态。执行CompareExchange的第一个线程将存储它认为下一个状态应该是的状态。第二个线程将发现该状态不再与先前读取的状态匹配，因此将在第一个线程的更改生效的情况下重新计算系统的正确下一个状态。

这种模式的优势在于，被交错放置的线程无法阻止其他线程的进程。它具有进一步的优势，即使存在大量争用，某些线程也将一直在进步。但是，它的缺点是，在存在争用的情况下，许多线程可能会花费大量时间来完成工作，最终将其丢弃。例如，如果不同CPU上的30个线程都尝试同时更改一个对象，则一个对象将在第一次尝试时成功，一次尝试在第二次尝试成功，一次尝试在第三次尝试等等，因此每个线程平均最终进行大约15次尝试更新其数据。使用“建议”锁可以显着改善事情：在线程尝试更新之前，它应检查是否设置了“争用”指示器。如果是这样的话，它应该在执行更新之前获取一个锁。如果线程尝试进行几次不成功的更新，则应设置竞争标志。如果试图获取锁的线程发现没有其他人在等待，则应清除竞争标志。请注意，此处的锁定对于“正确性”不是必需的；代码即使没有也可以正常工作。锁定的目的是最大程度地减少代码花费在不太可能成功的操作上的时间。

你开始

显然，不变性最大程度地减少了多处理器编程中的锁需求

错误。您需要仔细阅读所用每个类的文档。例如，C ++中的const std :: string 不是线程安全的。不可变的对象可以具有在访问它们时改变的内部状态。

但是您是从完全错误的角度来看待这个问题。对象是否不可变并不重要，重要的是您是否更改了它。您的意思是说“如果您从不参加驾驶考试，就永远不会因为醉酒驾驶而失去驾驶执照”。是的，但是没有讲到重点。

现在在示例代码中，有人用名为“ ConcatenateWithCommas”的函数编写了：如果输入是可变的并且您使用了锁，那么您将获得什么？如果在尝试连接字符串时其他人尝试修改列表，则锁可以防止崩溃。但是您仍然不知道在其他线程更改字符串之前还是之后将字符串连接起来。因此，您的结果相当无用。您遇到的问题与锁定无关，并且无法通过锁定解决。但是，如果您使用不可变的对象，而另一个线程用一个新的对象替换了整个对象，则您使用的是旧对象而不是新对象，因此结果是无用的。您必须在实际功能级别上考虑这些问题。