Java 多线程读取文件并统计词频 实例 出神入化的《ThreadPoolExecutor》

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Java 多线程读取文件并统计词频 实例 出神入化的《ThreadPoolExecutor》，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含11170字，纯文字阅读大概需要16分钟。

内容图文

重在展示多线程ThreadPoolExecutor的使用，和线程同步器CountDownLatch，以及相关CAS的原子操作和线程安全的Map/队列。

ThreadPool主线程

 1 import java.io.BufferedWriter;
 2 import java.io.File;
 3 import java.io.FileWriter;
 4 import java.util.*;
 5 import java.util.concurrent.*;
 6 import java.util.concurrent.atomic.AtomicInteger;
 7 import java.util.concurrent.atomic.AtomicReferenceArray;
 8 
 9 /**
10  * ClassName: ThreadPool
11  * Description:
12  * date: 2021/1/16 18:24
13  *
14  * @author hewei
15  */
16 public class ThreadPool {
17     /**存储词的队列**/
18     private static ArrayBlockingQueue<String> oneWordQueue = new ArrayBlockingQueue<String>(Integer.MAX_VALUE / 4);
19     /**存储词的次数**/
20     private static ConcurrentHashMap<String, AtomicInteger> wordCount = new ConcurrentHashMap<String, AtomicInteger>();
21     /**判断中英文的正则**/
22     private static String[] englishOrChinaWordCompile = {"[a-zA-Z]+", "[\\u4e00-\\u9fa5]"};
23     private static long waitTimeSecond = 5;
24     /**已知会创建10个线程池**/
25     private static CountDownLatch countDownLatch = new CountDownLatch(10);
26     /**存储词的次数排序**/
27     private static AtomicReferenceArray wordCountArray=new AtomicReferenceArray<String>(Integer.MAX_VALUE/16);
28 
29     public static void main(String[] args) {
30         BlockingQueue<Runnable> blockingQueue = new LinkedBlockingDeque<>(10000);
31         ThreadPoolExecutor readFilePool = new ThreadPoolExecutor(5, 5,
32                 waitTimeSecond, TimeUnit.SECONDS, blockingQueue, new UserThreadFactory("Study-WordCountReadFile-"),
33                 new UserRejectHandler());
34         //executor.allowCoreThreadTimeOut(true);
35         Long beginTime = System.currentTimeMillis();
36         //读取D盘的文件
37         File file = new File("E:\\tmp");
38         if (file.isDirectory()) {
39             File[] files = file.listFiles();
40             // 定义文件类型
41             for (File one : files) {
42                 String fileName = one.getName();
43                 readFilePool.execute(new WordCountReadFileTask(countDownLatch, "E:\\tmp\\" + fileName, oneWordQueue, englishOrChinaWordCompile));
44             }
45         }
46         ThreadPoolExecutor sortWordPool = new ThreadPoolExecutor(5, 5,
47                 waitTimeSecond, TimeUnit.SECONDS, blockingQueue, new UserThreadFactory("Study-WordCount-"),
48                 new UserRejectHandler());
49         //executor1.allowCoreThreadTimeOut(true);
50         for (int i = 0; i < 5; i++) {
51             sortWordPool.execute(new WordCountTask(countDownLatch, wordCount, oneWordQueue, waitTimeSecond,null));
52         }
53         try {
54             countDownLatch.await();
55             readFilePool.shutdown();
56             sortWordPool.shutdown();
57             // 写出到文件
58             List<Map.Entry<String, AtomicInteger>> list = new ArrayList(wordCount.entrySet());
59             Comparator com = new Comparator<Map.Entry<String, AtomicInteger>>(){
60                 @Override
61                 public int compare(Map.Entry<String, AtomicInteger> o1, Map.Entry<String, AtomicInteger> o2) {
62                     return ((Integer)o2.getValue().get()).compareTo((Integer) o1.getValue().get());
63                 }
64             };
65             list.sort(com);
66             // 写出到文件
67             BufferedWriter bw = new BufferedWriter(new FileWriter("E:\\read.txt"));
68             for(int i=0;i<list.size();i++){
69                 if(i<10) {
70                     System.out.println("单词  " + list.get(i).getKey() + ",次数  " + list.get(i).getValue());
71                 }
72                 bw.write("单词  "+ list.get(i).getKey()+",次数  "+ list.get(i).getValue());
73                 bw.newLine();
74             }
75             bw.flush();
76             bw.close();
77         } catch (Exception e) {
78             e.printStackTrace();
79         }
80     }
81 }

UserThreadFactory

 1 import java.util.concurrent.ThreadFactory;
 2 import java.util.concurrent.atomic.AtomicInteger;
 3 
 4 /**
 5  * ClassName: UserThreadFactory
 6  * Description:自定义线程创建工厂
 7  * date: 2021/1/16 18:26
 8  *
 9  * @author hewei
10  */
11 public class UserThreadFactory implements ThreadFactory {
12     /**
13      * 自定义线程名称前缀
14      **/
15     private final String prefixName;
16     /**
17      * 线程计数器 从1开始
18      */
19     private final AtomicInteger threadNumber = new AtomicInteger(1);
20 
21     public UserThreadFactory(String prefixName) {
22         this.prefixName = prefixName;
23     }
24 
25     @Override
26     public Thread newThread(Runnable runnable) {
27         //创建线程
28         String name = prefixName + threadNumber.getAndIncrement();
29         return new WorkThread(runnable,name);
30     }
31     /**
32      *自定义工作线程，定义线程名称有助于对jvm问题排查
33      */
34     class WorkThread extends Thread {
35         /**
36          * 线程名称
37          */
38         private String name;
39 
40         /**
41          * @param target  执行的方法
42          * @param name 线程的名称
43          */
44         public WorkThread(Runnable target, String name) {
45             super(target);
46             super.setName(name);
47             this.name=name;
48             System.out.println("创建："+name);
49         }
50 
51         @Override
52         public void run() {
53             try {
54                 /**
55                  * super.run()等同于target.run()
56                  */
57                 super.run();
58             } finally {
59                 System.out.println("结束线程:" + name);
60             }
61         }
62     }
63 }

WordCountReadFileTask

 1 import java.io.BufferedReader;
 2 import java.io.FileReader;
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 import java.util.concurrent.ArrayBlockingQueue;
 6 import java.util.concurrent.CountDownLatch;
 7 import java.util.regex.Matcher;
 8 import java.util.regex.Pattern;
 9 
10 /**
11  * ClassName: WordCountTask
12  * Description:
13  * date: 2021/1/17 19:48
14  *
15  * @author hewei
16  */
17 public class WordCountReadFileTask implements Runnable {
18     private String filePathAndName;
19     private ArrayBlockingQueue<String> oneWordQueue;
20     private  String[] englishOrChinaWordCompile;
21     private  CountDownLatch countDownLatch;
22 
23     public WordCountReadFileTask(CountDownLatch countDownLatch,String filePathAndName, ArrayBlockingQueue<String> oneWordQueue, String[] englishOrChinaWordCompile) {
24         this.countDownLatch=countDownLatch;
25         this.filePathAndName = filePathAndName;
26         this.oneWordQueue = oneWordQueue;
27         this.englishOrChinaWordCompile = englishOrChinaWordCompile;
28     }
29 
30     @Override
31     public void run() {
32         try {
33             BufferedReader br = new BufferedReader(new FileReader(filePathAndName));
34             StringBuffer sb = new StringBuffer();
35             List<String> strList=new ArrayList<String>();
36             String line = "";
37             while((line=br.readLine())!=null){
38                 sb.append(line);
39                 /**
40                  * 为了保证不超过Integer.max_value
41                  */
42                 if(sb.length()>50000000) {
43                     strList.add(sb.toString());
44                     /**
45                      * 清空StringBuffer
46                      * 1.delete,从到到尾
47                      * 2.new 新的对象。但会丢弃老对象加速gc到来
48                      * 3.setlength=0,不符合这里的场景
49                      */
50                     sb.delete(0,sb.length());
51                 }
52             }
53             if(sb!=null){
54                 strList.add(sb.toString());
55             }
56             br.close();
57             for(String words:strList) {
58                 for (String oneCompile : englishOrChinaWordCompile) {
59                     //正则
60                     Pattern p = Pattern.compile(oneCompile);
61                     Matcher matcher = p.matcher(words);
62                     while (matcher.find()) {
63                         /**
64                          * 添加一个元素，如果队列满，则阻塞等待队列被消费腾出空间来
65                          */
66                         oneWordQueue.put(matcher.group());
67                     }
68                 }
69             }
70         } catch (Exception e) {
71             e.printStackTrace();
72         }finally {
73             countDownLatch.countDown();
74         }
75     }
76 }

WordCountTask

 1 import java.io.BufferedReader;
 2 import java.io.FileReader;
 3 import java.util.ArrayList;
 4 import java.util.Arrays;
 5 import java.util.List;
 6 import java.util.concurrent.ArrayBlockingQueue;
 7 import java.util.concurrent.ConcurrentHashMap;
 8 import java.util.concurrent.CountDownLatch;
 9 import java.util.concurrent.TimeUnit;
10 import java.util.concurrent.atomic.AtomicInteger;
11 import java.util.concurrent.atomic.AtomicReferenceArray;
12 import java.util.regex.Matcher;
13 import java.util.regex.Pattern;
14 
15 /**
16  * ClassName: WordCountTask
17  * Description:
18  * date: 2021/1/17 19:48
19  *
20  * @author hewei
21  */
22 public class WordCountTask implements Runnable {
23     private ArrayBlockingQueue<String> oneWordQueue;
24     private ConcurrentHashMap<String, AtomicInteger> wordCount;
25     private long waitTimeSecond;
26     private  CountDownLatch countDownLatch;
27     private static AtomicReferenceArray wordCountArray;
28 
29     public WordCountTask(CountDownLatch countDownLatch,ConcurrentHashMap<String,AtomicInteger> wordCount,
30                          ArrayBlockingQueue<String> oneWordQueue,long waitTimeSecond,AtomicReferenceArray wordCountArray) {
31         this.wordCountArray=wordCountArray;
32         this.countDownLatch=countDownLatch;
33         this.oneWordQueue = oneWordQueue;
34         this.wordCount=wordCount;
35         this.waitTimeSecond=waitTimeSecond;
36     }
37 
38     @Override
39     public void run() {
40         try {
41             String oneWord;
42             AtomicInteger nowCount;
43             while ((oneWord=oneWordQueue.poll(waitTimeSecond, TimeUnit.SECONDS))!=null) {
44                 /**
45                  * 循环从队列里取出元素，然后加入到map中
46                  * 在加入map过程中，代码块会有指令重排问题。所以每一步都需要加判断。
47                  * 所以需要每一个操作都要具有原子性。
48                  */
49                 if((nowCount=wordCount.get(oneWord))==null){
50                     nowCount=new AtomicInteger(1);
51                     AtomicInteger ifExistCount=wordCount.putIfAbsent(oneWord,nowCount);
52                     if(ifExistCount!=null) {
53                         ifExistCount.getAndIncrement();
54                     }
55                 }else{
56                     nowCount.getAndIncrement();
57                 }
58                 /**
59                  * 实时排序，该排序依赖线程安全
60                  * 略
61                  */
62             }
63         } catch (Exception e) {
64             e.printStackTrace();
65         }finally {
66             countDownLatch.countDown();
67         }
68     }
69 }

内容总结

以上是互联网集市为您收集整理的Java 多线程读取文件并统计词频 实例 出神入化的《ThreadPoolExecutor》全部内容，希望文章能够帮你解决Java 多线程读取文件并统计词频 实例 出神入化的《ThreadPoolExecutor》所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端