java多线程读取文件夹中的多个文件问题，新手多谢！
 
现在想利用多线程读取一个文件夹中的多个xml文件，但是现在每个线程都把所有文件全部读一遍，我希望的是一个线程读过的文件，其他线程就不去读了，请问我的代码错在什么地方？本人新手，多谢！
 
ps：我也试过每读一个文件就把它从列表里删除，还是不行。。
 
package comparison;
 
import java.io.BufferedReader;
 
import java.io.File;
 
import java.io.FileInputStream;
 
import java.io.FileNotFoundException;
 
import java.io.IOException;
 
import java.io.InputStream;
 
import java.io.InputStreamReader;
 
import java.io.UnsupportedEncodingException;
 
import java.util.ArrayList;
 
import java.util.List;
 
import org.jdom2.Document;
 
import org.jdom2.Element;
 
import org.jdom2.JDOMException;
 
import org.jdom2.input.SAXBuilder;
 
public class CompareTest {
 
public static void main(String args[]){
 
read read = new read();
 
new Thread(read, "线程1").start();
 
new Thread(read, "线程2").start();
 
new Thread(read, "线程3").start();
 
new Thread(read, "线程4").start();
 
new Thread(read, "线程5").start();
 
//List list = read.readXML();
 
//for(String s:list){
 
//System.out.println(s);
 
//}
 
}
 
}
 
class read implements Runnable{
 
@Override
 
public void run() {
 
File f = new File("d:"+File.separator+"comparetest");
 
File[] filePaths = f.listFiles();
 
List filePathsList = new ArrayList<>();
 
for(File s:filePaths){
 
filePathsList.add(s);
 
}
 
//解析xml
 
SAXBuilder builder = new SAXBuilder();
 
List xmlList = new ArrayList<>();
 
for(int i=0;i
 
synchronized(this){
 
try {
 
Thread.sleep(300);
 
} catch (InterruptedException e2) {
 
// TODO Auto-generated catch block
 
e2.printStackTrace();
 
}
 
try {
 
InputStream is = new FileInputStream(filePathsList.get(i));
 
System.out.println("当前使用的线程是："+Thread.currentThread().getName()+",正在读文件:"+filePathsList.get(i)+",列表当前长度:"+filePathsList.size());
 
Document doc = builder.build(is);
 
Element root = doc.getRootElement();
 
List list = root.getChildren();
 
for(Element e:list){
 
xmlList.add(e.getChildTextTrim("ERROR_FEEDBACK_ID"));
 
}
 
xmlList.add("--------------------------");
 
} catch (JDOMException | IOException e1) {
 
// TODO Auto-generated catch block
 
e1.printStackTrace();
 
}
 
}
 
}
 
}
 
//public synchronized List readXML(){
 
//
 
}
 
//return xmlList;
 
//}
 
}
 
------解决方案--------------------
 
new Thread(read, "线程1").start();
 
new Thread(read, "线程2").start();
 
new Thread(read, "线程3").start();
 
new Thread(read, "线程4").start();
 
new Thread(read, "线程5").start();
 
这几个线程执行顺序我们是无法控制的，线程并发也是无法避免的。要实现你的功能那就只有一个办法让这5个线程之间有一个共识，就是让他们都知道除他之外的线程是否已经对某个文件进行了读取操作，如果已读取就不再读了。这就要用到线程之间的通信来完在。这里最好的办法就是定义一个全局变量，当一个线程一开始读取文件就把这个文件名信息存入这个全局变量中，别的线程读取时来判断一下那文件是否己经存到了全局变量中，如果已存在就不在讯取这个文件了。大体思路是这样的。所以你这个代码就得改一下在main中建一个全局变量LIST，然后把这个LIST传进这5个线程中来达到效果，当然也可以把list设成static这个好做一些。需要注意的是在每个线程中需要给这个全局的list加上线程锁，当任意一个线程对list进行操作时，让其他线程都处理等待状态。
 
------解决方案--------------------
 
上面代码还有个小bug，如下是在你基础上进行最小改动的
 
public class CompareTest {
 
public static void main(String args[]) {
 
read read = new read();
 
new Thread(read, "线程1").start();
 
new Thread(read, "线程2").start();
 
new Thread(read, "线程3").start();
 
new Thread(read, "线程4").start();
 
new Thread(read, "线程5").start();
 
}
 
}
 
class read implements Runnable {
 
List filePathsList = new ArrayList();
 
int index = 0;
 
public read() {
 
File f = new File("d:" + File.separator + "tmp");
 
getFileList(f);
 
}
 
private void getFileList(File f) {
 
File[] filePaths = f.listFiles();
 
for (File s : filePaths) {
 
if (s.isDirectory()) {
 
getFileList(s);
 
} else {
 
if (-1 != s.getName().lastIndexOf(".xml")) {
 
filePathsList.add(s);
 
}
 
}
 
}
 
}
 
@Override
 
public void run() {
 
File file = null;
 
while (index 
 
synchronized (this) {
 
if (index >= filePathsList.size()) {
 
continue;
 
}
 
file = filePathsList.get(index);
 
index++;
 
}
 
// 解析xml
 
SAXBuilder builder = new SAXBuilder();
 
List xmlList = new ArrayList();

# -*- coding:utf-8 -*-

import pandas as pd
import os
from concurrent.futures import ThreadPoolExecutor,wait,as_completed

def get_single_data_frame(cur_path):
    return pd.read_csv(cur_path)


# 创建两个线程
def get_sample(file_dir):
    executor = ThreadPoolExecutor(max_workers=10)
    all_file_list = os.listdir(file_dir)
    data_frame_list = []
    all_task = []
    for single_file in all_file_list:
        cur_path = os.path.join(file_dir, single_file)
        if "_SUCCESS" in cur_path or "_COPYING_" in cur_path:
            continue
        try:
            task = executor.submit(get_single_data_frame, cur_path)
            #single_data_frame = executor.submit(get_single_data_frame, cur_path).result()
            #data_frame_list.append(single_data_frame)
            all_task.append(task)
        except:
            print("Error: 读取异常")
    wait(all_task)
    for future in as_completed(all_task):
        result = future.result()
        data_frame_list.append(result)
    all_data_frame = pd.concat(data_frame_list, ignore_index=True)
    return all_data_frame



print(get_sample("./test/"))

 
该楼层疑似违规已被系统折叠 隐藏此楼查看此楼
 
for(.......) {
 
new Thread(new Runnable(){
 
@Override
 
public void run() {
 
//读取文件
 
ReadUtil.read();
 
}
 
}).start();
 
}
 
//-----------读取文件的操作------------
 
public synchronized static read() {
 
File file=new File("F://info/订单信息.xls");
 
Workbook wb=null;
 
try {
 
//传入的是文件,获取工作薄
 
wb = Workbook.getWorkbook(file);
 
if(wb!=null){
 
//do .......
 
}
 
} catch (BiffException e) {
 
e.printStackTrace();
 
} catch (IOException e) {
 
e.printStackTrace();
 
}finally {
 
wb.close();
 
}
 
}
 
如果这个方法不加“同步”的话，就会报错。空指针异常是wb.close()这块。
 
我不理解的是我启动了多个线程，应该就有多个实例ReadUtils之间的读取文件应该互不干扰才对，为什么一个线程会把另一个线程的IO流给关了。。。
 
后台错误信息如下：
 
Exception in thread "Thread-1" java.lang.NullPointerException
 
at com.excle.jxl4mysql.ReadUtil.read(ReadUtil.java:122)
 
at com.excle.jxl4mysql.ReadThread$1.run(ReadThread.java:36)
 
at java.lang.Thread.run(Thread.java:619)
 
Exception in thread "Thread-2" java.lang.NullPointerException
 
at com.excle.jxl4mysql.ReadUtil.read(ReadUtil.java:122)
 
at com.excle.jxl4mysql.ReadThread$1.run(ReadThread.java:36)
 
at java.lang.Thread.run(Thread.java:619)
 
Exception in thread "Thread-5" java.lang.NullPointerException
 
at com.excle.jxl4mysql.ReadUtil.read(ReadUtil.java:122)
 
at com.excle.jxl4mysql.ReadThread$1.run(ReadThread.java:36)
 
at java.lang.Thread.run(Thread.java:619)
 
Exception in thread "Thread-8" java.lang.NullPointerException
 
at com.excle.jxl4mysql.ReadUtil.read(ReadUtil.java:122)
 
at com.excle.jxl4mysql.ReadThread$1.run(ReadThread.java:36)
 
at java.lang.Thread.run(Thread.java:619)
 
Exception in thread "Thread-7" java.lang.OutOfMemoryError: Java heap space
 
Exception in thread "Thread-6" java.lang.OutOfMemoryError: Java heap space
 
Exception in thread "Thread-3" java.lang.OutOfMemoryError: Java heap space

 
import os #目录操作
 
def writeFile():
 
fo = open("foo.txt", "a+") #打开一个文件，第二个参数为打开的模式：r 只读，r+读写 w只写 w+读写 wb二进制方式只写 a 追加
 
print ("文件名: ", fo.name)
 
print("是否已关闭 : ", fo.closed)
 
print("访问模式 : ", fo.mode)
 
fo.write("www.runoob.com!\nVery good site!")
 
fo.close() #刷新缓冲区里任何还没写入的信息，并关闭该文件，这之后便不能再进行写入
 
print("是否已关闭 : ", fo.closed)
 
def readFile():
 
fo = open("foo.txt", "r+") # 打开一个文件，第二个参数为打开的模式：r 只读，r+读写 w只写 w+读写 wb二进制方式只写 a 追加
 
print("文件名: ", fo.name)
 
print("是否已关闭 : ", fo.closed)
 
print("访问模式 : ", fo.mode)
 
str = fo.read(10);
 
print("读取的字符串是 : ", str)
 
position = fo.tell();
 
print("指针当前文件位置 : ", position)
 
# 把指针再次重新定位到文件开头
 
position = fo.seek(0,0);
 
str = fo.read(10);
 
print("重新读取字符串 : ", str)
 
fo.close() # 刷新缓冲区里任何还没写入的信息，并关闭该文件，这之后便不能再进行写入
 
print("是否已关闭 : ", fo.closed)
 
#重命名
 
def dirFile():
 
fo = open("foo.txt", "w+")#
 
fo.close() # 刷新缓冲区里任何还没写入的信息，并关闭该文件，这之后便不能再进行写入
 
print("创建文件名: ", fo.name)
 
os.rename("foo.txt","oof.txt")
 
print("修改文件名: ", fo.name)
 
os.remove("oof.txt")
 
# 创建目录test
 
#os.mkdir("test")
 
# 删除”/tmp/test”目录
 
#os.rmdir("/tmp/test")
 
# 给出当前的目录
 
print(os.getcwd())
 
线程
 
import time, threading
 
def threadtest():
 
thread1 = threading.Thread(target=printtime,args=("t1",2));
 
thread2 = threading.Thread(target=printtime, args=("t2", 4));
 
thread1.start()
 
thread2.start()
 
def printtime(threadname,delay):
 
count=0
 
while count<5:
 
time.sleep(delay)
 
count += 1
 
print(threadname+":",time.strftime("%a %b %d %H:%M:%S %Y",time.localtime()))
 
线程同步
 
如果多个线程共同对某个数据修改，则可能出现不可预料的结果，为了保证数据的正确性，需要对多个线程进行同步。
 
使用Thread对象的Lock和Rlock可以实现简单的线程同步，这两个对象都有acquire方法和release方法，对于那些需要每次只允许一个线程操作的数据，可以将其操作放到acquire和release方法之间。
 
import time, threading
 
class myThread (threading.Thread):
 
def __init__(self, threadID, name, counter):
 
threading.Thread.__init__(self)
 
self.threadID = threadID
 
self.name = name
 
self.counter = counter
 
def run(self):
 
print("Starting " + self.name)
 
# 获得锁，成功获得锁定后返回True
 
# 可选的timeout参数不填时将一直阻塞直到获得锁定
 
# 否则超时后将返回False
 
threadLock.acquire()
 
print_time(self.name, self.counter, 3)
 
# 释放锁
 
threadLock.release()
 
def print_time(threadName, delay, counter):
 
while counter:
 
time.sleep(delay)
 
print("%s: %s" % (threadName, time.ctime(time.time())))
 
counter -= 1
 
threadLock = threading.Lock()
 
threads = []
 
# 创建新线程
 
thread1 = myThread(1, "Thread-1", 1)
 
thread2 = myThread(2, "Thread-2", 2)
 
# 开启新线程
 
thread1.start()
 
thread2.start()
 
# 添加线程到线程列表
 
threads.append(thread1)
 
threads.append(thread2)
 
# 等待所有线程完成
 
for t in threads:
 
t.join() # 等待至线程中止。这阻塞调用线程直至线程的join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生
 
print("Exiting Main Thread")