java线程池的应用浅析

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.util.Map;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.TimeUnit;



/**

 * 多线程 字符流

 * @author winkey

 *

 */

public class MyThread3 extends Thread{

    public static SortArray sortArray = new SortArray(10000) ;

    

    public String[] dataArr;

    

    public MyThread3(String[] dataArr){

        this.dataArr = dataArr;

    }



    public void run(){  

        //这个地方也有问题，怎么处理临界资源·~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

        //其实我只是想多个线程处理batchDataArr数组

        /*for(int i=0;i<batchDataArr.length;i++){

            if(this.index<batchDataArr.length){

                String str = batchDataArr[index++];

                Integer numAsInt = Integer.valueOf(str);

                System.out.println(Thread.currentThread().getName()+"__"+numAsInt);

                sortArray.setBit(numAsInt, 1);

        } */

        //while(true){

            //String[] batchDataArr = BatchDataArrHolder.take();

            //if (null == batchDataArr) continue;

            String[] batchDataArr = this.dataArr;

            if (null != batchDataArr){

                for(int i=0;i<batchDataArr.length;i++){

                    String str = batchDataArr[i];

                    Integer numAsInt = Integer.valueOf(str);

                    System.out.println(Thread.currentThread().getName()+"__"+numAsInt);

                    sortArray.setBit(numAsInt, 1);

                }

            }

        //}

    } 

    

    public static void main(String[] args) throws Exception {    

        BufferedReader in = new BufferedReader(new FileReader("E:\\bbbbbbb.txt"));

        BufferedWriter out = new BufferedWriter(new FileWriter("E:\\cc.txt"));

        BatchDataArrHolder holder = new BatchDataArrHolder();

        int readLength = 0;

        char[] chars = new char[5];

        String tail=null;

        String batchData;

        

        try{

            //创建一个可重用固定线程数的线程池

            ExecutorService pool = Executors.newFixedThreadPool(2);//两个子线程

            

            /*MyThread2 mt2 = new MyThread2();

            pool.execute(mt1);

            pool.execute(mt2);*/

             while(true){

                readLength = in.read(chars, 0, chars.length);

                //没有读上来数据说明上一次读取数据已读完，不再处理

                if(readLength == 0)

                    break;

                boolean isEnd = false;

                //读上来的数据少于数组长度，说明这一次已读完，处理完这次后不再继续读取

                if(readLength < chars.length){

                    //System.out.println(String.valueOf(chars).substring(0, readLength));

                    batchData = String.valueOf(chars).substring(0, readLength);

                    isEnd = true;

                }else{

                    //System.out.println(String.valueOf(chars));

                    batchData = String.valueOf(chars);

                }

                //接上前一次的剩余数据

                if(tail != null){

                    batchData = ""+tail+batchData;

                }

                //截取本次的剩余数据，留到下次用

                tail = batchData.substring(batchData.lastIndexOf(",")+1,batchData.length());

                if(tail.length()==0){

                    tail = null;

                }

                batchData = batchData.substring(0,batchData.lastIndexOf(","));

                String[] batchDataArr = new String[batchData.split(",").length];//多线程处理这个东西！！！

                batchDataArr = batchData.split(",");

                //holder.push(batchDataArr);//主线程将每次读上来的数据保存到 

                MyThread3 mt1 = new MyThread3(batchDataArr);

                

                pool.execute(mt1);

                if(isEnd==true){

                    break;

                }

            }

             //关闭线程用

             pool.shutdown();//只是不能再提交新任务，等待执行的任务不受影响  

              

                try {  

                    boolean loop = true;  

                    do {    //等待所有任务完成  

                        loop = !pool.awaitTermination(2, TimeUnit.SECONDS);  //阻塞，直到线程池里所有任务结束

                    } while(loop);  

                } catch (InterruptedException e) {  

                    e.printStackTrace();  

                } 

             /*while(true){

                 if(BatchDataArrHolder.isEmpty()){

                     pool.shutdown(); 

                     break;

                 }

             }*/

            //写数据

            //Thread.currentThread().sleep(2000);

            Integer sortUnit = sortArray.getMaxNum();

            System.out.println("最大数为：     "+sortUnit);

            for(int i = 0;i<=sortUnit;i++){

                if(sortArray.getBit(i)==1){

                    StringBuffer buf = new StringBuffer(""+i+"");

                    buf.append(",");

                    Integer num = sortArray.repeatingData.get(i);

                    if(num!=null && num>=2){

                        for(int j=2;j<=num;j++){

                            buf.append(""+i+"").append(",");

                        }

                    }

                    out.write(buf.toString());

                }                

            }

            out.flush();

        }finally{

            if(in!=null){

                 try{

                     in.close();

                 }catch(IOException e){

                     e.printStackTrace();

                 }

            }

             if(out!=null){

                 try{

                     out.close();

                 }catch(IOException e){

                     e.printStackTrace();

                 }

            }

        }

    }

}