Java核心技术 卷1 多线程----线程安全的集合（4）

　　如果多线程要并发的修改一个数据结构，例如散列表，那么很容易会破坏这个数据结构。一个线程可能要开始向表中插入一个新元素。假定在调整散列表各个桶之间的链接关系的过程中，被剥夺了控制权。如果另一个线程也开始遍历同一个链表，可能使用无效的链接并造成混乱，会抛出异常或者陷入死循环。

　　可以通过提供锁来保护共享数据结构，但是选择线程安全的实现作为替代可能更容易些。上一篇讨论的阻塞队列就是线程安全的集合。接下来讨论java类库提供的另外一些线程安全的集合。

　　高效的映射表、集合和队列

　　java.util.concurrent包提供了映射表、有序集合和队列的高效实现：ConcurrentHashMap、ConcurrentSkipListMap、ConcurrentSkipListSet和ConcurrentLinkedQueue。

java.util.concurrent.ConcurrentLinkedQueue<E>

• ConcurrentLinkedQueue<E>() 构造一个可以被多线程安全访问的无边界非阻塞的队列。
• ConcurrentSkipListSet<E>(Comparateor<? super E> comp)    构造一个可以被多线程安全访问的有序集

java.util.concurrent.ConcurrentSkipListMap<K,V>

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

　　参数：initialCapacity 集合的初始容量。默认值16

　　　　   loadFactor      控制调整：如果每一个桶的平均负载超过这个因子，表的大小会被重新调整。默认值为0.75.

　　　　　concurrencyLevel 并发写者结束 的估计数目。

• ConcurrentSkipListMap<K,V>
• ConcurrentSkipListSet<K,V>（Comparator<? super k） comp）

　　构造一个可以被多线程安全访问的有序的映象表。第一个构造器要求键实现Comparable接口。

• V putIfAbsent(K key,V value)

　　如果该键没有在映像表中出现，则将给定的值同给定的键关联起来，并返回null。否则返回与该键关键的现有值。

• boolean remove(K key,V value)

　　如果给定的键与给定的值关联，删除给定的键与值并返回真。否则，返回false.

• boolean replace(K key,V oldValue,V newValue)

　　如果给定的键当前与oldvalue相关联，用它与newValue关联。否则返回false

写数组的拷贝

　　CopyOnWriteArrayList和CopyOnWriteArraySet是线程安全的集合。其中所有的修改线程对底层数组进行复制。如果在集合上进行迭代的线程数超过修改线程数，这样的安排是很有用的。当构建一个迭代器的时候，它包含一个对当前数组的引用。如果数组后来被修改了，迭代器仍然引用旧数组，但是，集合的数组已经被替换了。因为旧的迭代器拥有一致的视图，访问无须任何同步开销。

Callable与Future

Runnable封装了一个异步的任务，可以把它想像成为一个没有参数和返回值的异步方法。Callable与Runnable类似，但是有返回值。Callable接口是一个参数化的类型，只有一个方法call。

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

　　类型参数是返回值的类型。例如：Callable<Integer>表示一个最终返回Integer对象的异步计算。

　　Future保存异步计算的结果。可以启动一个计算，将Future对象交给某个线程，然后忘掉它。Future对象的所有者在结果计算 好之后就可以获得它。

　　Future接口具有下面的方法：

public interface Future<V>
{
      V get() throws ...;
      V get(long timeout,TimeUnit unit) throws ...;
      void cancel(boolean mayInterrupt);
      boolean isCancelled();
      boolean isDone();    
}    

　　第一个get方法的调用被阻塞，直到计算完成。如果在计算完成之前，第二个方法的调用超时，抛出一个TimeoutException异常。如果运行该计算的线程被中断，两个方法都将抛出InterruptedException。 如果计算完成，那么get方法立即返回。

　　如果计算还在进行，isDone方法返回false;如果完成了，则么回true.

　　可以用cancel方法取消该计算。如果计算还没有开始，它被取消且不再开始。如果计算处于运行中，那么如果mayInterrupt参数为true，它就被中断。

　　FutureTask包装器是一种非常便利的机制，可以将Callable转换成Future转换成Future和Runnable，它同时实现二者的接口。

　　以下这个例子与上一篇寻找包含指定关键字的文件的例子相似。然而，现在我们仅仅计算匹配的文件数目。因此，我们有了一个需要长时间运行的任务，它产生一个数例，一个Callable<Integer>的例子。

class MatchCouner implements Callable<Integer>
{
       public MatchCounter(Fille directory,String keyWord){...}
       public Integer call(){...} //返回匹配文件的数
}    

　　然后我们利用MatchCounter创建一个FutureTask对象，并用来启动一个线程。

FutureTask<Integer> task =new FutureTask<Integer>(counter);
Thread t=new Thread(task);
t.start();

　　最后，打印结果： 

System.out.println(task.get()+" mathcing files.");

　　当然对get的调用会发生阻塞，直到有可获得的结果为止。

　　在call方法内部，使用相同的递归机制。对于每一个子目录，产生一个新的MatchCounter并为它启动一个线程。把FutureTask对象隐藏在ArrayList<Future<Integer>>中。最后所有结果加起来：

for(Future<Integer> result:results)
    count+=result.get()

　　每一次对get的调用都会发生阻塞直到结果可获得为止。当然线程是并行运行的，因此，很可能在大致相同的时候所有的结果都可获得。完整代码如下：

package test.Future;

import java.io.File;
import java.util.Scanner;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * Created by Administrator on 2017/11/23.
 */
public class FutureTest {
    public static void main(String[] args) {
        Scanner in =new Scanner(System.in);
        System.out.print("输入查询路径：");
        String directory=in.nextLine();
        System.out.print("输入关键字：");
        String keyword=in.nextLine();

        MatchCounter counter=new MatchCounter(new File(directory),keyword);
        FutureTask<Integer> task=new FutureTask<>(counter);
        Thread t=new Thread(task);
        t.start();
        try {
            System.out.println(task.get()+" 匹配文件");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }
}

package test.Future;

import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

/**
 * 此任务对包含给定关键字的目录和子目录中的文件进行计数
 */
public class MatchCounter implements Callable<Integer> {
    private File directory;
    private String keyword;
    private int count;

    /**
     * @param directory 开始搜索目录
     * @param keyword   寻找关键字
     */
    public MatchCounter(File directory, String keyword) {
        this.directory = directory;
        this.keyword = keyword;
    }

    @Override
    public Integer call() throws Exception {
        count = 0;
        try {
            File[] files = directory.listFiles();
            if (files == null) {
                return count;
            }
            List<Future<Integer>> results = new ArrayList<>();
            for (File file : files
                    ) {
                if (file.isDirectory()) {
                    MatchCounter counter = new MatchCounter(file, keyword);
                    FutureTask<Integer> task = new FutureTask<>(counter);
                    results.add(task);
                    Thread t = new Thread(task);
                    t.start();
                } else {
                    if (search(file)) {
                        count++;
                    }
                }
                for (Future<Integer> result : results) {
                    try {
                        count += result.get();
                    } catch (ExecutionException e) {
                        e.printStackTrace();
                    }
                }
            }
        } catch (InterruptedException e) {
        }
        return count;
    }

    /**
     * 搜索一个给定关键字的文件
     *
     * @param file
     * @return
     */
    public boolean search(File file) {
        try{
            try(Scanner in= new Scanner(file,"gbk")){
                boolean found=false;
                while (!found&&in.hasNextLine()){
                    String line=in.nextLine();
                    if (line.contains(keyword)){
                        found=true;
                        System.out.println(file.toString());
                    }
                }
                return found;
            }
        }
        catch (IOException e){
            return false;
        }
    }
}

java.util.concurrent.Callable<V>

•  V call() 运行将产生结果的任务
•  V get()
•  V get(long time,TimeUnit unit)

　　获取结果，如果没有结果可用，则阻塞直到得到结果超过指定的时间为止。如果不成功，第二个方法会抛出TimeoutException异常。

• boolean cancel(boolean mayInterrupt)

　　尝试取消这一任务的运行。如果任务已经开始，并且mayInterrupt参数值为true，它就会被中断如果成功执行取消操作，返回true。

• boolean isCancelled() 如果任务在完成前被取消了，则返回true。
• boolean isDone() 如果任务结束，无论是正常结束、中途取消或发生异常，都返回true。

java.util.concurrent.FutureTask<V>

• FutureTask(Callable<V> task)
• FutureTask(Runnable task,V result) 构造一个既是Future<V>又是Runnable的对象。