【Java并发.2】线程安全性

2018-06-29 来源: 躲猫猫的猫 发布在  https://www.cnblogs.com/zhaww/p/9240054.html

  要编写线程安全的代码,其核心在于要对状态访问操作进行管理,特别是对共享(Shared)和可变的(Mutable)状态的访问。

  “共享”意味着变量可以由多个线程同时访问,而“可变”则意味着变量的值在其生命周期内可以发生变化。我们将像讨论代码那样来讨论线程安全性,但更侧重于如何防止数据在数据上发生不可控的并发访问。

  当多个线程访问某个状态变量并且其中有一个线程执行写入操作时,必须采用同步机制来协同这些线程对变量的访问。Java 中的主要同步机制是关键字 synchronized ,它提供了一种独占的加锁方式,但“同步”这个术语还包括 volatile 类型的变量,显式锁(Explicit Lock)以及原子变量。

如果当多个线程访问同一个可变的状态变量时,没有使用合适的同步,那么程序就会出现错误。有三种方式可以修复这个问题:
  • 不在线程之间共享该状态变量
  • 将专题图变量修改为不可变的变量
  • 在访问状态变量时使用同步

  如果从一开始就设计一个线程安全的类,那么比在以后再将这个类修改为线程安全的类要容易的多。

当设计线程安全的类时,良好的面向对象技术、不可修改性,以及明晰的不变性规范都能起到一定的帮助作用。

2.1  什么是线程安全性  

  给线程安全性给出一个确切的定义:

当多个线程访问某个类时,不管运行时环境采用何种调度方式或者这些线程将如何交替执行,并且在主调代码中不需要任何额外的同步或协同,这个类都能表现出正确的行为,那么就称为这个类时线程安全的。 
在线程安全类中封装了必要的同步机制,因此客户端无须进一步采取同步措施。

  示例:一个无状态的 Servlet

public class StatelessFactorizer implements Servlet {
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        BigInteger i = extractFromRequest(servletRequest);
        BigInteger[] factors = factor(i);
        encodeIntoResponse(servletResponse, factors)
    }
}

  与大多数Servlet 相同,StatelessFactorizer 是无状态的:它既不包含任何域,也不包含任何对其他类中域的引用。计算过程中的临时状态仅存在于线程栈上的局部变量中,并且只能由正在执行的线程访问。

无状态对象一定是线程安全的。

  

2.2  原子性

  假设我们希望增加一个“命中计数器”来统计所处理的请求数量。例如下代码

public class StatelessFactorizer implements Servlet {        【皱眉脸--不要这么做】
    ;
    public long getCount() {
        return count;
    }
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        BigInteger i = extractFromRequest(servletRequest);
        BigInteger[] factors = factor(i);
        ++count;
        encodeIntoResponse(servletResponse, factors)
    }
}

  不幸的是 ++count 不是原子操作,这是一个“读取-修改-写入”的操作序列。(上一节讲的竞态条件)。

  2.2.1  竞态条件

    当某个计算的正确性取决于多个线程的交替执行时序时,那么就会发生竞态条件。

    最常见的竞态条件类型就是“先检查后执行(Check-Then-Act)”操作,即通过一个可能失效的观测结果来决定下一步的动作。

  2.2.2  实例:延迟初始化中的竞态条件

public class LazyInitRace {            【皱眉脸--不要这样做】
    private UnsafeSequence instance = null;
    public UnsafeSequence getInstance() {
        if (instance == null) {
            instance = new UnsafeSequence();
        }
        return instance;
    }
}

    存在另一种竞态条件,在“读取-修改-写入”这种操作。

  2.2.3  复合操作

    LazyInitRace 需要以原子方式执行(不可分割)的操作。要避免竞态条件问题,就必须在某个线程修改该变量时,通过某种方式防止其他线程使用这个变量,从而确保其他线程只能在修改操作完成之前或之后读取和修改状态,而不是在修改状态的过程中。

假定有两个操作A 和B ,如果从执行 A 的线程来看,当另一个线程执行 B 时,要么将 B 全部执行完,要么完全不执行 B,那么 A 和 B 对彼此来说就是原子的。原子操作是指:对于访问同一个状态的所有操作(包括该操作本身)来说,这个操作时一个以原子方式执行的操作。

    所以,我们将介绍加锁机制,这是Java 中用于确保原子性的内置机制。使用 AtomicLong 类型的变量来统计已处理请求的数量。

public class StatelessFactorizer implements Servlet {
    );
    public long getCount() {
        return count.get();
    }
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        BigInteger i = extractFromRequest(servletRequest);
        BigInteger[] factors = factor(i);
        count.incrementAndGet();
        encodeIntoResponse(servletResponse, factors);
    }
}

    在 java.util.concurrent.atomic包中包含了一些原子变量类,用于实现在数值和对象引用上的原子状态转换。

2.3  加锁机制

  当在Servlet 中添加一个状态变量时,可以通过线程安全的对象来管理 Servlet 的状态以维护 Servlet 的线程安全性。但如果想在 Servlet 中添加更多的状态,那么是否只需要添加更多的线程安全状态变量就足够了?

  假设我们希望提升 Servlet 的性能:将最近的计算结果缓存起来。看代码:

public class UnsafeCachingFactorizer implements Servlet {                    【皱眉脸--不要这样做】
    private final AtomicReference<BigInteger> lastNumber = new AtomicReference<>();
    private final AtomicReference<BigInteger[]> lastFactors = new AtomicReference<>();
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        BigInteger i = extractFromRequest(servletRequest);
        if (i.equals(lastNumber.get())) {
            encodeIntoResponse(servletResponse, lastFactors.get());
        } else {
            BigInteger[] factors = factor(i);
            lastNumber.set(i);      //同步1
            lastFactors.set(factors);  //同步2
            encodeIntoResponse(servletResponse, factors);
        }
    }
}

  尽管这里面的原子引用本身都是线程安全的,但是 还是存在着竞态条件。同步1 和 同步2 不是原子操作,可能存在问题。

要保持状态的一致性,就需要在单个原子操作中更新所有相关的状态变量

  2.3.1  内置锁

    Java提供了一种内置的锁机制来支持原子性:同步代码块(Synchronized Block)。同步代码块包括两部分:一个作为锁的对象引用,一个作为由这个锁保护的代码块。静态的synchronized 方法以 Class 对象作为锁。

    Java 的内置锁相当于一种互斥锁,这意味着最多只有一个线程能持有这种锁。由这个锁保护的同步代码会以原子方式执行,多个线程在执行该代码块时也不会相互干扰。

    在上一个程序清单里,如果使用关键字 synchronized 来修饰 service 方法,因此在同一个时刻只有一个线程可以执行 service 方法。然而,这种方法却过于极端,因为多个客户端无法同时使用Servlet ,服务响应性非常低,无法令人接受。

  2.3.2  重入

    当某个线程请求一个由其他线程持有的锁时,发出请求的线程会阻塞。然而,由于内置锁是可重入的,因此如果某个线程试图获得一个由自己持有的锁,那么这个请求就会成功。

    “重入” 意味着获取锁的操作的粒度是“线程”,而不是“调用”。

    下面代码清单:如果内置锁不是可重入的,那么这段代码将发生死锁。

public class Widget {
    public synchronized void doSomething() {
      ...
    }
}
public class LoggingWidget extends Widget {
     public synchronized void doSomething() {
        System.out.println(toString() + ": calling doSomething");
        super.doSomething();
    }
}

2.4  用锁来保护状态

  由于锁能使其保护的代码路径以串行形式来访问,因此可以通过锁来构造一些协议来实现对共享状态的独占访问。

对于可能被多个线程同时访问的可变状态变量,在访问它时都需要持有同一个锁,在这种情况下,我们称状态变量是由这个锁保护的。
每个共享的和可变的变量都应该只由一个锁来保护,从而使维护人员指导是哪一个锁。

  一种常见的加锁约定是,将所有的可变状态都封装在对象内部,并通过对象的内置锁对所有访问可变状态的代码路径进行同步,使得在该对象上不会发生并发访问。 

  当类的不可变性条件涉及多个状态变量时,那么还有另外一个需求:在不变性条件中的每个变量都必须由同一个锁来保护

  如果同步可以避免竞态条件,那么为什么不在每个方法声明时都使用同步呢?事实上,如果不加区别的滥用 synchronized ,可能导致程序中出现过多的同步。

  此外,将每个方法都作为同步方法还可能导致活跃性问题(Liveness)或性能问题(Performance)。

2.5  活跃性与性能

  之前有介绍对整个 service 方法进行同步,虽然这种简单且粗粒度的方法能确保线程安全性,但付出的代价却很高。我们将这种应用程序称为不良并发(Poor Concurrent)应用程序:可同时调用的数量,不仅受到可用处理资源的限制,还受到应用程序本身结构的限制。

  缓存最近执行因数分解的数值 及其计算结果的 Servlet:

public class UnsafeCachingFactorizer implements Servlet {
    private BigInteger lastNumber;
    private BigInteger[] lastFactors;
    private long hits;
    private long cacheHits;
    public synchronized  long getHits() { return hits;}
    public synchronized  double getCacheHitRatio() {
        return (double) cacheHits / (double) hits;
    }
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        BigInteger i = extractFromRequest(servletRequest);
        BigInteger[] factors = null;
        synchronized (this) {
            ++hits;
            if (i.equals(lastNumber)) {
                ++cacheHits;
                factors = lastFactors.clone();
            }
        }
        if (factors == null) {
            factors = factor(i);
            synchronized (this) {
                lastNumber = i;
                lastFactors = factors.clone();
            }
        }
        encodeIntoResponse(servletResponse, factors);
    }
} 

  在上面的改造后的代码 实现了在简单性(对整个方法进行同步) 与并发性(对尽可能短的代码路径进行同步)之间的平衡。在获取与释放锁等操作上都需要一定的开销,因此如果将同步代码块分解的过细,那么通常并不好,尽管这样不会破坏原子性。

通常,在简单性与性能之间存在着相互制约因素。当实现某个同步策略时,一定不要盲目地为了性能而牺牲简单性(着可能会破坏安全性)

  无论是执行计算密度的操作,还是在执行某个可能阻塞的操作,如果持有锁的时间过长,那么都会带来活跃性或性能问题  

当执行时间较长的计算或者可能无法快速完成的操作时(例如:网络 I/O 或控制台 I/O),一定不要持有锁。

  

相关文章