已关闭，此问题需要更focused。目前不接受答复。
**想改善这个问题吗？**更新问题，使其仅通过editing this post关注一个问题。

12小时前关闭。
Improve this question
在C中，有哪些常用的模式可以使类成为线程安全的，同时保持其原始性能或不会有太多的性能损失？
另一件让我非常惊讶的事情是，“不可变的保持器模式”在C中并不常用，我想知道为什么。例如，在Java中，我看到这个模式是这样使用的：

class NumberRange {
  private final AtomicReference<NumberRangeHolder> holder;

  public NumberRange(int lower, int upper, boolean floor) {
     holder = new AtomicReference<>(new NumberRangeHolder(lower, upper, floor));
  }

  public void expand() throws RangeException {
     NumberRangeHolder prev;
     NumberRangeHolder next;
     do {
       prev = holder.get();
       next = prev.expand(); // Throws RangeException
     } while (!holder.compareAndSet(prev, next));
  }
}

其中holder类似于：

final public class NumberRangeHolder {
   private final int STEP = 10;
   private final int lower;
   private final int upper;
   private final boolean absolute;
   
   public NumberRangeHolder(int lower, int upper, boolean absolute) {
      this.lower = (lower > upper) ? upper : lower;
      this.upper = (lower < upper) ? upper : lower;
      this.absolute = absolute;
   } 

   public NumberRangeHolder expand() throws RangeException {
      final int lowerLimit = -(Integer.MAX_VALUE - STEP);
      if (lower < lowerLimit) throw new RangeException("can't expand lower (overflow)");
      final int upperLimit = Integer.MAX_VALUE - STEP;
      if (upper > upperLimit) throw new RangeException("can't expand upper (overflow)");
      return new NumberRangeHolder(lower - STEP, upper + STEP, absolute);
   }

因为我们使用了Compare和Swap以及Atomic，所以NumberRange应该是一个线程安全的类。与C++中其他常用的模式相比，这种模式有什么大的缺点吗？（例如，经过验证的性能命中率或经过验证的内存命中率等）