一道多线程练习题

Question

俩.txt文件，内容分别是
data1.txt                      data2.txt
Name,value1,value2,value3      Name,value1,value2,value3
N1,2,5,3                       N2,1,3,2
N1,3,1,2                       N3,1,3,6
N3,2,2,2                       N2,1,3,3
N2,1,1,1                       N1,2,4,1要求是用三个线程处理，读取上述俩文件内容，统计数据，写出data3.txt 内容处理统计出的数据外，附加value4，=value1/(value2+value3);我的思路是在主类设两个变量，其中一个同步的临时变量，读线程读取一行数据到临时变量中，统计线程把临时变量数据统计到目标变量中，这里的两个线程交互执行没有弄好，
求解~~~~

Answer 1

需求都描述不明白，还整多线程！
对两个文件的内容进行处理，怎么处理？name相同的进行合并？加还是减？
生成第三个文件，形式是什么样的？总共几列？每一列的值是怎么来的？

Answer 2

好吧，是我没说清楚， 需求就是 统计data1.txt 和data2.txt 的数据，Name相同的相加，value4=(value1+value2)/value3
最后 data3.txt 内容就是
Name,value1,value2,value3，value4
N1,*,*,*,*
N2,*,*,*,*
N3,*,*,*,*我想的就是 读线程每读一行数据到临时变量中，统计线程就把这一行数据统计到一个变量中，
     类似 统计线程监控 临时变量，有一条统计一条，

Answer 3

起2个线程分别去读取文件至全局变量中，同时加入value4.
第3个线程等前面2个线程读取完成后把data写进文件。

Answer 4

package test.thread;import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;/**
 * @author xujsh
 * @created 2011-8-26下午13:45:04
 */
class NameValues implements Comparable<NameValues> {
private String name;
private int value1;
private int value2;
private int value3; public NameValues(String name, int value1, int value2, int value3) {
this.name = name;
this.value1 = value1;
this.value2 = value2;
this.value3 = value3;
} public NameValues(String nameValues) {
String arr[] = nameValues.split(",");
this.name = arr[0];
this.value1 = Integer.parseInt(arr[1]);
this.value2 = Integer.parseInt(arr[2]);
this.value3 = Integer.parseInt(arr[3]);
} @Override
public boolean equals(Object obj) {
if (!(obj instanceof NameValues)) {
return false;
}
NameValues other = (NameValues) obj;
return (this.name.equals(other.name)) && (this.value1 == other.value1)
&& (this.value2 == other.value2)
&& (this.value3 == other.value3);
} @Override
public int hashCode() {
int result = 13;
result += name.hashCode() * 31;
result += value1 * 31;
result += value2 * 31;
result += value3 * 31;
return result;
}
@Override
public int compareTo(NameValues other) {
return this.name.compareTo(other.name);
}
//对两个NameValues进行相加
public NameValues add(NameValues other) {
if (this.name.equals(other.name)) {
return new NameValues(this.name, this.value1 + other.value1,
this.value2 + other.value2, this.value3 + other.value3);
} else {
return this;
}
}
@Override
public String toString() {
return "[" + name + "," + value1 + "," + value2 + "," + value3 + "]";
} public String getName() {
return name;
} public int getValue1() {
return value1;
} public int getValue2() {
return value2;
} public int getValue3() {
return value3;
} public int getValue4() {
return (value1 + value2) / value3;
}}
class ReadThread extends Thread {
private String filename;
private BlockingQueue<NameValues> queue;
private CountDownLatch latch; public ReadThread(String filename, BlockingQueue<NameValues> queue,
CountDownLatch latch) {
this.filename = filename;
this.queue = queue;
this.latch = latch;
} public void run() {
try {
BufferedReader br = new BufferedReader(new InputStreamReader(
new FileInputStream(filename)));
String line = "";
while ((line = br.readLine()) != null) {
try {
Thread.sleep(10);
} catch (Exception ex) {
ex.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ ":is putting " + new NameValues(line));
queue.put(new NameValues(line));
}
br.close();
System.out.println(Thread.currentThread().getName() + ":is over!");
latch.countDown();
} catch (Exception e) {
e.printStackTrace();
}
}
}class WriteThread extends Thread {
private String filename;
private BlockingQueue<NameValues> queue;
private CountDownLatch latch;
private OutputStream out; public WriteThread(String filename, BlockingQueue<NameValues> queue,
CountDownLatch latch) {
this.filename = filename;
this.queue = queue;
this.latch = latch;
} public void run() {
try {
//等待读文件结束
latch.await();
System.out.println("begin to write...");
if (out == null)out = new FileOutputStream(filename);
NameValues[] values = queue.toArray(new NameValues[0]);
//生成计算结果
for (int i = 0; i < values.length; i++) {
if (values[i] == null)continue;
for (int j = i + 1; j < values.length; j++) {
if (values[j] == null)continue;
if (values[i].add(values[j]) != values[i]) {
values[i] = values[i].add(values[j]);
values[j] = null;
}
}
}
//对结果进行排序
Set<NameValues> resultSet = new TreeSet<NameValues>();
for (int i = 0; i < values.length; i++) {
if (values[i] == null)continue;
resultSet.add(values[i]);
}
//输出结果
for (Iterator<NameValues> it = resultSet.iterator(); it.hasNext();) {
NameValues value = it.next();
StringBuilder sb = new StringBuilder();
sb.append(value.getName()).append(",");
sb.append(value.getValue1()).append(",");
sb.append(value.getValue2()).append(",");
sb.append(value.getValue3()).append(",");
sb.append(value.getValue4()).append("\r\n");
out.write(sb.toString().getBytes());
}
out.close();
System.out.println(Thread.currentThread().getName() + ":is over!");
} catch (Exception e) {
e.printStackTrace();
}
}
}
public class TheadTest {
public static void main(String[] args) {
//阻塞队列，允许两个线程同时往里面写数据
BlockingQueue<NameValues> queue = new LinkedBlockingQueue<NameValues>();
//两个读线程读取数据完毕以后，可以进行写文件操作
CountDownLatch latch = new CountDownLatch(2);
//读文件的线程池
ExecutorService readers = Executors.newFixedThreadPool(2);
//写文件的线程池
ExecutorService writers = Executors.newFixedThreadPool(1);
readers.execute(new ReadThread("1.txt", queue, latch));
readers.execute(new ReadThread("2.txt", queue, latch));
writers.execute(new WriteThread("3.txt", queue, latch));
//关闭线程池
readers.shutdown();
writers.shutdown();
}
}

Answer 5

运行了一下代码，也放了两个txt到相应的bin目录下了，怎么还是会报找不到文件的错误啊