Java核心技术——并发2

并发2

线程安全的集合

阻塞队列

1. 创建阻塞队列

   ArrayBlockingQueue(int capacity)\ArrayBlockingQueue(int capacity, boolean fair)

   构造一个指定的容量和公平性的阻塞队列。队列实现为一个循环数组

   LinkedBlockingQueue()\LinkedBlockingDeque()

   构造一个无上限的阻塞队列或双向队列，实现为一个链表

   LinkedBlockingQueue(int capacity)\LinkedBlockingDeque(int capacity)

   DelayQueue()

   构造一个包含Delayed元素的无上限阻塞队列。只有到期元素可以从队列中移除

   PriorityBlockingQueue()\PriorityBlockingQueue(int initialCapacity)\PriorityBlockingQueue(int initialCapacity, Comparator<? super E> comparator)

2. 阻塞队列的方法

   方法	正常动作	特殊情况下的动作
   add	添加一个元素	队满，则抛出异常
   remove	移除并返回队头元素	队空，则抛出异常
   put	添加一个元素	队满则阻塞
   take	移除并返回队头元素	队空则阻塞
   offer	添加一个元素并返回true	队满则阻塞，并返回false
   poll	移除并返回队头元素	队空则阻塞，并返回null
   element	返回队头元素	队空，则抛出异常
   peek	返回队头元素	队空，返回null

高效的映射、集和队列

这些集合不能使用size方法

1. 构造方法

   ConcurrentLinkedQueue()

   构造一个可被多线程安全访问的无上限非阻塞队列

   ConcurrentSkipListSet()\ConcurrentSkipListSet(Comparator<? super E> comparator)

   构造一个有序集，第一个的E类要实现comparable接口

   ConcurrentHashMap<K, V>()\ConcurrentHashMap<K, V>(int initialCapacity)\ConcurrentHashMap<K, V>(int initialCapacity, float loadFactor, int concurrencyLevel)

   ConcurrentHashMap<K, V>()、ConcurrentHashMap<K, V>(Comparator<? super E> comparator)

2. 映射条目的原子更新

   default V compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction )

   将函数应用到key 和get(key)。将key与结果关联，或者如果结果为null，则删除这个键。返回get(key)。

   default V merge(K key, V value, BiFunction<? super K, ? super V, ? extends V> remappingFunction )

   如果key与一个非null值v关联，将函数应用到v和value，将key与结果关联，或者结果为null则删除这个键，否则，将key与value关联，返回get(Key)

3. 对并发散列映射的批操作

   对映射快照进行遍历，即使有其他线程在处理映射，这些操作也能安全的执行

   • search(搜索)：为每个键或者值应用一个函数，直到函数生成一个非null的结果。然后搜索终止，并返回这个函数的结果，如果没找到则输出null

     U searchKeys(long threshold, BiFunction<? super K, ? extends U> f)

     U searchValues(long threshold, BiFunction<? super V, ? extends U> f)

     U search(long threshold, BiFunction<? super K, ? super V, ? extends U> f)

     U searchEntries(long threshold, BiFunction<Map.Entry<K, V>, ? extends U> f)

     threshold参数化阈值，如果映射元素多于这个阈值，就会并发完成批操作

   • forEach为所有键或值应用一个函数

     map.forEach(threshold, BiFunction<? super K, ? super V, ? extends U> f)

     只对各个映射条目应用一个消费者函数

     map.forEach(threshold, BiFunction<? super K, ? super V, ? extends U> f， BiFunction<? super K, ? super V, ? extends U> f )

     各个映射条目先经过转换器转换，再传递到消费者函数，输出结果，只要转换器返回null这个值就会被悄无声息的略过

   • reduce(归约) 组合所有键或值，这里要使用所提供的一个累加函数

     操作与forEach类似

4. 并发集视图

   Set<? super K> <? super K>newKeySet()

   Set<? super K> <? super K>keySet()

   这个集是可更改的，删除一个键，散列表中的键值也会被删除，不过加键没有意义。

   Set<? super K> <? super K>keySet(initial)

   这个加键是有意义的，默认值为initial

任务和线程池

Callable与Future

1. Callable接口

   public interface Callable<V> {
   	V call() throws Exception
   }
   

2. Future接口保存异步计算的结果

   public interface Future<V> {
   	V get();//调用后会阻塞，知道计算完成
   	V get(long timeout, TimeUnit unit);//也会阻塞，超时或中断抛出异常
   	void cancel(boolean mayInterrupt);//取消计算，未开始则取消，开始了mayInterrupt为true则中断
   	boolean isCancelled();
   	boolean isDone();
   }
   

执行器（Exectors）

1. 静态工厂方法

   ExecutorService newCachedThreadPool()

   返回一个缓存线程池，会在必要时创建线程，如果线程已经空闲60s则终止该线程

   ExecutorService newFixedThreadPool(int Threads)

   返回一个给定线程数的线程池

   ExecutorService newSingleExecutor()

   返回一个执行器

2. 提交任务

   Future submit(Callable task)

   Future submit(Runnable task)

   Future submit(Runnable task, T result)

3. 关闭线程池

   void shutdown()

控制任务组（ExecutorService）

T invokeAny(Collection<Callable> tasks)

T invokeAny(Collection<Callable> tasks, long timeout, TimeUnit unit)

执行给定任务，返回一个任务结果，然后终止

List<Future> invokeAll(Collection<Callable> tasks)

List<Future> invokeAll(Collection<Callable> tasks, long timeout, TimeUnit unit)

返回执行的所有结果

ExecutorCompletionService（Executor e)

构造一个执行器完成服务来收集给定执行器的结果

Future submit(Callable task)

Future submit(Runnable task, T result)

提交一个任务给底层的执行器

Future take()

移除下一个已完成的结果，如果没有可用的已完成结果则阻塞

Future poll()

移除下一个已完成的结果，如果没有可用的已完成结果则返回null

fork-join框架

if(problemSize < threshold) 
    solve problem directly
else {
    break problem into subproblems
    recursively solve each subproblem
    continue the result
}

异步计算

可完成Future

CompletableFuture类实现了Future接口，提供了获得结果的另一种机制，注册一个回调，一旦结果可用，就会利用该结果这个回调

CompletableFuture supplyAsync(Supplier, ? extends Executors)

用于生成CompletableFuture对象

whenComplete(BiFunction<? super K, ? super V, ? extends U> f)

组合可完成Future

进程

1. 建立一个进程

   ProcessBuilder(String… command)/ProcessBuilder(List command)

   用给定命令和参数构造一个进程构造器，第一个字符串必须是可执行的命令

   ProcessBuilder directory(File directory)

   设置进程的工作目录

   ProcessBuilder inheritIO()

   让进程使用虚拟机的标准输入、输出、错误流

   Map<String, String> environment()

   生成一个可更改的映射，用于为进程设置环境变量

   Process start()

   启动进程，并生成它的Process对象

   static List startPipline(List builders)

   启动一个进程管线，将各个进程的标准输出连接到下一个进程的标准输入