学习笔记―java线程池模拟

一、知识点

1、线程常用的方法

synchronized 同步代码块，用于同步操作，java5提供也了新的方法，等后面再说

wait 线程主动释放对象锁，所以wait在synchronized内部使用，当前线程阻塞，知道notify方法唤醒

sleep 则不会释放锁

2、锁对象

如果是静态方法则是类的字节码对象，只有同一个对象才能锁住

3、线程池的实现

以下代码并未使用Java提供的线程池，而是自行组装的

首先提供一个线程类，用于主线程创建固定的线程数，然后巧妙的使用Verctor作为队列

线程类中提供构造方法使其传入队列，主线程通过notifyAll方法唤醒中因wait而休眠的线程

线程类中定义静态方法，记录已完成的数目

线程类中有两部分需要同步:

完成队列数，用于判断是否全部任务已经完成

从队列中取数据时需要线程安全，因为所以线程操作的是同一个队列

二、部分参考代码

 

 

public class SimplePoolThread extends Thread{

    // 线程中需要处理的队列,通过构造方法传入
    private List pool;
    public SimplePoolThread(List pool){
        this.pool = pool;
    }

    // 标记已经完成的
    // 这个是静态的，所以线程池中共用此数据
    private static int finish = 0;
    // 此处加锁的对象是类的字节码对象
    private static synchronized void addFinish(){
        finish ++;
    }

    @Override
    public void run() {
        // 如果没有完成,那么run方法一直运行
        while(finish != SimpleDemo.getNumber()){
            File input = null;

            // 此处为去队列部分，所以需要线程安全
            synchronized(pool){
                // 处理的数据为空
                while(pool.isEmpty()){
                    // 为空且相等,说明还未有队列进入线程池或队列已经处理完毕
                    if(finish == SimpleDemo.getNumber()){
                        System.out.println("Thread ending");
                        return;
                    }
                    // 如果不是，那么等待
                    try {
                        pool.wait();
                    } catch (InterruptedException e) {
                    }
                }

                // 队列不为空，那么从后面开始处理
                input = (File) pool.remove(pool.size()-1);
                addFinish();
            }

            // 业务处理部分，不会受多线程影响了
            if(!input.getName().endsWith(".gz")){
                try {
                    InputStream in = new FileInputStream(input);
                    in = new BufferedInputStream(in);
                    File output = new File(input.getParent(),input.getName()+".gz");
                    if(!output.exists()){
                        OutputStream out = new FileOutputStream(output);
                        out = new BufferedOutputStream(new GZIPOutputStream(out));
                        int b;
                        while((b = in.read())!=-1){
                            out.write(b);
                        }
                        out.flush();
                        out.close();
                        in.close();
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

 

 public final static int count = 4;
    // 需要处理的队列数
    private static int number = -1;
    public static int getNumber() {
        return number;
    }

    public static void main(String[] args) {
        Vector pool = new Vector();
        // 创建线程池
        SimplePoolThread[] threads = new SimplePoolThread[count];

        for(int i=0;i<threads.length;i++){
            threads[i] = new SimplePoolThread(pool);
            threads[i].start();
        }

        // 临时计数
        int totalFiles = 0;
        File f = new File(".");
        if(f.exists()){
            if(f.isDirectory()){
                File[] files = f.listFiles();
                for(int j=0;j<files.length;j++){
                    if(!files[j].isDirectory()){
                        totalFiles++;
                        // 往线程池队列中添加数据，并更新线程池
                        synchronized (pool){
                            pool.add(0,files[j]);
                            pool.notifyAll();
                        }
                    }
                }
            }else{
                totalFiles++;
                synchronized(pool){
                    pool.add(0,f);
                    pool.notifyAll();
                }
            }
        }

        // 队列添加结束
        number = totalFiles;

        // 关闭空闲的进程
        for(int i=0;i<threads.length;i++){
            threads[i].interrupt();
        }
    }