多线程无锁

最新推荐文章于 2023-10-14 20:02:37 发布

cunxiedian8614

最新推荐文章于 2023-10-14 20:02:37 发布

阅读量207

点赞数

文章标签： c# 数据结构与算法 java

仅仅因为您在线程之间共享数据结构并不意味着您必须使用锁。

多年来，我遇到了一些方法，这些方法可以帮助协调线程之间的工作，而不必等待任何人等待。这里有几个。

警告：我停止使用这些模式是因为它们容易被误解和误用，这可能会导致难以诊断的随机错误。如果使用这些模式，则不会帮助下一个开发人员更好地理解代码或避免错误。你被警告了。

Reference to an immutable object

我们知道在多线程环境中，修改不带锁的共享对象是一个坏主意。但是替换它呢？

例如，考虑此代码。我将使用C＃，但是在Java，C ++或其他具有线程的传统语言中也是如此。

public class FunWithThreads {
    private Thing thing;

    public void InThreadOne() {
        this.thing = new Thing()
    }

    public Result InThreadTwo() {
        var localThing = this.thing;
        var result1 = SomeCalculation1(localThing);
        var result2 = SomeCalculation2(localThing);
        var finalResult = DoMoreWork(localThing, result1, result2);
        return result;
    }
}

假设有许多线程正在同时调用InThreadOne（），而许多其他线程正在同时调用InThreadTwo（）。我们会得到错误的结果，比赛条件或冲突吗？

并不是的。InThreadTwo（）始终指的是一致版本这东西因为它将对它的引用放置到局部变量中，并且从那时起仅使用局部引用。如果计算花费的时间太长，那么也许我们得到的结果有些陈旧，但结果始终是一致的。

有用的地方：我发现这种方法在任何时候都非常有用这东西是一个大型的，预先计算的数据结构，不经常更新但经常读取。通常，我已经使用它为内部资本市场应用程序缓存了一些数据，以使该应用程序对用户而言更加敏捷。

陷阱：确保这一点非常重要这东西在方法开始时仅被引用一次，否则我们将回到比赛状态。同样重要的是这东西分配后永远不会修改。这意味着很多描述性注释，非常仔细的代码审查，并确保每个看过此代码的开发人员都知道所有问题。在更大的代码库中，某人（甚至您也可以！）可能仍然找到在某处犯错误的方法。

Complex atomic operations

上面的代码起作用的原因是因为在C＃（和大多数其他语言）中，引用的分配是原子操作，即在执行时，另一个线程无法中途潜入并做其他事情。

Modern processors have a few other interesting atomic operations, like compare and swap, implemented in C# as Interlocked.CompareExchange(), and in Java as AtomicInteger.compareAndSet(). This function takes three arguments and does the following as an atomic operation:

比较第一个和第三个参数，然后如果它们相等，则将第一个参数设置为等于第二个参数，或者如果它们不相等，则不执行任何操作。

可以使用这种情况的一种情况是尝试限制对有限资源上昂贵操作的请求。例如，如果昂贵的操作已在运行，则此代码将删除所有请求：

// Let's pretend this class is a singleton.
public class ExpensiveOperationLimiter {
    private int isProcessing = 0; 

    public void RequestExpensiveOperation() {
        // If isProcessing == 1, this does nothing and returns 1.
        // If isProcessing == 0, this sets isProcessing to 1 and returns 0. 
        var wasProcessing = Interlocked.CompareExchange(ref isProcessing, 1, 0);

        if (!wasProcessing) {
            // Only one invocation will be running at a time.
            DoExpensiveOperation()
        }

        isProcessing = 0;
    }

    private void DoExpensiveOperation() {
        // ...
    }
}