有人有比较成熟的!用线程池的多线程文件下载!

Question

和文件上传的代码吗?麻烦大家了!

Answer 1

http://commons.apache.org/sandbox/threadpool/

Answer 2

import java.io.File;
import java.util.*;
import org.apache.commons.io.FileUtils;
public class AutoCreateTxt {
    // 休息时间
    private final static int sleepT = 1000;
    // 循环间隔
    private final static int dataT = 1000;    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        System.out.println("Start=T=" +start);
        List<TxtFileStruct> _list = new ArrayList();
        for (int i = 0; i < 300000; i++)
            _list.add(new TxtFileStruct("titie=" + i, " content=" + i));
        System.out.println("Start==" + _list.size());
        
        //经过测试用非多线程的方法     System.out.println("End==" + ( end-start));
            //的结果反而快                         
        new AutoCreateTxt().noThread(_list);
        
        //经过测试用多线程的方法
        //用createFilesThread.run方法里面最后一个System.out.println("end==" + end);的数值
            //减去System.out.println("Start=T=" +start);的数值反而比不用多线程的速度慢5倍左右
            //不知道为什么？
        //new AutoCreateTxt().runThread(_list);
        
        long end = System.currentTimeMillis();
        System.out.println("End==" + ( end-start));
    }    public void noThread(List<TxtFileStruct> _list) {
        int sumData = _list.size();
        for (int i = 0; i < sumData; i++) {
            createFiles.creTxt(_list.get(i));
        }    }    public void runThread(List<TxtFileStruct> _list) {
        int sumData = _list.size();
        for (int i = 0; i < sumData; i++) {
            // 如果i等于循环间隔，则线程停止X豪秒
            if (((i + 1) * dataT) == i) {
                try {
                    Thread.sleep(sleepT);
                } catch (InterruptedException e) {
                    // TODO 自动生成 catch 块
                    e.printStackTrace();
                }
            }
            // 这样写会不会开了太多的线程了！？创建和销毁的时间浪费太大了！而且我不知道怎么纪录执行的次数！
            // 怎么能用JDK1.5新特性写呢？
            new Thread(new createFilesThread(_list.get(i))).start();
        }
    }
}class createFilesThread implements Runnable {
    public TxtFileStruct _as;    public static int runSum = 0;    public createFilesThread(TxtFileStruct _as) {
        this._as = _as;
    }    public void run() {
        createFiles.creTxt(this._as);
        runSum++;
        //纪录总执行的次数！
    //    System.out.println("runSum==" + runSum);
        long end = System.currentTimeMillis();
        System.out.println("end==" + end);
    }
}class createFiles {
    public static boolean creTxt(TxtFileStruct _as) {
        boolean reValue = true;
        try {
            String strContent = _as.getTitle() + _as.getContent();
             FileUtils.forceMkdir(new File("path"));
             FileUtils
             .writeStringToFile(new File("fname"), strContent, "GBK");
        } catch (Exception e) {
            e.printStackTrace();
            reValue = false;
        }
        return reValue;
    }
}class TxtFileStruct {
    private String title;    private String content;    TxtFileStruct(String _title, String _content) {
        this.title = _title;
        this.content = _content;    }    public String getContent() {
        return content;
    }    public void setContent(String content) {
        this.content = content;
    }    public String getTitle() {
        return title;
    }    public void setTitle(String title) {
        this.title = title;
    }
}

Answer 3

上一个发错了import java.io.Serializable;
import java.util.*;
import java.util.concurrent.*;public class AutoCreateTxt {    static int corePoolSize = 20; // 线程池维护线程的最小数量
    static int maximumPoolSize = 50; // 线程池维护线程的最大数量
    static int keepAliveTime = 100; // 线程池维护线程所允许的空闲时间
    static int unit; // 线程池维护线程所允许的空闲时间的单位    static  ThreadPoolExecutor threadPool;
    public static void main(String[] args) {
        // 构造一个线程池
        threadPool = new ThreadPoolExecutor(corePoolSize,
                                            maximumPoolSize, keepAliveTime,
                                            TimeUnit.MILLISECONDS,
                                            new LinkedBlockingQueue());
        
        long start = System.currentTimeMillis();
        System.out.println("开始时间=" + start);
        List<TxtFileStruct> _list = new ArrayList();        for (int i = 0; i < 200000; i++) {
            _list.add(new TxtFileStruct("titie=" + i, " content=" + i));
        }        System.out.println("总对象数=" + _list.size());
        //多线程Pool
        new AutoCreateTxt().thread3(_list);
        //一般的调用方法,非多线程
        //System.out.prinltn("静态化失败列表:=="+new AutoCreateTxt().thread2(_list));
    }    //一般的调用方法
    public List thread2(List<TxtFileStruct> _list) {
 long start= System.currentTimeMillis();
        List reValue = new ArrayList();
        int sumData = _list.size();
        boolean runFlag = false;
        for (int i = 0; i < sumData; i++) {
            TxtFileStruct tmpTFS =  _list.get(i);
            runFlag = createFiles.creTxt(tmpTFS);
            if(runFlag)
                    System.out.println("成功=" + tmpTFS.getTitle());
            else{
                    System.out.println("失败=" + tmpTFS.getTitle());
                    reValue.add(tmpTFS);
                }
        }
 long end= System.currentTimeMillis();
System.out.println(end-start);
        return reValue;    }    //多线程Pool方法
    public void thread3(List<TxtFileStruct> _list) {        int sumData = _list.size();
        for (int i = 0; i < sumData; i++) {
            try {
                threadPool.execute(new ThreadPoolTask(_list.get(i)));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}
class ThreadPoolTask implements Runnable, Serializable {
    // 保存任务所需要的数据
    private TxtFileStruct _as;    ThreadPoolTask(TxtFileStruct _as) {
        this._as = _as;
    }    public void run() {
        createFiles.creTxt(this._as);
        _as = null;
    }
}
class createFiles {
    //创建
    public static boolean creTxt(TxtFileStruct _as) {
        boolean reValue = true;
        try {
            String strContent = _as.getTitle() + _as.getContent();
            //延长时间算法
            //for (int i = 0; i < 100000; i++) {}
            //根据TxtFileStruct对象创建文件
            // FileUtils.forceMkdir(new File("path"));
            // FileUtils.writeStringToFile(new File("fname"), strContent,
            // "GBK");
            System.out.println(strContent);
        } catch (Exception e) {
            e.printStackTrace();
            reValue = false;
        }
        return reValue;
    }
}
class TxtFileStruct {
    //文章标题
    private String title;
    //文章内容
    private String content;    TxtFileStruct(String _title, String _content) {
        this.title = _title;
        this.content = _content;    }    public String getContent() {
        return content;
    }    public void setContent(String content) {
        this.content = content;
    }    public String getTitle() {
        return title;
    }    public void setTitle(String title) {
        this.title = title;
    }
}

Answer 4

java实现多线文件下载，这里有完整的代码，lz有时间去看看http://calmness.javaeye.com/blog/220075

Answer 5

我初步的想法是!用java.util.concurrent.*的ThreadPoolExecutor
做线程池!然后调用apache的 commons-fileupload组件实现文件上传,下载功能但是我对
1.ThreadPoolExecutor的关闭
2.在大并发情况下,我是采用创建一个不关闭的threadpool好,还是对每一个用户都创建一个threadpool好?后者是不是
消耗资源反而更厉害呢?
3.我希望主线程,执行到threadpool以后,就停止执行下面的,直到threadpool里面的任务全部都执行完毕,threadpool关闭以后才继续执行主线程后面的内容!并且其中任意一个thread失败(返回false),主程序都将退出!上面三点把握的不好!不知道该怎么做啊!希望得到帮助

Answer 6

这个我也看过啊!我不会不找就来csdn问的啊..还不太一样啊!
哪个是一个类似迅雷的c/s的东西啊!
1.他没有实现threadpool
2.我希望主线程,执行到threadpool以后,就停止执行下面的语句,直到threadpool里面的任务全部都执行完毕,threadpool关闭以后才继续执行主线程后面的内容!并且其中任意一个thread失败(返回false),主程序都将退出! 
3.他是针对1个文件多线程下载.我是针对多文件多线程每个文件一个thred
确实很有参考价值!但是跟我的需求还不是那么一样啊

Answer 7

线程池和数据库链接池的原理其实是一样的.如果有空闲的线程就去干事情,线程满的话,后来的请求就需要排队了.一个线程做完事情了.就把自己的标志空闲的标志位置1.基本原理差不多,线程的代码网上也是很多.上面已经好多人提供了.至于文件上传,我一般就是用Apache的上传文件的那个包叫commons-fileupload.你下载一下.
上传文件的时候要注意你的Form要设置成 enctype="multipart/form-data".
其他的你自己看fileupload的例子吧

Answer 8

原理当然不用说了!但是
如果只有2-7个thread的话用threadpool是否反而比多thread更耗费资源不知道!需要有经验的人说说啊!
另外我的问题是用java.util.concurrent.*的ThreadPoolExecutor 
做线程池!然后调用apache的 commons-fileupload组件实现文件上传,下载功能 但是我对 
1.ThreadPoolExecutor的关闭 
2.在大并发情况下,我是采用创建一个不关闭的threadpool好,还是对每一个用户都创建一个threadpool好?后者是不是 
消耗资源反而更厉害呢? 
3.我希望主线程,执行到threadpool以后,就停止执行下面的,直到threadpool里面的任务全部都执行完毕,threadpool关闭以后才继续执行主线程后面的内容!并且其中任意一个thread失败(返回false),主程序都将退出! 上面三点把握的不好!不知道该怎么做啊!希望得到帮助