【JUC并发】单词计数实验：ConcurrentHashMap，computeIfAbsent，merge，LongAdder

ConcurrentHashMap 介绍

• computeIfAbsent(key,Function)：
  • 如果存在则返回key的值
  • 如果不存在，则Function返回值作为key的值
• merge(key，value，BiFunction)：
  • 不存在指定的key时，将value设置为key的值。
  • 当key存在值时，执行BiFunction接收oldKey和value，返回结果设置为key的值。

实验介绍

• 将26个英文字母分别循环200次，每个字母作为一个单词，一共有5200个单词。
• 每个单词中间用"\n"分隔，乱序存入26个文件中
• 生成26个线程对26个文件中的单词进行计数，存入map中

环境搭建

生成文件

//定义生成测试文件的方法
    @Test
    public void produceData() throws IOException {
        //定义26个字母的字符串
        String data="abcdefghijklmnopqrstuvwxyz";
        List<String> list=new ArrayList<>();
        //循环遍历26个字母，每个字母循环200次，最后将5200个字母放入集合
        for (int i = 0; i < data.length(); i++) {
            for (int j = 0; j < 200; j++) {
                list.add(String.valueOf(data.charAt(i)));
            }
        }
        //将集合打乱
        Collections.shuffle(list);
        //遍历26次。每次取出集合中的200个元素加上“换行符”放入文件中
        for (int i = 0; i < 26; i++) {
            try(FileWriter fw=new FileWriter((i+1)+".txt")){
                fw.write(list.subList(i*200,(i+1)*200).stream().collect(Collectors.joining("\n")));
            }
        }
    }

读取文件

//定义读文件的方法
    private static void read(List list,int i){
        //创建输入缓冲字符流
        try(BufferedReader bf=new BufferedReader(new FileReader((i+1)+".txt")) ){
            String data;
            //读取每行数据，判断是否为空
            while((data=bf.readLine())!=null){
                //将字母加入到集合中
                list.add(data);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

生成线程：操作每个文件对应的list，存放到线程共享的map

/**
     * 定义26个线程读26个文件并将结果放入map。map由函数式接口作为参数提供，放入map由Consumer函数式接口处理。
     * @param supplier 提供者：提供map集合存放单词计数
     * @param consumer 消费者：对list（第二个参数）进行计数并存入map（第一个参数）中
     */
    private static <T>void deal(Supplier<Map<String,T>> supplier, BiConsumer<Map<String,T>,List<String>> consumer){
        //获得map集合，用于存放单词计数
        Map<String,T> map=supplier.get();
        CountDownLatch count=new CountDownLatch(26);
        //循环创建26个线程，读取26个文件的内容，并进行计数操作
        for (int i = 0; i < 26; i++) {
            int j=i;
            new Thread(()->{
                List<String> list=new ArrayList();
                read(list,j);
                consumer.accept(map,list);
                count.countDown();
            }).start();
        }
        try {
            count.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Collection<T> values = map.values();
        System.out.println(values.toString());
    }

测试

代码

public static void main(String[] args) {
        //实现1
            deal(()-> new ConcurrentHashMap<String, LongAdder>(),(map, list)->{
            //遍历集合内容
            list.forEach(str->{
                //单词数累加：map中没有str的key则new LongAdder，有则进行加1
                map.computeIfAbsent(str,(key)-> new LongAdder()).increment();
            });

        });
        //实现2
        deal(()-> new ConcurrentHashMap<String, Integer>(),(map, list)->{
            //遍历集合内容
            list.forEach(str->{
                //单词数累加：map中没有str的key则set(str,1)，有则set(str,Integer.sum(oldvalue,1))
                map.merge(str,1,Integer::sum);
            });

        });
    }

输出

[200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200]