《Java并发编程实战》-4

《Java并发编程实战》-4

---

5.1 同步容器类

Collections.synchronizedXxx等工厂方法创建的同步实现线程安全的方式是：将它们的状态封装起来，并对每个公有方法都进行同步，使得每次只有一个线程能访问容器的状态。

5.5.1 同步容器的问题

在使用客户端加锁的Vector上的复合操作

public static Object getList(Vector list) {
    synchronized (list) {
        int lastIndex = list.size() - 1;
        return list.get(lastIndex);
    }
}

public static void deleteLast(Vector list) {
    synchronized (this) {
        int lastIndex = list.size() - 1;
        list.remove(lastIndex);
    }
}

5.1.2 迭代器与ConcurrentModificationException

当容器类发现容器在迭代过程中被修改时，就会抛出一个”ConcurrentModificationException
“，这就是“快速失败”。

5.1.3 隐藏迭代器

正如封装对象的状态有助于维持不变性条件，封装对象的同步机制同样有助确保实施同步策略。

5.2 并发容器

通过并发容器来代替同步容器，可以极大地提高伸缩性并降低风险。

并发容器	同步容器	普通容器
BlockingQueue	ConcurrentLinkedQueue	PriorityQueue
ConcurrentHashMap, SkipListMap	hashtable, Collections.synchroniedList(TreeSet set)	hashmap,SortedMap, SortedSet
CopyOnWriteArrayList	Vector, Collections.synchroniedList(List list)	ArrayList, LinkedList
CopyOnWriteArraySet, ConcurrentSkipListListSet	Collections.synchroniedSet(Set set)	LinkedHashSet, HashSet, TreeSet

5.2.1 ConcurrentHashMap

ConcurrentHashMap使用更细粒度的加锁机制—分段锁来实现更大程度的共享。

ConcurrentHashMap具有弱一致性(Weakly Consistent)，而非”及时失败”。

只有当应用程序需要加锁Map以进行独占访问时，才应该放弃使用ConcurrentHashMap。

5.2.2 额外的原子Map操作

public interface ConcurrentMap<K,V> extends Map<K,V> {
    // 仅当K没有相应的映射值时才插入
    V putIfAbsent(K key, V value);

    // 仅当K被映射到oldValue时才替换为newValue
    boolean remove(K key, V value);

    // 仅当K被映射到oldValue时才替换为newValue
    boolean replace(K key, V oldValue, V newValue);

    // 仅当K被映射到某个值时才替换为newValue
    boolean replace(K key, V newValue);
}

5.2.3 CopyOnWriteArrayList

CopyOnWriteArrayLsit用于替代同步List，某些情况下它提供了更好的并发行性能，并且在迭代期间不需要对容器进行加锁或复制（类似地，CopyOnWriteArraySet的作用是替代同步Set）。

每当修改容器时都会复制底层数组，这需要一定的开销。

仅当迭代操作远远多于修改操作时，才应该使用”写入时负责”容器。

5.3 阻塞队列和生产者-消费者模式

在构建高可靠的应用程序时，有界队列是一种强大的资源管理工具:它们能抑制并防止产生过多的工作项，使应用程序在负荷过载的情况下变得更加健壮。

BlockingQueue的方法:

• put 如果队列满则阻塞
• take 如果队列为空则阻塞
• offer 如果队列满则返回一个失败状态，一般是false
• poll 如果队列空则返回一个表示空的数据,一般是null

BlockingQueue的多种实现:

• LinkedBlockingQueue 基于链表，FIFO
• ArrayBlockingQueue 基于数组, FIFO
• PriorityBlockingQueue 按优先级排序的队列
• SynchronousQueue 它不会为队列中元素维护储存空间，它维护一组线程，这些线程在等待着吧元素加入或者移出队列。

5.3.1 示例:桌面搜索

5.3.2 串行线程封闭

对象池利用了串行线程封闭，将一个对象“借给”一个请求线程。

还可以通过ConcurrentMap的原子方法remove或者AtomicReference的原子方法compareAndSet来转笔可变对象的所有的所有权（但必须确保只有一个线程能接受被转移的对象）。

双端队列与工作密取

Deque是一个双端队列，实现了在队头和队尾的高效插入和移除。具体实现包括ArrayList和LinkedBlockingDeque。

双端队列适用于工作密取模式。

5.4 阻塞方法与中断方法

• 传递
• 恢复中断

public class TackRunnable implements Runnable {
    try {
            processTack(queue.take());
        } catch (InterruptedException e) {
            // 恢复被中断的状态
            Thread.currentThread().interrupt();
        }
}

5.5 同步工具类

5.5.1 闭锁

CoutDwonLatch，倒计时门闩,又名闭锁、倒计时计数器，是一种同步工具类，可以延迟线程大的进度直到其到达终止状态。

闭锁可以用来确保某些活动直到其他活动都完成后才能继续执行。

• 确保某个计算在其需要得所有资源都被初始化之后才继续执行。二元闭锁（包括两个状态）可以用来表示“资源R已经被初始化”，而所有需要R的操作都必须现在这个闭锁上等待。
• 确保某个服务在其依赖的所有其他服务都已经启动之后才启动。每个服务都有一个相关的二元闭锁。当启动服务S时，将首先在S依赖的其他服务的闭锁上等待，在所有依赖的服务启动后会释放锁S，这样其他依赖S的服务才能继续执行。
• 等待直到某个操作的所有参与者（例如，在多个玩家游戏中的所有玩家）都就绪再继续执行。这种情况中，当所有玩家都准备就绪时，闭锁将到达结束状态。

5.5.2 FutureTask

FutureTask表示的计算是通过Callable来实现的，相当于一种可生成结果的Runnable，并且可以处于一下三种状态：

• 等待运行(Wating to run)
• 正在运行(Running)
• 运行完成(Completed)

信号量

计数信号量用来控制同时访问某个某个特殊资源的操作数量，或者同时执行某个指定操作的数量。计算信号量还可以用来实现某种资源池，或者对容器施加边界。

5.5.4 栅栏

栅栏类似于闭锁，他能阻塞一组线程直到某个事件发生。栅栏与闭锁的关键区别在于，所有线程必须同时到达栅栏位置，才能继续执行。闭锁用于等待事件，而栅栏用于等待其他线程线程。

CyclicBarrier可以使一定数量的参与反复地在栅栏位置汇集，他在并行迭代算法中非常有用：这种算法通常将一个问题拆分成一系列相互独立的子问题。

另一种形式的栅栏使Exchange，他是一种两方栅栏，各方在栅栏位置上交换数据。当两分法执行不对称的操作时，Exchanger会非常有用，例如当一个线程向缓冲区写入数据，而另一个线程从缓冲区读取数据。

5.6 构建高效且可伸缩的结果缓存

使用ConcurrentHashMap和FutureTask来构架缓存

public interface Computable<A, V> {
    V compute(A arg) throws InterruptedExcetion;
}

public class Menoizer<A, V> implements Computable<A, V> {
    private final ConcurrentMap<A, Future<V>> cache = new ConcurrentHashMap<>();
    private final Computable<A, V> c;

    public Menoizer(Computable<A, V> c) { this.c = c; }
    while (true) {
        Future<V> f = cache.get(arg);
        if (f == null) {
            Callable<V> eval = new Callable<V>() {
                public V call() throws InterruptedException {
                    return c.compute(args);
                }
            };
            FutureTask<V> ft = new FutureTask<V>(eval);
            // 复合操作（“若没有则添加”）
            f = cache.putIfAbsent(arg, ft);
            if(f == null) {
                f = ft;
                ft.run();
            }
        }
        try{
            // 若正在计算，则阻塞等待结果
            return f.get();
        } catch (CancellationException e) {
            // 出现异常则去除缓存，防止缓存污染
            cache.renove(arg,f);
        } catch (ExecutionException e) {
            throw launderThrowable(w.getCause())
        }
    }
}

第一部分小结

• 可变状态是至关重要的。
  所有的并发问题都可以归结为如何协调对并发状态的访问，可变状态越少，就越容易确保线程安全。
• 尽量将域声明为final类型，除非需要它们是可变的。
• 不可变对象一定是线程安全的。
  不可变对象能极大地降低并发编程的复杂性。它们更为简单而且安全，可以任意共享而无须使用加锁或保护性复制等机制。
• 封装有助于管理复杂性
  在编写线程安全的程序时，虽然可以将所有数据都保存在全局变量中，但为什么要这么做？将数据封装在对象中，更易于维持不变性条件：将同步机制封装在对象中，更易于遵循同步策略。
• 用锁来保护每个可变变量。
• 当保护同一个不变性条件中的所有变量时，要使用用一个锁。
• 在执行复合操作期间，要持有锁。
• 如果从多个线程中访问同一个可变变量没有同步机制，那么程序会出现问题。
• 不要故作聪明地推断出不需要使用同步。
• 在设计过程中考虑线程安全，或者在文档中明确地指出它不是线程安全的。
• 将同步策略文档化。