Java并发编程学习记录#2

线程安全篇B

为了保持状态的一致性，需要在一个原子性操作中更新相关的状态变量，加锁，可以将一些混合操作变为原子性操作，从而保证线程安全。

锁

1. 内部锁

Java提供了一个加强原子性的内在锁机理-同步块，其包含两部分，一部分是一个可以作为锁的对象的引用，另一部分是由这个锁保护的阻塞代码。同步方法是同步块的一个快捷体现，其作用于所有的方法体。

每一个Java对象都可以作为一个潜在的同步锁，这种内部构建的锁叫做内部锁或是管程锁。当线程进入同步块前会自动获得锁，并在执行退出(正常或异常的情况)后，自动释放锁。

内在锁是一种互斥锁，即至多有一个线程可以拥有锁。当线程A想要获得线程B获得的锁，它必须等待或者阻塞，直到B线程释放锁，若不释放，A会一直等待。

2. 重入性

重入性指的是锁的获得基于每个线程，而不是基于每次调用；一个线程可以成功请求获得它已经持有的锁；

该特性的实现是因为锁的请求获得次数（lockcount）和持有它的线程的关联来实现的。当一个线程获得或者再次获得锁时，在虚拟机里将会lockcount+1，当一个同步块退出时，虚拟机会让lockcount-1。当lockcount=0时，该线程释放锁。

重入性简化了面向对象的并发操作，否则的话，像如下代码中，将会发生死锁。

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

用锁保护状态

由于锁可以将对代码的访问变得序列化，因此可以使用锁来构建一些策略来保障共享状态的排他性。

一个可以被多个线程访问的可变状态，所有的访问都需要持有共同的锁，此时，我们称这个状态被这个锁保护。

对象的内部锁和它的状态没有内在的关联，一个对象的成员不会自动被其内部锁保护。获得一个对象的内部锁，仅仅会阻止其它线程获得这个锁，但并不妨碍其它线程访问这个对象。

每次共享时，一个可变状态需要指定一个具体的锁，并使其使用者知道是哪个锁。

对于每一个拥有多于一个变量的不变量来说，它的所有变量应该使用同一个锁来保护。

一个通用的锁策略是，将所有可变状态用一个对象封装起来，然后所有访问这些可变状态的代码都用这个对象的内部锁保护起来，用来防止并发访问。这种方式很常用，也很简单，但是这样会导致活性和性能问题。

活性和性能

不合适的同步，特别是同步耗时操作，会使得并发能力下降，甚至失去并发能力。

用两段代码解释更直观。

• 粗糙同步,省略了一些次要代码。Servlet框架的设计本意是同时处理多个请求，但是同步后的service方法一旦有耗时操作，那么由于同步的原因，其它的请求只能等上一个请求完成之后才能进行，降低了处理性能。

public class SynchronizedFactorizer extends GenericServlet implements Servlet {
    @GuardedBy("this") private BigInteger lastNumber;
    @GuardedBy("this") private BigInteger[] lastFactors;

    public synchronized void service(ServletRequest req,
                                     ServletResponse resp) {
        BigInteger i = extractFromRequest(req);
        if (i.equals(lastNumber))
            encodeIntoResponse(resp, lastFactors);
        else {
            BigInteger[] factors = factor(i);
            lastNumber = i;
            lastFactors = factors;
            encodeIntoResponse(resp, factors);
        }
    }

    void encodeIntoResponse(ServletResponse resp, BigInteger[] factors) {
    }

    BigInteger extractFromRequest(ServletRequest req) {
        return new BigInteger("7");
    }

    BigInteger[] factor(BigInteger i) {
        // Doesn't really factor
        return new BigInteger[] { i };
    }
}

• 精细同步，只需进行精致的分割，改变同步的位置，便能尽可能的消除加锁对性能带来的影响。见代码：

public class CachedFactorizer extends GenericServlet implements Servlet {
    @GuardedBy("this") private BigInteger lastNumber;
    @GuardedBy("this") private BigInteger[] lastFactors;
    @GuardedBy("this") private long hits;
    @GuardedBy("this") private long cacheHits;

    public synchronized long getHits() {
        return hits;
    }

    public synchronized double getCacheHitRatio() {
        return (double) cacheHits / (double) hits;
    }

    public void service(ServletRequest req, ServletResponse resp) {
        BigInteger i = extractFromRequest(req);
        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(resp, factors);
    }

    void encodeIntoResponse(ServletResponse resp, BigInteger[] factors) {
    }

    BigInteger extractFromRequest(ServletRequest req) {
        return new BigInteger("7");
    }

    BigInteger[] factor(BigInteger i) {
        // Doesn't really factor
        return new BigInteger[]{i};
    }
}

如何确定同步块的大小需要考虑安全性，易用性和性能。有时候，易用性和性能是一对相对矛盾的设计指标。无论何时在使用锁时，应该考虑到被同步的代码能做什么，以及这些代码耗时大概多少。进行大量的计算或是存在潜在的阻塞操作，都有可能加长持有锁的时间，进一步影响到程序的活性和性能。

涉及大量计算和耗时操作（如net或者io）的代码，应避免持有锁。

//待下篇

主要参考自_ Java Concurrency in Practice