package com.jiuqi;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class ThreadTest {
final static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
public static void main(String[] args)
{
File f = new File("F://重點運營車輛軌跡入庫//track_20180806//track//2018//08//06");
// 文件總數
final List<File> filePathsList = new ArrayList<File>();
File[] filePaths = f.listFiles();
for (File s : filePaths) {
filePathsList.add(s);
}
CountDownLatch latch = new CountDownLatch(filePathsList.size());
ExecutorService pool = Executors.newFixedThreadPool(100);
BlockingQueue<Future<Map<String, FileInputStream>>> queue =
new ArrayBlockingQueue<Future<Map<String, FileInputStream>>>(100000);
System.out.println("-------------文件讀、寫任務開始時間：" + sdf.format(new Date()));
for (int i = 0; i < filePathsList.size(); i++) {
File temp = filePathsList.get(i);
Future<Map<String, FileInputStream>> future = pool.submit(new MyCallableProducer(latch, temp));
queue.add(future);
pool.execute(new CallableConsumer(queue));
}
try {
Thread.sleep(60 * 1000);
latch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("-------------文件讀、寫任務結束時間：" + sdf.format(new Date()));
pool.shutdownNow();
}
// 文件讀線程
static class MyCallableProducer implements Callable<Map<String, FileInputStream>>
{
private CountDownLatch latch;
private File file;
private FileInputStream fis = null;
private Map<String, FileInputStream> fileMap = new HashMap<String, FileInputStream>();
public MyCallableProducer(CountDownLatch latch, File file)
{
this.latch = latch;
this.file = file;
}
@Override
public Map<String, FileInputStream> call() throws Exception
{
System.out.println(Thread.currentThread().getName() + " 線程開始讀取文件 ：" + file.getName() + " ,時間爲 "+ sdf.format(new Date()));
fis = new FileInputStream(file);
// fileMap.put(file.getName(), fis);
fileMap.put(file.getPath(), fis);
doWork();
System.out.println(Thread.currentThread().getName() + " 線程讀取文件 ：" + file.getName() + " 完畢" + " ,時間爲 "+ sdf.format(new Date()));
latch.countDown();
return fileMap;
}
private void doWork()
{
int time =1000;
try {
Thread.sleep(time);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
// 文件寫線程
static class MyCallableConsumer implements Runnable
{
private String fileName = "";
private BlockingQueue<Future<Map<String, FileInputStream>>> queue;
private FileInputStream fis = null;
private File dirFile = null;
private BufferedReader br = null;
private InputStreamReader isr = null;
private FileWriter fw = null;
private BufferedWriter bw = null;
public MyCallableConsumer(BlockingQueue<Future<Map<String, FileInputStream>>> queue2)
{
this.queue = queue2;
}
@Override
public void run()
{
try {
Future<Map<String, FileInputStream>> future = queue.take();
Map<String, FileInputStream> map = future.get();
Set<String> set = map.keySet();
for (Iterator<String> iter = set.iterator(); iter.hasNext();)
{
fileName = iter.next().toString();
fis = map.get(fileName);
System.out.println(Thread.currentThread().getName() + " 線程開始寫文件 ：" + fileName + " ,時間爲 "+ sdf.format(new Date()));
try {
isr = new InputStreamReader(fis, "utf-8");
br = new BufferedReader(isr);
dirFile = new File("F:/重點運營車輛軌跡入庫" + File.separator + "track1" + File.separator + fileName);
if(!dirFile.exists()){
dirFile.createNewFile();
}
fw = new FileWriter(dirFile);
bw = new BufferedWriter(fw);
String data = "";
bw.write("+++++++++++++" + Thread.currentThread().getName() + " 線程開始寫文件++++++++++++");
while ((data = br.readLine()) != null) {
bw.write(data + "\r");
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
bw.close();
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
// 文件寫線程
static class CallableConsumer implements Runnable
{
private String fileName = "";
private BlockingQueue<Future<Map<String, FileInputStream>>> queue;
private FileInputStream fis = null;
private File dirFile = null;
private BufferedReader br = null;
private InputStreamReader isr = null;
private FileWriter fw = null;
private BufferedWriter bw = null;
public CallableConsumer(BlockingQueue<Future<Map<String, FileInputStream>>> queue2)
{
this.queue = queue2;
}
@Override
public void run()
{
try {
Future<Map<String, FileInputStream>> future = queue.take();
Map<String, FileInputStream> map = future.get();
Set<String> set = map.keySet();
for (Iterator<String> iter = set.iterator(); iter.hasNext();)
{
fileName = iter.next().toString();
fis = map.get(fileName);
System.out.println(Thread.currentThread().getName() + " 線程開始寫文件 ：" + fileName + " ,時間爲 "+ sdf.format(new Date()));
Test.readTxtFile(fileName);
}
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
}