Java并发编程实战

线程安全性

1. 一个对象是否线程安全，取决于它是否被多个线程访问
2. Java的同步机制关键字是synchronized，它提供了一种独占的加锁方式，但“同步”这个术语还包括volatile类型的变量，显式锁以及原子变量
3. 由于不恰当的执行时序而出现不正确的结果这种情况成为：静态条件(race condition，这里的condition翻译成情况更合适)
4. 大多数竞态条件的本质：基于一种可能失效的观察结果做出判断或者执行某个计算，这种类型的竞态条件称为“先检查后执行”，一个常见的案例就是延迟初始化，代码如下：

@NotThreadSafe
public class LazyInitRace {
    private ExpensiveObject instance = null;

    public ExpensiveObject getInstance() {
        //检查条件，但是检查后条件可能发生变化
        if (instance == null)
            instance = new ExpensiveObject();
        return instance;
    }
}
class ExpensiveObject { }

5. 复合操作必须是原子的：为了线程安全性，先检查后执行和“读取-修改-写入”等操作必须是原子的，这些操作也称为复合操作，上面的问题可以如下修复：

//线程安全的类
//当无状态的类添加一个状态时，如果该状态完全由线程安全的对象来管理，那么这个类仍然是线程的
@ThreadSafe
public class CountingFactorizer extends GenericServlet implements Servlet {
    //使用AtomicLong来代替long类型的计数器
    //AtomicLong是线程安全的对象
    private final AtomicLong count = new AtomicLong(0);
    public long getCount() { return count.get(); }

    public void service(ServletRequest req, ServletResponse resp) {
        ...
        count.incrementAndGet();
        ...
    }
}

6. 线程安全性的要求中，多个线程之间的操作无论是采用何种执行时序或者交替方式，都要保证不变性条件不被破坏。下面的代码虽然使用了Atomic类，但仍然是线程不安全的，因为不满足该要求：

//一个提供因式分解计算的Servlet，并带有缓存上次计算结果的缓存功能
@NotThreadSafe
public class UnsafeCachingFactorizer extends GenericServlet implements Servlet {
    private final AtomicReference lastNumber
            = new AtomicReference();
    private final AtomicReference lastFactors
            = new AtomicReference();

    public void service(ServletRequest req, ServletResponse resp) {
        BigInteger i = extractFromRequest(req);
        //判断是否缓存计算过
        if (i.equals(lastNumber.get()))
            //此处get的结果可能是判断过后又修改过的
            encodeIntoResponse(resp, lastFactors.get());
        else {
            //计算
            BigInteger[] factors = factor(i);
            lastNumber.set(i);
            lastFactors.set(factors);
            encodeIntoResponse(resp, factors);
        }
    }
}

正确的写法：

@ThreadSafe
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);
    }
}

7. synchronized：Java提供了一种内置的锁的机制来支持原子性：同步代码块（用来修饰方法就是同步方法），每个Java对象都可以用做一个实现同步的锁，这些锁被称为内置锁或者监视器锁。内置锁是一种互斥锁，虽然通过它可以很简单的实现线程互斥性，但是会影响性能（活跃性问题或性能问题）
8. 可冲入的概念：synchronized是可重入的，如果某个线程视图获取一个已经由它自己持有的锁，那么这个请求会成功。重入意味着获取锁的操作的粒度是线程，而不是调用。如果不支持重入，下面的代码中对父类的调用将会产生死锁：

class Widget {
    public synchronized void doSomething() {
    }
}

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

9. 用锁来保护状态：对于可能被多个线程同时访问的可变状态变量，在访问它时都需要持有同一个锁，在这种情况下，我们称状态变量是由这个锁保护的（获取锁后只能避免其他线程获取同一个锁，不能阻止其他线程访问该对象）
10. 每个共享的和可变的变量应该只由一个锁来保护，从而使维护人员知道是哪一个锁。同时，对于每个包含多个变量的不可变性条件，其中涉及的所有变量都需要由同一个锁来保护

对象的共享

1. sychronized不仅仅能够实现原子性，它的另一个好处是实现可见性。即加锁的含义不仅仅局限于互斥行为，还包括内存可见性
2. 在没有同步的情况下，编译器、处理器以及运行时等都可能对操作的执行顺序进行一些意想不到的调整，要相对内存操作的顺序进行判断几乎不可能，这种调整也称为重排序
3. 失效值：在没有同步的情况下，读取的数据有可能是要给失效值，这会给程序运行带来安全性问题或者活跃问题
4. 最低安全性：读取的值可能是失效的，但最起码是之前设置过的值，这是最低有安全性，但是对于非volatile类型的long和double变量，JVM允许将64位的读操作或写操作分成两个32位的操作，这回导致在多线程中读到一个意料之外的值
5. 加锁与可见性：加锁（内置所）保证一个线程能够以可预测的方式查看另一个线程的执行结果：例如在M上调用unlock之前的所有操作结果对于在M上调用lock之后的线程都是可见的
6. volatile变量：volatile是一种稍弱的同步机制，确保变量的更新能够被其他线程所见，volatile会阻止JVM对该变量的操作和其他的内存操作一起重排序。需要注意的是，volatile只能保证可见性，而不能保证原子性，对于volatile执行++操作不是原子性的。因此当变量的写入依赖变量的当前值时，不能仅用volatile来同步
7. 发布和逸出：发布一个对象是指让对象能够在作用域之外的代码中是使用，如果在对象构造完之前就发布该对象，就会破坏线程安全性，当某个不该发布的对象被发布时，这种情况就被称为逸出。下面代码通过内部类将this引用在构造函数中逸出(内部类隐含外部类的引用)

public class ThisEscape {
    //不要在构造函数中使this引用逸出
    public ThisEscape(EventSource source) {
        source.registerListener(new EventListener() {
            public void onEvent(Event e) {
                doSomething(e);
            }
        });
    }
    void doSomething(Event e) {
    }
    interface EventSource {
        void registerListener(EventListener e);
    }
    interface EventListener {
        void onEvent(Event e);
    }
    interface Event {
    }
}

8. 线程封闭： 当访问共享的可变数据时，通常需要同步，一种避免使用同步的方式就是不共享数据，这种也称为线程封闭。栈封闭是线程封闭的一种特例，即只能通过局部变量才能访问对象
9. ThreadLocal类：维持线程封闭性的一种更规范的方法是使用ThreadLocal，这个类能使线程中的某个值与保存的值的对象关联起来，比如下面的代码使每个线程都会拥有属于自己的连接：

public class ConnectionDispenser {
    static String DB_URL = "jdbc:mysql://localhost/mydatabase";

    private ThreadLocal connectionHolder
            = new ThreadLocal() {
                public Connection initialValue() {
                    try {
                        return DriverManager.getConnection(DB_URL);
                    } catch (SQLException e) {
                        throw new RuntimeException("Unable to acquire Connection, e");
                    }
                };
            };

    public Connection getConnection() {
        return connectionHolder.get();
    }
}

10. 不变性：满足同步需求的另一种方法就是使用不可变对象，原子性和可见性相关的问题的来源都是试图访问一个可变的状态相关。如果对象的状态不会改变，那么这些问题的复杂性也就自然消失了。不可变对象一定是线程安全的。不可变对象定义:对象创建以后其状态就不能修改，对象所有的域都是final类型，对象是正确创建的（没有this引用逸出）。它们只有一种状态，并且该状态由构造函数来控制。关键字final用于构造不可变对象。在java的内存模型中，final域还有着特殊的含义，final域能确保初始化过程的安全性，从而可以不受限制的访问不可变对象，并在共享这些对象时无需同步
11. 对于访问和更新多个变量时出现的竞争条件问题，可以通过将这些变量全部保存在一个不可变对象中来消除
12. 对象发布的坑：有时我们需要发布某个对象(作为public字段并供别人使用)，这是要注意发布的正确性，下面是一个不正确发布的案例：

public class StuffIntoPublic {
    //不安全的发布，其他线程看到Holder是不一致的，甚至是尚未创建完成的
    public Holder holder;
    public void initialize() {
        holder = new Holder(42);
    }
}

同时如果Holder的实现是如下所示,调用该类的assertSanity，有可能抛出异常，原因在于类未完全初始化(重排序导致)，变量n还是默认值（一个失效值），如果n声明为final类型，那么Holder将不可变，从而避免出现不正确发布的问题

public class Holder {
    private int n;
    public Holder(int n) {
        this.n = n;
    }
    public void assertSanity() {
        if (n != n)
            throw new AssertionError("This statement is false.");
    }
}

解决上面的问题的一种方式，是使用静态初始化，它是JVM在类的初始化阶段执行，由于JVM存在这同步机制，因此这种方式初始化的任何对象都可以被安全的的发布：

public static Holder holder= new Holder(42);

13. 安全的发布对象的方式：在静态初始化函数中初始化一个对象引用；将对象的引用保存到volatile类型的域或者AtomicReference对象中；将对象的引用保存到某个正确构造对象的final域中；将对象保存到一个由锁保护的域中
14. 事实不可变对象：如果一个对象技术是可变的，但是一旦发布后不再改变，把这种称之为“事实不可变对象”。在没有额外同步的情况下，任何线程都可以安全的使用被安全发布的事实不可变对象
15. 对象的发布需求取决于它的可变性：不可变的对象可以通过任意机制来发布，事实不可变的对象必须通过安全的方式发布；可变对象必须通过安全方式来发布，并且必须是线程安全的或者由某个锁保护起来

对象的组合

1. 对象的状态一般又其域构成；同步策略定义了如何在不违背对象不变条件或者后验条件的情况下（比如下一个状态可预测）对其状态的访问操作进行协同
2. 构建线程安全类的最简单的方式：线程封闭：将数据封装在对象内部，并将数据的访问限制在对象的方法上
3. 监视器模式：线程封闭一般采用监视器模式，就是利用对象的monitor进行同步（synchronize修饰），案例代码（一个汽车跟踪类）如下：

@ThreadSafe
 public class MonitorVehicleTracker {
    //MutablePoint是普通的可变对象
    //这里Map的key表示汽车的名称
    @GuardedBy("this") private final Map locations;

    public MonitorVehicleTracker(Map locations) {
        this.locations = deepCopy(locations);
    }
    public synchronized Map getLocations() {
        return deepCopy(locations);
    }
    public synchronized MutablePoint getLocation(String id) {
        MutablePoint loc = locations.get(id);
        return loc == null ? null : new MutablePoint(loc);
    }
    public synchronized void setLocation(String id, int x, int y) {
        MutablePoint loc = locations.get(id);
        if (loc == null)
            throw new IllegalArgumentException("No such ID: " + id);
        loc.x = x;
        loc.y = y;
    }
    private static Map deepCopy(Map m) {
        Map result = new HashMap();

        for (String id : m.keySet())
            result.put(id, new MutablePoint(m.get(id)));

        return Collections.unmodifiableMap(result);
    }
}

4. 线程安全的委托：委托其他类实现线程安全：

@ThreadSafe
public class DelegatingVehicleTracker {
    //线程安全的Map
    private final ConcurrentMap locations;
    private final Map unmodifiableMap;
    public DelegatingVehicleTracker(Map points) {
        locations = new ConcurrentHashMap(points);
        unmodifiableMap = Collections.unmodifiableMap(locations);
    }
    //注意这里没有使用深拷贝，是因为Point是不可变类（final修饰变量），可以安全发布
    public Map getLocations() {
        return unmodifiableMap;
    }
    public Point getLocation(String id) {
        return locations.get(id);
    }
    public void setLocation(String id, int x, int y) {
        if (locations.replace(id, new Point(x, y)) == null)
            throw new IllegalArgumentException("invalid vehicle name: " + id);
    }
    // Alternate version of getLocations (Listing 4.8)
    public Map getLocationsAsStatic() {
        return Collections.unmodifiableMap(
                new HashMap(locations));
    }
}

5. 客户端加锁：使用某个对象的客户端代码，使用对象本身用于保护其状态的锁来保护客户端的代码，比如：

@ThreadSafe
class GoodListHelper  {
    public List list = Collections.synchronizedList(new ArrayList());
    //注意这里不能使用GoodListHelper的this引用加锁，因为list里面的同步操作的锁是list引用
   //这样导致客户端代码和对象使用的锁不一致，出现list操作线程不安全的问题
    public boolean putIfAbsent(E x) {
        synchronized (list) {
            boolean absent = !list.contains(x);
            if (absent)
                list.add(x);
            return absent;
        }
    }
}

基础构建模块

1. 同步容器包括Vector和HashTable，以及Collections.synchronizedXxx等工厂方法创建，它们实现是将状态封装起来，然后所有的共有方法都进行同步。这样会产生一个问题：效率不高，比如迭代的时候，需要
2. 同步容器的问题：单个操作时同步的，但是复合操作不是，比如putIfAbsent操作。由于复合操作存在异常，像Vector会采用fail-fast策略：即出现复合操作产生的并发问题（比如getLast和deleteLast在同一个对象上频繁调用或者迭代期间出现并发修改），直接抛出异常，这往往是不是我们需要的（get和delete一般不产生异常）。更加常见的比如，在调用size和get之间，vector的长度可能会发生变化，这种在迭代中也不可避免，这可能会抛出数组越界异常，当然我们可以通过客户端加锁的方式实现安全迭代，但是迭代期间，对于容器的其他方法的调用都是阻塞的
3. 隐藏的迭代器：同步容器的迭代式不安全的，有时候迭代式存在隐含的条件里面，让我们难以发现：比如打印容器变量（会调用toString），或者调用hashCode、equals、contailsAll、removeAll、retailAll方法的时候
4. 并发容器之ConcurrentHashMap：采用分段锁来提高并发性能、不会在迭代时对容器加锁（允许并发时修改，也允许size等方法返回估算值）、提供了常见的复合的原子操作比如putIfAbsent等方法
5. 并发容器之CopyOnWriteArrayList：用于代替同步List，CopyOnWriteArraySet代替同步Set，copy on write是指在修改的创建一个容器的副本，修改后替换以前的引用，从而在修改的时候不影响读，适合读多写少的情况，确定是内存开销大
6. 阻塞队列-生产者消费者模式：阻塞队列提供了put和take的阻塞方法以及带有时间的offer和poll方法。队列可以是有界的也可以是无界的，无界队列的put方法不会阻塞。BlockingQueue简化了生产者-消费者的实现过程，支持任意数量的生产者和消费者。如果阻塞队列不完全复合生产者和消费者设计的需求，可以使用信号量来创建自己的数据结构
7. BlockingQueue有多种实现：LinkedBlockingQueue和ArrayBlockingQueue是FIFO队列，PriorityBlockingQueue是一个优先级队列，SynchronousQueue是一个只存一个元素的队列。
8. 一个案例：生产者搜索问题并放入队列，消费者取出文件名称并建立索引：

public class ProducerConsumer {
    static class FileCrawler implements Runnable {
        private final BlockingQueue fileQueue;
        private final FileFilter fileFilter;
        private final File root;

        public FileCrawler(BlockingQueue fileQueue,
                           final FileFilter fileFilter,
                           File root) {
            this.fileQueue = fileQueue;
            this.root = root;
            this.fileFilter = new FileFilter() {
                public boolean accept(File f) {
                    return f.isDirectory() || fileFilter.accept(f);
                }
            };
        }

        private boolean alreadyIndexed(File f) {
            return false;
        }

        public void run() {
            try {
                crawl(root);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }

        private void crawl(File root) throws InterruptedException {
            File[] entries = root.listFiles(fileFilter);
            if (entries != null) {
                for (File entry : entries)
                    if (entry.isDirectory())
                        crawl(entry);
                    else if (!alreadyIndexed(entry))
                        fileQueue.put(entry);
            }
        }
    }
    static class Indexer implements Runnable {
        private final BlockingQueue queue;

        public Indexer(BlockingQueue queue) {
            this.queue = queue;
        }
        public void run() {
            try {
                while (true)
                    indexFile(queue.take());
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }

        public void indexFile(File file) {
            // Index the file...
        };
    }
    private static final int BOUND = 10;
    private static final int N_CONSUMERS = Runtime.getRuntime().availableProcessors();
    
    //主程序
    public static void startIndexing(File[] roots) {
        BlockingQueue queue = new LinkedBlockingQueue(BOUND);
        FileFilter filter = new FileFilter() {
            public boolean accept(File file) {
                return true;
            }
        };
        for (File root : roots)
            new Thread(new FileCrawler(queue, filter, root)).start();

        for (int i = 0; i < N_CONSUMERS; i++)
            new Thread(new Indexer(queue)).start();
    }
}

8. 双端队列与工作窃取：Java6新增了两种容器类型Deque和BlockingDeque(前者子接口)，他们分别对Queue和BlockingQueue进行了扩展。Deque是一个双端队列。具体实现有ArrayDeque和LinkedBlockingDeque。双端队列适用于工作窃取模式。
9. InterruptedException处理：阻塞的方法会抛出InterruptedException，表示中断，中断是一种协作机制，并不是强制的去中止线程。对于该异常的处理有两个基本的方式：传递InterruptedException（包括直接抛出或者捕获并处理返回）；恢复中断，使上层的代码知道中断了。切记不要吞异常不做处理，下面是恢复中断的一个案例：

public class TaskRunnable implements Runnable {
    BlockingQueue queue;
    @Override
    public void run() {
        try {
            processTask(queue.take());
        } catch (InterruptedException e) {
            // restore interrupted status
            Thread.currentThread().interrupt();
        }
    }
    void processTask(Task task) {
        // Handle the task
    }
    interface Task {
    }
}

10. 同步工具类之闭锁：
    闭锁的含义：延迟线程的进度直到某个中止状态
    可能用来：某个计算需要所有的资源都被初始化之后再执行；确保某个服务在其依赖的所有其他服务都已经启动之后再启动；等待某个操作的所有参与者都就绪再执行。
    闭锁之CountDownLatch，下面是使用CountDownLatch的代码案例：

public class TestHarness {
    public long timeTasks(int nThreads, final Runnable task)
            throws InterruptedException {
        final CountDownLatch startGate = new CountDownLatch(1);
        final CountDownLatch endGate = new CountDownLatch(nThreads);

        for (int i = 0; i < nThreads; i++) {
            Thread t = new Thread() {
                @Override
                public void run() {
                    try {
                        startGate.await();
                        try {
                            task.run();
                        } finally {
                            endGate.countDown();
                        }
                    } catch (InterruptedException ignored) {
                    }
                }
            };
            t.start();
        }
        long start = System.nanoTime();
        //上面所有的线程都再等待下面的countDown
        startGate.countDown();
        //等待上面的线程都执行完后倒数
        endGate.await();
        long end = System.nanoTime();
        return end - start;
    }
}

11. 同步工具类之FutureTask:FutureTask也可以当成闭锁，下面是使用案例：

public class Preloader {
    ProductInfo loadProductInfo() throws DataLoadException {
        return null;
    }

    private final FutureTask future =
            new FutureTask<>(() -> loadProductInfo());
    private final Thread thread = new Thread(future);

    public void start() { thread.start(); }

    public ProductInfo get()
            throws DataLoadException, InterruptedException {
        try {
            return future.get();
        } catch (ExecutionException e) {
            Throwable cause = e.getCause();
            if (cause instanceof DataLoadException) {
                throw (DataLoadException) cause;
            } else {
                throw LaunderThrowable.launderThrowable(cause);
            }
        }
    }
    interface ProductInfo {
    }
}

12. 同步工具类之信号量：可以用来自定义自己的同步机制：acquire获取许可，release释放许可，如果信号量是1，可以用作mutex，信号量也可以用作线程池，下面是信号量的一个使用案例：

public class BoundedHashSet  {
    private final Set set;
    private final Semaphore sem;

    public BoundedHashSet(int bound) {
        this.set = Collections.synchronizedSet(new HashSet());
        sem = new Semaphore(bound);
    }
    public boolean add(T o) throws InterruptedException {
        sem.acquire();
        boolean wasAdded = false;
        try {
            wasAdded = set.add(o);
            return wasAdded;
        } finally {
            if (!wasAdded) {
                sem.release();
            }
        }
    }
    public boolean remove(Object o) {
        boolean wasRemoved = set.remove(o);
        if (wasRemoved) {
            sem.release();
        }
        return wasRemoved;
    }
}

13. 同步工具类之栅栏：
    栅栏与闭锁的区别：闭锁用于等待事件，栅栏用于等待其他线程，栅栏常用在分解和合并任务上，下面是一个案例：

public class CellularAutomata {
    private final Board mainBoard;
    private final CyclicBarrier barrier;
    private final Worker[] workers;

    public CellularAutomata(Board board) {
        this.mainBoard = board;
        int count = Runtime.getRuntime().availableProcessors();
        this.barrier = new CyclicBarrier(count,
                () -> mainBoard.commitNewValues());
        this.workers = new Worker[count];
        for (int i = 0; i < count; i++) {
            //分解成子问题
            workers[i] = new Worker(mainBoard.getSubBoard(count, i));
        }
    }
    //工作线程
    private class Worker implements Runnable {
        private final Board board;

        public Worker(Board board) { this.board = board; }
        @Override
        public void run() {
            while (!board.hasConverged()) {
                for (int x = 0; x < board.getMaxX(); x++) {
                    for (int y = 0; y < board.getMaxY(); y++) {
                        board.setNewValue(x, y, computeValue(x, y));
                    }
                }
                try {
                    //等待所有的线程都工作完后再往下执行
                    barrier.await();
                } catch (InterruptedException | BrokenBarrierException ex) {
                    return;
                }
            }
        }

        private int computeValue(int x, int y) {
            // Compute the new value that goes in (x,y)
            return 0;
        }
    }
    //主方法
    public void start() {
        //分解工作
        for (Worker worker : workers) {
            new Thread(worker).start();
        }
        //合并工作
        mainBoard.waitForConvergence();
    }

    interface Board {
        int getMaxX();
        int getMaxY();
        int getValue(int x, int y);
        int setNewValue(int x, int y, int value);
        void commitNewValues();
        boolean hasConverged();
        void waitForConvergence();
        Board getSubBoard(int numPartitions, int index);
    }
}

另一种形式的栅栏是Exchanger，各方在栅栏上交换数据，一个使用案例：

public class ExchangerDemo {

    public static void main(String[] args) {
        Exchanger