Question

我有一个Java程序可以执行两个步骤：

使用多个线程递归读取目录中的文件（10 线程）
通过HTTP Post

似乎第一步效果很好，但第二步总是发送相同的文件10次。

如何更正此错误？

这是我的日志：

Import file: 2005_1.xml
Import file: 2005_7.xml
Import file: 2005_6.xml
Import file: 2005_10.xml
Import file: 2005_5.xml
Import file: 2005_11.xml
Import file: 2005_8.xml
Import file: 2005_2.xml
Import file: 2005_3.xml
Import file: 2005_4.xml

Result: {"fileName":"2005_4.xml"
Result: {"fileName":"2005_4.xml"
...

Response: HttpResponseProxy{HTTP/1.1 400  [
Import file: 2005_9.xml
Result: {"fileName":"2005_4.xml"
...
Response: HttpResponseProxy{HTTP/1.1 200  [
Result: {"fileName":"2005_4.xml"

Response: HttpResponseProxy{HTTP/1.1 200  [
Result: {"fileName":"2005_9.xml"

我的代码：读取具有多个线程的目录中的文件：

public void listSendFilesMultiThread(final File folder) {
        ExecutorService service = Executors.newFixedThreadPool(10, getThreadFactory());

        for (final File fileEntry : folder.listFiles()) {
            Runnable r;
            r = new Runnable() {
                @Override
                public void run() {
                    if (fileEntry.isDirectory()) {
                        listSendFilesMultiThread(fileEntry);
                    } else {
                        GetThread thread = new GetThread(fileEntry, errorFilesDestDir);

                        // start the thread
                        thread.start();

                        // join the threads
                        try {
                            thread.join();
                        } catch (InterruptedException e) {
                            LOGGER.error("InterruptedException: " + e);
                        }
                    }
                }
            };
            service.execute(r);
        }
    }

通过HTTP Post发送文件：

static class GetThread extends Thread {

        private final CloseableHttpClient closeableHttpClient;
        private final File file;
        private final String errorFilesDestDir;
        private final PoolingHttpClientConnectionManager cm;
        private MultipartEntityBuilder builder;

        public GetThread(File file, String errorFilesDestDir) {
            cm = new PoolingHttpClientConnectionManager();
            closeableHttpClient = HttpClients.custom().setConnectionManager(cm).build();

            this.file = file;
            this.errorFilesDestDir = errorFilesDestDir;
        }

        @Override
        public void run() {
            try {
                if (file.exists() && file.length() > 0) {
                    FileBody fileBody = new FileBody(file);
                    // we should create a new builder per file
                    builder = MultipartEntityBuilder.create();
                    builder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
                    builder.addPart("xmlFile", fileBody);
                    HttpEntity entity = builder.build();
                    request.setEntity(entity);

                    LOGGER.info("Import file: " + file.getName());
                    CloseableHttpResponse response = closeableHttpClient.execute(request);
                    LOGGER.info("Response: {}", response.toString());

                    try {
                        entity = response.getEntity();
                        printInfo(response, entity);
                    } finally {
                        response.close();
                        closeableHttpClient.close();
                        cm.close();
                    }

                    EntityUtils.consume(entity);
                } else if (file.length() == 0) {
                    LOGGER.error("The import XML file is empty: " + file.getAbsolutePath());
                    Files.copy(file.toPath(), new File(errorFilesDestDir + file.getName()).toPath(), StandardCopyOption.REPLACE_EXISTING);
                } else {
                    LOGGER.error("The import XML file doesn't exist");
                }
            } catch (ClientProtocolException e) {
                // Handle protocol errors
                LOGGER.error("ClientProtocolException: " + e.toString());
            } catch (IOException e) {
                // Handle I/O errors
                LOGGER.error("IOException: " + e.toString());
            }
        }
    }

连接驱逐政策

public static class IdleConnectionMonitorThread extends Thread {

        private final HttpClientConnectionManager connMgr;
        private volatile boolean shutdown;

        public IdleConnectionMonitorThread(HttpClientConnectionManager connMgr) {
            super();
            this.connMgr = connMgr;
        }

        @Override
        public void run() {
            try {
                while (!shutdown) {
                    synchronized (this) {
                        wait(5000);
                        // Close expired connections
                        connMgr.closeExpiredConnections();
                        // Optionally, close connections
                        // that have been idle longer than 30 sec
                        connMgr.closeIdleConnections(30, TimeUnit.SECONDS);
                    }
                }
            } catch (InterruptedException e) {
                LOGGER.error("InterruptedException: " + e.toString());
            }
        }

        public void shutdown() {
            shutdown = true;
            synchronized (this) {
                notifyAll();
            }
        }
    }

Answer 1

我建议使用生产者和消费者模式来简化代码。一个或多个线程（一个应该足够，因为它没有进行任何处理）将使用您的逻辑并找到要上载的文件。接下来，它会将它们放入队列中。启动任意数量的消费者，以便从队列中读取记录并将其上载到服务器。 https://dzone.com/articles/concurrency-pattern-producer 消费者将拥有从磁盘读取文件并上传到服务器的逻辑。

Answer 2

我想问题是你运行的10个线程没有任何分离排除 - 如果一个线程处理一个目录，另一个线程不应该处理同一个文件夹。这意味着他们正在做同样的工作。您应确保线程未开始处理已访问过的目录或文件。

Answer 3

您在request的{{1}}方法中使用的变量run()在其他任何地方都没有提及。因为这可能是一个内部类（由static关键字指示），我想这是包含类的某个字段，因此在所有线程之间共享。

由于对此全局变量的访问未同步，因此整个操作的结果是不可预测的。

每个线程都应该有自己的请求实例。保持对request-Object的glogal引用几乎不是一个好主意 - 它也可能导致其他问题，因为Application Containers（例如Tomcat）有时会有一些这样的对象以及底层资源（Connection Objects等）。）可能会在以后重复使用。

那就是说，在这种情况下，你很可能无论如何都是IO绑定（即受磁盘速度和上传带宽的限制，而不是处理能力）并且根本不会通过多线程获得任何东西。我会在这里使用单线程解决方案。

多个线程来读取和导入目录中的文件

3 个答案: