如何在循环或方法执行期间阻止其他线程修改指定变量的值

你需要实现的是maskValue变量在myMethod全执行周期（含并行流处理阶段）的修改独占权限，或是保证并行流处理时读取的maskValue值稳定，可根据业务场景选择以下实现方案：

方案1：ReentrantLock 读写统一管控（强独占、阻塞外部修改） #

所有对maskValue的读写操作都绑定同一把锁，myMethod执行期间全程持有锁，其他线程调用setter时会被阻塞直到方法执行完成，完全符合「执行期间不允许其他线程修改」的强需求。

import java.util.concurrent.locks.ReentrantLock;

class MyClass {
  private boolean maskValue = false;
  // 专门管控maskValue读写的独立锁
  private final ReentrantLock maskLock = new ReentrantLock();

  // getter加锁，保证读取值的一致性
  public boolean getMaskValue() {
    maskLock.lock();
    try {
      return maskValue;
    } finally {
      maskLock.unlock();
    }
  }

  // setter加锁，只有持有锁才能修改值
  public void setMaskValue(boolean maskValue) {
    maskLock.lock();
    try {
      this.maskValue = maskValue;
    } finally {
      maskLock.unlock();
    }
  }

  public void myMethod () {
    maskLock.lock(); // 方法启动就抢占锁，全程持有
    try {
      // 并行流执行期间锁不释放，其他线程无法修改maskValue
      list.parallelStream().forEach(item -> doStuff(item));
    } finally {
      maskLock.unlock(); // 方法执行完成后才释放锁，允许其他线程修改
    }
  }
}

方案2：快照读取（无锁、不阻塞外部修改） #

如果你的需求仅为并行流本次处理用到的maskValue值不变，允许外部线程在流执行期间修改maskValue（修改后的值不影响本次流处理逻辑），可以用局部变量存快照的方式实现，性能更高无锁开销：

class MyClass {
  // 加volatile保证读取时的可见性，能拿到最新的变量值
  private volatile boolean maskValue = false;

  public boolean getMaskValue() {
    return maskValue;
  }

  public void setMask(boolean maskValue) {
    this.maskValue = maskValue;
  }

  public void myMethod () {
    // 流启动前读取一次变量值作为本次处理的快照，赋值给final局部变量
    final boolean localMask = maskValue;
    // 并行流内部仅使用局部快照，外部对原变量的修改不会影响本次处理
    list.parallelStream().forEach(item -> doStuff(item, localMask));
  }
}

方案3：synchronized 内置锁实现（轻量场景替代方案） #

如果项目逻辑简单并发量不高，也可以用Java内置的synchronized关键字实现和ReentrantLock一致的独占效果：

class MyClass {
  private boolean maskValue = false;

  public synchronized boolean getMaskValue() {
    return maskValue;
  }

  public synchronized void setMaskValue(boolean maskValue) {
    this.maskValue = maskValue;
  }

  // 方法加内置锁，执行期间其他线程无法调用加了synchronized的setter/getter
  public synchronized void myMethod () {
    list.parallelStream().forEach(item -> doStuff(item));
  }
}

注意synchronized是对象粒度的锁，如果类内有多个独立的管控变量，建议拆分独立锁对象，避免锁粒度过大影响整体性能。

内容的提问来源于stack exchange，提问作者Vishal Kohli