Question

我正在制作一个下载管理器，我希望多个线程下载不同的文件段，一次写入不同位置的文件。只是为了每一个人的澄清，我不希望文件锁定，因为它会杀死一次写入不同线程的目的。我正在使用Apache HttpClient库和FileChannel transferFrom（）。当前代码仅下载第一个段，只是忽略其他段。

代码说明： startDownload方法创建一个新文件并检查链接是否支持部分内容，如果是，它会为每个段启动线程，否则单个线程将下载整个文件.getFileName是从URI中提取文件名的函数。 Download方法包含使用HttpClient实际下载文件的代码，然后使用transferFrom写入。

    public void startDownload() {
    Thread thread = new Thread(() -> {
        try {
            String downloadDirectory = "/home/muhammad/";
            URI uri = new URI("http://94.23.204.158/JDownloader.zip");
            int segments = 2;
            // Create a HttpClient for checking file for segmentation.
            CloseableHttpClient Checkingclient = HttpClients.createDefault();
            // get request for checking size of file.
            HttpGet checkingGet = new HttpGet(uri);
            CloseableHttpResponse checkingResponse = Checkingclient.execute(checkingGet);
            long sizeofFile = checkingResponse.getEntity().getContentLength();
            // Create a new file in downloadDirectory with name extracted from uri.
            File file = new File(downloadDirectory + getFileName(uri));
            if (!file.exists()) {
                file.createNewFile();
            }
            // set range header for checking server support for partial content.
            checkingGet.setHeader("Range", "bytes=" + 0 + "-" + 1);
            checkingResponse = Checkingclient.execute(checkingGet);
            // Check if response code is 206 (partial content response code).
            if (checkingResponse.getStatusLine().getStatusCode() == 206) {
                //find size of each segment.
                final long sizeOfEachSegment = sizeofFile / segments;
                //Download each segment independently.
                for (int i = 0; i < segments; i++) {
                    Download(i * sizeOfEachSegment, (i + 1) * sizeOfEachSegment, sizeOfEachSegment, file, uri);
                }
                // Thread used for last few Bytes and EOF.
                Download(sizeOfEachSegment * segments, sizeofFile, Long.MAX_VALUE, file, uri);
            } else {
                System.err.println("server dont support partial content");
                System.out.println(checkingResponse.getStatusLine().getStatusCode());
                // Download complete file using single thread.
                Download(0, 0, Long.MAX_VALUE, file, uri);
            }
        } catch (IOException | URISyntaxException ex) {
            Logger.getLogger(Downloader.class.getName()).log(Level.SEVERE, null, ex);
        }
    });
    thread.start();
}
public void Download(long start, long end, long sizeOfEachSegment, File file, URI uri) {
    Thread thread = new Thread(() -> {
        try {
            FileChannel fileChannel = new FileOutputStream(file).getChannel();
            CloseableHttpClient client = HttpClients.createDefault();
            HttpGet get = new HttpGet(uri);
            // Range header for defining which segment of file we want to receive.
            if (end != 0) {
                String byteRange = start + "-" + end;
                get.setHeader("Range", "bytes=" + byteRange);
            }
            CloseableHttpResponse response = client.execute(get);
            ReadableByteChannel inputChannel = Channels.newChannel(response.getEntity().getContent());
            fileChannel.transferFrom(inputChannel, start, sizeOfEachSegment);
            response.close();
            client.close();
            fileChannel.close();
        } catch (IOException | IllegalStateException exception) {
            Logger.getLogger(Downloader.class.getName()).log(Level.SEVERE, null, exception);
        }
    });
    thread.start();
}

对现有代码的一些修复可以使多个线程同时写入同一个文件而不等待会很好但我也有兴趣研究其他更有效的技术，如果他们可以完成上述任务。如果在任何情况下无需等待即可写入文件，那么任何其他有效的解决方案都会受到欢迎。在此先感谢：）

Answer 1

而不是多个线程写入同一个文件，您可以让一个线程写入该文件，多个线程生成数据但将其存储在文件编写器线程的某种缓冲区中。

Answer 2

从不同的线程写入同一个文件根本不会对你有所帮助 - 它甚至可能会严重损害吞吐量。

您应该使用一个线程写入文件并从队列中提取。

类似的东西：

class WriteBlock {
    long offset;
    byte[] data;
}
BlockingQueue<WriteBlock> writeQueue = new LinkedBlockingQueue<>();

现在每个下载线程都应该从下载中读取一个块，创建一个WriteBlock并将其发布到队列中。

与此同时，写作线程将WriteBlock从队列中吸出并尽可能快地写入。

在队列中可能有优化重新排序块（可能使用PriorityBlockingQueue）但是先用简单的方法完成。

从多个线程写入同一个文件而不锁定Java

2 个答案: