多线程读取文件

单线程读取10K个 文件的话会显的非常的慢，但是如果我们开启多个线程去读取，会让读取的速度大大的加快，顺便说一下多线程的注意事项：synchronized 代码快中 尽量简短，不要有 类似socket.accept() inputstream.read() 这样的阻塞式的方法，这样会让程序减慢，如果synchronized代码快中的东西太多，容易造成单线程的囧地，而且速度还不如单线程快。

废话少说，我们来看看代码：
1.生成10K个 文件：

package com.fileThread;

import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;

public class GenFile {

    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {

        File file = null;
        OutputStream out = null;

        file = new File("c:/file");
        if(!file.exists()){
            file.mkdirs();
        }
        for (int i = 0; i < 10000; i++) {
            file = new File("c:/file/file" + i + ".txt");
            out = new FileOutputStream(file);
            out.write("nihao1hh1hh1".getBytes());
            out.close();
        }
        file = null;
        out = null;
    }

}

多线程 读取

package com.fileThread;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

public class ReadFile {

    public static void main(String[] args) throws Exception {
        Sum sum = new Sum();
        Thread t1 = new Thread(sum);
        Thread t2 = new Thread(sum);
        Thread t3 = new Thread(sum);
        t1.start();
        t2.start();
        t3.start();
        // t1.run();
        // t2.run();
        // t3.run();
        // System.out.println(sum.getSum()+"==");
    }
}

class Sum implements Runnable {
    private Integer i = 0;
    private Integer sum = 0;
    static long time;

    public void run() {
        File file = null;
        InputStream is = null;
        StringBuffer sb = null;
        while (true) {
            if (i == 0) {
                time = System.currentTimeMillis();
            }
            if (i == 10000) {
                break;
            }
            synchronized (this) {
                file = new File("c:/file/file" + i + ".txt");
                // System.out.println(i + "currentThread==" +
                // Thread.currentThread().getName()); 

              i++;


            }

            try {
                is = new FileInputStream(file);
            } catch (FileNotFoundException e) {
            }
            byte[] data = new byte[2048];
            int len = 0;
            sb = new StringBuffer();
            try {
                while ((len = is.read(data)) != -1) {
                    sb.append(new String(data, 0, len));
                }
            } catch (IOException e) {
            }
            String result = sb.toString();
            String[] arr = result.split("\\D+");
            synchronized (this) {
                for (String s : arr) {
                    if (s != null && s.trim().length() > 0) {
                        sum += Integer.parseInt(s);
                    }
                }
            }
        }
        file = null;
        sb = null;
        is = null;
        System.out.println(this.sum);
        System.out.println(System.currentTimeMillis() - time);
    }

    public Integer getI() {
        return i;
    }

    public void setI(Integer i) {
        this.i = i;
    }

    public Integer getSum() {
        return sum;
    }

    public void setSum(Integer sum) {
        this.sum = sum;
    }

}

所有的东西 都放到 synchronazied代码快中的速度比较，这个类似单线程

package com.fileThread;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

public class ReadFileAll {

    public static void main(String[] args) throws Exception {
        Sums sum = new Sums();
        Thread t1 = new Thread(sum);
        Thread t2 = new Thread(sum);
        Thread t3 = new Thread(sum);
        t1.start();
        t2.start();
        t3.start();
        // 22562
        // 14625
    }
}

class Sums implements Runnable {
    private Integer i = 0;
    private Integer sum = 0;
    static long time;

    public void run() {
        File file = null;
        InputStream is = null;
        StringBuffer sb = null;
        while (true) {
            if (i == 0) {
                time = System.currentTimeMillis();
            }
            if (i == 10000) {
                break;
            }
            synchronized (this) {
                file = new File("c:/file/file" + i + ".txt");
//                System.out.println(i + "currentThread=="
//                        + Thread.currentThread().getName());
                i++;
                try {
                    is = new FileInputStream(file);
                } catch (FileNotFoundException e) {
                }
                byte[] data = new byte[2048];
                int len = 0;
                sb = new StringBuffer();
                try {
                    while ((len = is.read(data)) != -1) {
                        sb.append(new String(data, 0, len));
                    }
                } catch (IOException e) {
                }
                String result = sb.toString();
                String[] arr = result.split("\\D+");
                for (String s : arr) {
                    if (s != null && s.trim().length() > 0) {
                        sum += Integer.parseInt(s);
                    }
                }
            }
        }
        file = null;
        sb = null;
        is = null;
        System.out.println(this.sum);
        System.out.println(System.currentTimeMillis() - time);
    }

    public Integer getI() {
        return i;
    }

    public void setI(Integer i) {
        this.i = i;
    }

    public Integer getSum() {
        return sum;
    }

    public void setSum(Integer sum) {
        this.sum = sum;
    }

}

单线程去读的速度：

package com.fileThread;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

public class ReadFileSingleThread {

    public static void main(String[] args) throws Exception {
        int i = 0;
        long time = 0;
        int sum =0;
        File file = null;
        InputStream is = null;
        StringBuffer sb = null;
        while (true) {
            if (i == 0) {
                time = System.currentTimeMillis();
            }
            if (i == 10000) {
                break;
            }
            file = new File("c:/file/file" + i + ".txt");
            i++;
            try {
                is = new FileInputStream(file);
            } catch (FileNotFoundException e) {
            }
            byte[] data = new byte[2048];
            int len = 0;
            sb = new StringBuffer();
            try {
                while ((len = is.read(data)) != -1) {
                    sb.append(new String(data, 0, len));
                }
            } catch (IOException e) {
            }
            String result = sb.toString();
            String[] arr = result.split("\\D+");
            for (String s : arr) {
                if (s != null && s.trim().length() > 0) {
                    sum += Integer.parseInt(s);
                }
            }
        }
        file = null;
        sb = null;
        is = null;
        System.out.println(sum);
        System.out.println(System.currentTimeMillis() - time);
    }
}

通过比较，大家就可以发现多线程的好处了，可能大家多如何写多线程存在疑问，这里我想说的是多想想，你的多线程是想做什么，就像 这个 例子，我的多线程 就是想 每个人线程分担 不同的文件读取，再算总和，所以我要控制的同步资源就是文件的名称和总和，所以我就需要把这两个 属性 同步上，这样就可以。如何返回多线程执行完的结果呢，我个人认为这样做，是让其他线程在mian 之前完成，这样就可以达到效果，可以用thread.join()方法，这样在执行mian 之前就会先把多线程执行完，就可以的到结果。