java多线程导入excel数据

你可以使用Java中的多线程来同时读取Excel文件的多个部分，并将它们合并到一个数据结构中。以下是一个简单的Java多线程读取Excel文件的示例代码：

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;

public class ExcelReader {
    private static final int THREAD_COUNT = 4;

    public List<Data> readExcel(File file) throws IOException, InterruptedException {
        List<Data> dataList = new ArrayList<>();

        try (FileInputStream fis = new FileInputStream(file);
            HSSFWorkbook workbook = new HSSFWorkbook(fis)) {
            Sheet sheet = workbook.getSheetAt(0);
            int rowCount = sheet.getLastRowNum() - sheet.getFirstRowNum();

            if (rowCount <= THREAD_COUNT) {
                // 无需多线程
                for (int i = 1; i <= rowCount; i++) {
                    Row row = sheet.getRow(i);
                    Cell cell1 = row.getCell(0);
                    Cell cell2 = row.getCell(1);
                    Cell cell3 = row.getCell(2);
                    dataList.add(new Data(cell1.getStringCellValue(), cell2.getStringCellValue(), cell3.getStringCellValue()));
                }
            } else {
                // 多线程读取
                ExecutorService executor = Executors.newFixedThreadPool(THREAD_COUNT);
                int batchSize = rowCount / THREAD_COUNT;
                int remainCount = rowCount % THREAD_COUNT;
                int startIndex = 1;
                int endIndex = batchSize;

                for (int i = 0; i < THREAD_COUNT; i++) {
                    if (i == THREAD_COUNT - 1) {
                        endIndex += remainCount;
                    }

                    final int start = startIndex;
                    final int end = endIndex;

                    executor.execute(() -> {
                        List<Data> subList = new ArrayList<>();
                        for (int j = start; j <= end; j++) {
                            Row row = sheet.getRow(j);
                            Cell cell1 = row.getCell(0);
                            Cell cell2 = row.getCell(1);
                            Cell cell3 = row.getCell(2);
                            subList.add(new Data(cell1.getStringCellValue(), cell2.getStringCellValue(), cell3.getStringCellValue()));
                        }
                        synchronized (dataList) {
                            dataList.addAll(subList);
                        }
                    });

                    startIndex = endIndex + 1;
                    endIndex += batchSize;
                }

                executor.shutdown();
                while (!executor.isTerminated()) {
                    Thread.sleep(100);
                }
            }
        }
        return dataList;
    }

    private static class Data {
        private String field1;
        private String field2;
        private String field3;

        public Data(String field1, String field2, String field3) {
            this.field1 = field1;
            this.field2 = field2;
            this.field3 = field3;
        }
    }
}

在这个示例中，我们使用了Apache POI库来读取Excel文件。我们将文件读取分为两种情况：

- 如果行数小于或等于线程数，则不需要多线程。
- 如果行数大于线程数，则将Excel文件的行数平均分配到多个线程中。

在第二种情况下，我们使用Java ExecutorService API来创建一个线程池，并将行数分成线程数份。然后，我们使用Java lambda表达式来定义每个线程的任务，该任务将读取Excel文件的每个部分，并将其添加到一个数据列表中。最后，我们使用synchronized块来确保多个线程不会同时修改数据列表。