不太会用多线程555555555!!!!!不知道我的简单的需求怎么做好啊!!!55555555555

Question

import java.io.*
import java.util.*;
import java.util.concurrent.*;
import org.apache.commons.io.FileUtils;不太会用多线程555555555
------------------------------------------------------------------
我的需求：
我从DB里获得一个LIST,LIST里面全是TxtFileStruct对象
我要遍历这个LIST，然后针对LIST里的每个TxtFileStruct对象创建文件 我的问题:
1.我用普通的方法也就是thread2方法的时候速度反而很快;
利用JDK1.5 线程池的反而很慢,而且我也不知道执行完毕了没有,执行到strContent==3w多的时候就不动了
感觉没有完(因为createFiles方法里面的System.out.println("strContent=="+strContent);最大打印出来的数值是3W多,我也没办法确定是完了没完)
我不知道我那里写错了希望那位大虾能帮我纠正一下啊!!!!!!!!!!2.我用普通的方法可以知道 //计算多成功生成了多少 //保存失败的TxtFileStruct对象!
但是我如果用多线程的方法怎么能知道这两项数值啊?
public class AutoCreateTxt {
public static void main(String[] args) {
long start = System.currentTimeMillis();
//开始执行时间
System.out.println("Start=T=" + start);
List<TxtFileStruct> _list = new ArrayList();
System.out.println("Start==" + _list.size());
for (int i = 0; i < 200000; i++) {
_list.add(new TxtFileStruct("titie=" + i, " content=" + i));
}

//普通的不用多线程的
new AutoCreateTxt().thread2(_list);

//利用JDK1.5 线程池的
new AutoCreateTxt().thread3(_list);

long end = System.currentTimeMillis();
//开始执行时间 执行结束时间
System.out.println("End==" + (end - start));
} public List thread2(List<TxtFileStruct> _list) {
int sumData = _list.size();
//计算多成功生成了多少
int suSum = 0;
//保存失败的
List failList = new ArrayList();
boolean bFlag = false;
for (int i = 0; i < sumData; i++) {
bFlag = createFiles.creTxt(_list.get(i));
if(bFlag)
suSum++;
else
  failList.add(_list.get(i));
} }
public void thread3(List<TxtFileStruct> _list) {
int sumData = _list.size();
int corePoolSize = 20; // 线程池维护线程的最小数量
int maximumPoolSize = 50; // 线程池维护线程的最大数量
int keepAliveTime = 100; // 线程池维护线程所允许的空闲时间
int unit;// 线程池维护线程所允许的空闲时间的单位
int workQueue = 20; // 线程池所使用的缓冲队列
// 构造一个线程池
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(corePoolSize,
maximumPoolSize, keepAliveTime, TimeUnit.MILLISECONDS,
new ArrayBlockingQueue(workQueue),
new ThreadPoolExecutor.DiscardOldestPolicy());
for (int i = 0; i < sumData; i++) {
try {
new Thread(new createFilesThread(_list.get(i))).start();
threadPool.execute(new ThreadPoolTask(_list.get(i)));
} catch (Exception e) {
e.printStackTrace();
}
}
}
}class ThreadPoolTask implements Runnable, Serializable {
private static final long serialVersionUID = 4056961698947796649L;
public 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();
 FileUtils.forceMkdir(new File("path"));
 FileUtils.writeStringToFile(new File("fname"), strContent,
 "GBK");
 System.out.println("strContent=="+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 1

建议你看看【生产者，消费者】这个典型的多线程方式。参考这个先熟悉这个原理 http://www.java2000.net/viewthread.jsp?tid=581

Answer 2

推荐lz一本书：《java网络编程详解》 里面对多线程和线程池的应用和解释都很清楚lz 看看有没有电子版的，下个看看就好了，里面的例子都是实际开发中用到的。

Answer 3

/*生产和消费，当总量大于100时，就把消费100.
 *如超过3秒总量还未超过100，就全部消费掉.
 */
class Test7
{
      public static void main(String[] args)
      {
            final T t = new T();
            Thread thread1 = new Thread(new Runnable()
            {
                  public void run()
                  {
                        while(true)
                        {                              t.product();
                        }
                  }
            });
            Thread thread2 = new Thread(new Runnable()
            {
                  public void run()
                  {
                        while(true)
                        {
                              t.consume();
                        }
                  }
            });
            thread1.start();
            thread2.start();
      }}class T
{
      int n = 0;
      int p;
      Random r = new Random();
      double time;
      boolean b = false;
      synchronized void product()
      {
            time = System.currentTimeMillis();
            try
            {
//                Thread.currentThread().sleep(1000);
                  if(b)
                  {
                        wait();
                  }
            }
            catch(Exception e){System.out.println(e);}
            p =(r.nextInt(100))+1;
            n = n + p;
            System.out.println("生产了："+p+"当前总数为"+n);
            b = true;
            notify();
      }
      synchronized void consume()
      {
            try
            {
                  if(!b)
                  {
                        wait();
                  }
            }
            catch(Exception e){System.out.println(e);}            if(n>=100)
            {
                  n = n - 100;
                  System.out.println("剩余："+n);
            }
            else if(System.currentTimeMillis() >= (time+3000))
            {
                  System.out.println("超过3秒，全部消费，共消费："+ n);
                  n = 0;
            }
            b = false;
            notify();
      }
}多线程的小练习，楼主自己研究吧
另，楼主说打印3W多就不动了，是程序死锁了还是内存耗尽了啊

Answer 4

不太会用多线程555555555 
------------------------------------------------------------------ 
我的需求： 
我从DB里获得一个LIST,LIST里面全是TxtFileStruct对象 
我要遍历这个LIST，然后针对LIST里的每个TxtFileStruct对象创建文件 我的问题: 
1.我用普通的方法也就是thread2方法的时候速度反而很快; 
利用JDK1.5 线程池的反而很慢,而且我也不知道执行完毕了没有,执行到strContent==3w多的时候就不动了 
感觉没有完(因为createFiles方法里面的System.out.println("strContent=="+strContent);最大打印出来的数值是3W多,我也没办法确定是完了没完) 
我不知道我那里写错了希望那位大虾能帮我纠正一下啊!!!!!!!!!! 2.我用普通的方法可以知道 //计算多成功生成了多少 //保存失败的TxtFileStruct对象! 
但是我如果用多线程的方法怎么能知道这两项数值啊? 
import java.io.* 
import java.util.*; 
import java.util.concurrent.*; 
import org.apache.commons.io.FileUtils; 
public class AutoCreateTxt { 
public static void main(String[] args) { 
long start = System.currentTimeMillis(); 
//开始执行时间 
System.out.println("Start=T=" + start); 
List <TxtFileStruct> _list = new ArrayList(); 
System.out.println("Start==" + _list.size()); 
for (int i = 0; i < 200000; i++) { 
_list.add(new TxtFileStruct("titie=" + i, " content=" + i)); 
} //普通的不用多线程的 
new AutoCreateTxt().thread2(_list); //利用JDK1.5 线程池的 
new AutoCreateTxt().thread3(_list); long end = System.currentTimeMillis(); 
//开始执行时间 执行结束时间 
System.out.println("End==" + (end - start)); 
} public List thread2(List <TxtFileStruct> _list) { 
int sumData = _list.size(); 
//计算多成功生成了多少 
int suSum = 0; 
//保存失败的 
List failList = new ArrayList(); 
boolean bFlag = false; 
for (int i = 0; i < sumData; i++) { 
bFlag = createFiles.creTxt(_list.get(i)); 
if(bFlag) 
suSum++; 
else 
failList.add(_list.get(i)); 
} } 
public void thread3(List <TxtFileStruct> _list) { 
int sumData = _list.size(); 
int corePoolSize = 20; // 线程池维护线程的最小数量 
int maximumPoolSize = 50; // 线程池维护线程的最大数量 
int keepAliveTime = 100; // 线程池维护线程所允许的空闲时间 
int unit;// 线程池维护线程所允许的空闲时间的单位 
int workQueue = 20; // 线程池所使用的缓冲队列 
// 构造一个线程池 
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(corePoolSize, 
maximumPoolSize, keepAliveTime, TimeUnit.MILLISECONDS, 
new ArrayBlockingQueue(workQueue), 
new ThreadPoolExecutor.DiscardOldestPolicy()); 
for (int i = 0; i < sumData; i++) { 
try { 
new Thread(new createFilesThread(_list.get(i))).start(); 
threadPool.execute(new ThreadPoolTask(_list.get(i))); 
} catch (Exception e) { 
e.printStackTrace(); 
} 
} 
} 
} class ThreadPoolTask implements Runnable, Serializable { 
private static final long serialVersionUID = 4056961698947796649L; 
public 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(); 
FileUtils.forceMkdir(new File("path")); 
FileUtils.writeStringToFile(new File("fname"), strContent, 
"GBK"); 
System.out.println("strContent=="+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 5

不太会用多线程555555555 
------------------------------------------------------------------ 
我的需求： 
我从DB里获得一个LIST,LIST里面全是TxtFileStruct对象 
我要遍历这个LIST，然后针对LIST里的每个TxtFileStruct对象创建文件 我的问题: 
1.我用普通的方法也就是thread2方法的时候速度反而很快; 
利用JDK1.5 线程池的反而很慢,而且我也不知道执行完毕了没有,执行到strContent==3w多的时候就不动了 
感觉没有完(因为createFiles方法里面的System.out.println("strContent=="+strContent);最大打印出来的数值是3W多,我也没办法确定是完了没完) 
我不知道我那里写错了希望那位大虾能帮我纠正一下啊!!!!!!!!!! 2.我用普通的方法可以知道 //计算多成功生成了多少 //保存失败的TxtFileStruct对象! 
但是我如果用多线程的方法怎么能知道这两项数值啊? 
import java.io.* 
import java.util.*; 
import java.util.concurrent.*; 
import org.apache.commons.io.FileUtils; 
public class AutoCreateTxt { 
public static void main(String[] args) { 
long start = System.currentTimeMillis(); 
//开始执行时间 
System.out.println("Start=T=" + start); 
List <TxtFileStruct> _list = new ArrayList(); 
System.out.println("Start==" + _list.size()); 
for (int i = 0; i < 200000; i++) { 
_list.add(new TxtFileStruct("titie=" + i, " content=" + i)); 
} //普通的不用多线程的 
new AutoCreateTxt().thread2(_list); //利用JDK1.5 线程池的 
new AutoCreateTxt().thread3(_list); long end = System.currentTimeMillis(); 
//开始执行时间 执行结束时间 
System.out.println("End==" + (end - start)); 
} public List thread2(List <TxtFileStruct> _list) { 
int sumData = _list.size(); 
//计算多成功生成了多少 
int suSum = 0; 
//保存失败的 
List failList = new ArrayList(); 
boolean bFlag = false; 
for (int i = 0; i < sumData; i++) { 
bFlag = createFiles.creTxt(_list.get(i)); 
if(bFlag) 
suSum++; 
else 
failList.add(_list.get(i)); 
} } 
public void thread3(List <TxtFileStruct> _list) { 
int sumData = _list.size(); 
int corePoolSize = 20; // 线程池维护线程的最小数量 
int maximumPoolSize = 50; // 线程池维护线程的最大数量 
int keepAliveTime = 100; // 线程池维护线程所允许的空闲时间 
int unit;// 线程池维护线程所允许的空闲时间的单位 
int workQueue = 20; // 线程池所使用的缓冲队列 
// 构造一个线程池 
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(corePoolSize, 
maximumPoolSize, keepAliveTime, TimeUnit.MILLISECONDS, 
new ArrayBlockingQueue(workQueue), 
new ThreadPoolExecutor.DiscardOldestPolicy()); 
for (int i = 0; i < sumData; i++) { 
try { 
new Thread(new createFilesThread(_list.get(i))).start(); 
threadPool.execute(new ThreadPoolTask(_list.get(i))); 
} catch (Exception e) { 
e.printStackTrace(); 
} 
} 
} 
} class ThreadPoolTask implements Runnable, Serializable { 
private static final long serialVersionUID = 4056961698947796649L; 
public 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(); 
FileUtils.forceMkdir(new File("path")); 
FileUtils.writeStringToFile(new File("fname"), strContent, 
"GBK"); 
System.out.println("strContent=="+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 6

import java.io.*;
import java.util.*;
import java.util.concurrent.*;
import org.apache.commons.io.FileUtils;public class AutoCreateTxt {
public static void main(String[] args) {
long start = System.currentTimeMillis();
// 开始执行时间
System.out.println("Start=T=" + start);
List<TxtFileStruct> _list = new ArrayList();
System.out.println("Start==" + _list.size());
for (int i = 0; i < 200000; i++) {
_list.add(new TxtFileStruct("titie=" + i, " content=" + i));
} // 普通的不用多线程的
new AutoCreateTxt().thread2(_list); // 利用JDK1.5 线程池的
new AutoCreateTxt().thread3(_list); long end = System.currentTimeMillis();
// 开始执行时间 执行结束时间
System.out.println("End==" + (end - start));
} public List thread2(List<TxtFileStruct> _list) {
int sumData = _list.size();
// 计算多成功生成了多少
int suSum = 0;
// 保存失败的
List failList = new ArrayList();
boolean bFlag = false;
for (int i = 0; i < sumData; i++) {
bFlag = createFiles.creTxt(_list.get(i));
if (bFlag)
suSum++;
else
failList.add(_list.get(i));
} } public void thread3(List<TxtFileStruct> _list) {
int sumData = _list.size();
int corePoolSize = 20; // 线程池维护线程的最小数量
int maximumPoolSize = 50; // 线程池维护线程的最大数量
int keepAliveTime = 100; // 线程池维护线程所允许的空闲时间
int unit;// 线程池维护线程所允许的空闲时间的单位
int workQueue = 20; // 线程池所使用的缓冲队列
// 构造一个线程池
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(corePoolSize,
maximumPoolSize, keepAliveTime, TimeUnit.MILLISECONDS,
new ArrayBlockingQueue(workQueue),
new ThreadPoolExecutor.DiscardOldestPolicy());
for (int i = 0; i < sumData; i++) {
try {
new Thread(new createFilesThread(_list.get(i))).start();
threadPool.execute(new ThreadPoolTask(_list.get(i)));
} catch (Exception e) {
e.printStackTrace();
}
}
}
}class ThreadPoolTask implements Runnable, Serializable {
private static final long serialVersionUID = 4056961698947796649L; public 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();
FileUtils.forceMkdir(new File("path"));
FileUtils.writeStringToFile(new File("fname"), strContent, "GBK");
System.out.println("strContent==" + 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 7

java里面实现多线程已经很简单了，不信你用C语言写写看。

Answer 8

经过一个高人的指点啊...我下面这样写终于可以了啊...
但是高人觉得麻烦啊.不回答我下面的问题啊!!
不知道有没有人知道怎么解决啊?谢谢啊
1.我听说线程序接池还需要关闭!不然就会资源耗尽~但我不知道怎么关闭啊!
2.我怎么能在多线程里面向在thread2里面一样!
在所有线程都执行完毕以后能知道总共耗费多少时间.并且把创建失败的对象都放入一个list打印出来!
因为多线程不象单线程一样,不知道什么时候执行最后一句.所以下面这句我不知道放到什么地方!
long end = System.currentTimeMillis();
System.out.println(end - start);
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 9

想看多线程程序运行时间，把下面代码放到 main 方法的第一行：Runtime.getRuntime().addShutdownHook(
new Thread(
new Runnable() {
private long time;
{
this.time = System.currentTimeMillis();
}
public void run() {
this.time = System.currentTimeMillis() - this.time;
System.out.println("运行总计耗时:" + time + "ms");
}
}
)
);