（生产者消费者）线程池、 多线程读写线程

接上篇 非阻塞队列ConcurrentLinkedQueue之容器初步学习

地 址: http://blog.csdn.net/RD_moon/article/details/77939147

如图所示：
1、 DataContainer 容器类上篇博客已有 ；
2、 txt 文本中存在多行数据大概有1000行 ，不多；
3、 运行Startup 类 会将txt文本中的数据通过线程放到容器里，然后在通过多个线程从容器里读出来，打印在控制台上；

一、 读线程

package com.pst.demo.service;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;

import com.pst.demo.support.DataContainer;
import com.pst.demo.support.EtlConstants;

public class ReadDataService implements Runnable{

    private CountDownLatch countDownLatch;

    private DataContainer dataContainer;

    private File srcFile;

    private static int BLOCK_SIZE = 250;//

    public ReadDataService(File srcFile, DataContainer dataContainer, CountDownLatch countDownLatch) {
        this.srcFile = srcFile;
        this.dataContainer = dataContainer;
        this.countDownLatch = countDownLatch;
    }

    @Override
    public void run() {
        FileReader fr = null;
        BufferedReader bf = null;
        try {
            fr  = new FileReader(this.srcFile);
            bf = new BufferedReader(fr);
            String line = null;
            int rowNum = 0;
            List rows = new ArrayList(BLOCK_SIZE);// list 里读入大小为BLOCK_SIZE的数量时 才被放进容器里
            while ((line = bf.readLine()) != null) {
                rowNum++;
                rows.add(line);
                if (rowNum % BLOCK_SIZE == 0) {
                    dataContainer.insertData(rows);
                    rows = new ArrayList(BLOCK_SIZE);
                }
            }
            if (rows.size() > 0) {
                dataContainer.insertData(rows);
            }

        }  catch (Exception e) {
            e.printStackTrace();
        } finally {
            insertEndFlag(this.dataContainer);
            if (countDownLatch != null) {
                countDownLatch.countDown();
            }
            if (bf != null) {
                try {
                    bf.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fr != null) {
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private void insertEndFlag(DataContainer data){
        try {//置为-1 理解为状态位
            data.insertData(EtlConstants.EXTRACT_END_FLAG);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }


}

二、 写线程

package com.pst.demo.service;

import java.util.List;
import java.util.concurrent.CountDownLatch;

import com.pst.demo.support.DataContainer;


public class WriteDataService implements Runnable {

    private CountDownLatch countDownLatch;

    private DataContainer dataContainer;

    public WriteDataService(CountDownLatch countDownLatch,
            DataContainer dataContainer) {

        this.countDownLatch = countDownLatch;
        this.dataContainer = dataContainer;
    }



    @Override
    public void run() {
            while(true){
                try {
                    Object rows =this.dataContainer.getData();
                    if (rows == null || rows instanceof Integer) {
                        break;
                    } else {
                        writetData((List)rows);
                    }
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }finally{
                    if(countDownLatch!=null){
                        countDownLatch.countDown();
                    }
                }
            }
    }



    private void writetData(List rows) {
        //这里写对数据的操作 如写进文件里 后者数据库里
        for(int i=0;i<rows.size();i++){
            System.out.println(rows.get(i));
        }
    }

}

三、线程池

package com.pst.demo.support;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * 
 */
public class ThreadPool {

    private static int DEFAULT_POOL_NUMBER = 8;

    private static ThreadPool instance = new ThreadPool();

    private ExecutorService writeDataPool;

    private ExecutorService readDataPool;

    private ThreadPool() {
        // TODO Auto-generated constructor stub
        writeDataPool = Executors.newFixedThreadPool(DEFAULT_POOL_NUMBER);
        readDataPool = Executors.newFixedThreadPool(DEFAULT_POOL_NUMBER);
    }

    public static ThreadPool getInstance(){
        return instance;
    }

    public void dispatchInsertDataThread(Runnable command){
        writeDataPool.execute(command);
    }

    public void dispatchReadDataThread(Runnable command){
        readDataPool.execute(command);
    }

}

四、 EtlConstants类

package com.pst.demo.support;

public abstract class EtlConstants {

    public final static Integer EXTRACT_END_FLAG = -1;

}

五、 线程启动类

package com.pst.demo.support;

import java.io.File;
import java.io.FileFilter;
import java.io.FileWriter;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;

import org.apache.commons.lang.StringUtils;

import com.pst.demo.service.ReadDataService;
import com.pst.demo.service.WriteDataService;

public class Startup {

    private static final String DATA_DIR = "D:/workspace/work/threadtest/src/";

    public static List errorLog = new ArrayList();

    public static void main(String[] args) {
        try {
            String dirName = DATA_DIR;
            File dir = new File(dirName);           
            File[] dataFiles = dir.listFiles(new FileFilter() {
                @Override
                public boolean accept(File pathname) {
                    if (StringUtils.indexOf(pathname.getName(), ".txt") != -1) {
                        return true;
                    }
                    return false;
                }
            });
            for (File file : dataFiles) {
                //1.ETL线程
                System.out.println("startEtl starting....");
                startEtl(file);
                System.out.println("startEtl end....");

            }
        } catch (Exception e) {
            e.printStackTrace();
        } 
    }

    private static void startEtl(File log){
        try {
            DataContainer dataContainer = new DataContainer();
            final CountDownLatch countDownLatch = new CountDownLatch(5);
            ThreadPool.getInstance().dispatchReadDataThread(new ReadDataService(log, dataContainer, countDownLatch)); 
            ThreadPool.getInstance().dispatchInsertDataThread(new WriteDataService(  countDownLatch, dataContainer));
            ThreadPool.getInstance().dispatchInsertDataThread(new WriteDataService(  countDownLatch, dataContainer));
            ThreadPool.getInstance().dispatchInsertDataThread(new WriteDataService(countDownLatch, dataContainer));
            ThreadPool.getInstance().dispatchInsertDataThread(new WriteDataService(countDownLatch, dataContainer));
            countDownLatch.await();
        } catch (Exception e) {
            e.printStackTrace();
        } 
    }


}