Tôi đã viết phần phụ trợ InputStream(和 Luồng đầu ra) để bao bọc các luồng khác và đọc trước trên một luồng nền, về cơ bản cho phép quá trình giải nén/nén xảy ra trên một luồng khác đang xử lý luồng được giải nén.

Đây là mô hình nhà sản xuất/người tiêu dùng khá chuẩn.

Đây có vẻ như là một cách đơn giản để tận dụng CPU đa lõi với quy trình đọc, xử lý và ghi dữ liệu đơn giản, cho phép sử dụng tài nguyên CPU và ổ đĩa hiệu quả hơn. Có lẽ "hiệu quả" không phải là từ phù hợp nhất, nhưng nó cũng giống như trực tiếp từ ZipĐầu VàoLuồng Đọc và viết trực tiếp Nó cung cấp mức sử dụng cao hơn so với ZipOutputStream và tôi quan tâm nhiều hơn đến thời gian chạy giảm.

Tôi rất vui khi đăng mã, nhưngCâu hỏi của tôi là tôi có đang phát minh lại thứ gì đó đã có sẵn trong thư viện hiện có (và được sử dụng thường xuyên hơn) không?

EDIT - Mã đã đăng...

我的 NềnĐầu VàoLuồng Mã như sau (NềnĐầu raLuồng Rất giống), nhưng tôi muốn cải thiện một số khía cạnh của nó.

1. Có vẻ như tôi đang làm việc quá sức để chuyển bộ đệm qua lại.
2. Nếu mã gọi loại bỏ cặp NềnĐầu VàoLuồng trích dẫn,nềnĐọcChủ đề sẽ treo mãi mãi.
3. ôi Tín hiệu cần cải thiện.
4. Các ngoại lệ nên được truyền tới luồng tiền cảnh.
5. Tôi muốn cho phép sử dụng được cung cấp Người thi hành chủ đề.
6. close() Phương thức này sẽ báo hiệu luồng nền và không được đóng luồng trình bao bọc vì luồng trình bao bọc phải được sở hữu bởi luồng nền đọc nó.
7. Làm những việc ngớ ngẩn như đọc sách sau khi đọc xong cần được quan tâm đúng mức.

gói nz.co.datcut.io;

import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
nhập java.util.concurrent.LinkedBlockingQueue;

lớp công khai BackgroundInputStream mở rộng inputStream {
    int tĩnh cuối cùng DEFAULT_QUEUE_SIZE = 1;
    int tĩnh cuối cùng DEFAULT_BUFFER_SIZE = 64*1024;
    int cuối cùng riêng tưKích thước;
    bộ đệm int cuối cùng riêng tưKích thước;
    boolean dễ bay hơi riêng tư eof = false;
    riêng tư LinkedBlockingQueue bufferQueue;
    cuối cùng riêng tư được bọcInputStream;
    byte riêng tư[] currentBuffer;
    byte dễ bay hơi riêng tư [] freeBuffer;
    vị trí int riêng tư;

    public BackgroundInputStream(InputStream bọcInputStream) {
        cái này (wrappedInputStream, DEFAULT_QUEUE_SIZE, DEFAULT_BUFFER_SIZE);
    }

    public BackgroundInputStream(InputStream được bọcInputStream,int queueSize,int bufferSize) {
        this.wrappedInputStream = bọcInputStream;
        this.queueSize = queueSize;
        this.bufferSize = bufferSize;
    }

    @Ghi đè
    public int read() ném IOException {
        if (bufferQueue == null) {
            bufferQueue = new LinkedBlockingQueue(queueSize);
            BackgroundReader nềnReader = new BackgroundReader();
            Chủ đề nềnReaderThread = Chủ đề mới (backgroundReader, "Background inputStream");
            nềnReaderThread.start();
        }
        if (currentBuffer == null) {
            thử {
                if ((!eof) || (bufferQueue.size() > 0)) {
                    currentBuffer = bufferQueue.take();
                    vị trí = 0;
                } khác {
                    return -1;
                }
            } bắt (InterruptedException e) {
                e.printStackTrace();
            }
        }
        int b = currentBuffer[pos++];
        if (pos == currentBuffer.length) {
            freeBuffer = currentBuffer;
            currentBuffer = null;
        }
        return b;
    }

    @Ghi đè
    public int available() ném IOException {
        if (currentBuffer == null) trả về 0;
        trả về currentBuffer.length;
    }

    @Ghi đè
    public void close() ném IOException {
        WrapInputStream.close();
        currentBuffer = null;
        freeBuffer = null;
    }

    lớp BackgroundReader triển khai Runnable {

        @Ghi đè
        công khai void run() {
            thử {
                trong khi (!eof) {
                    byte[] newBuffer;
                    if (freeBuffer != null) {
                        newBuffer = freeBuffer;
                        freeBuffer = null;
                    } khác {
                        newBuffer = byte mới[bufferSize];
                    }
                    int byteRead = 0;
                    int writeToBuffer = 0;
                    while (((bytesRead = WrapInputStream.read(newBuffer, writeToBuffer, bufferSize - writeToBuffer)) != -1) && (writingToBuffer < bufferSize)) {
                        writeToBuffer += byteRead;
                    }
                    if (viếtToBuffer > 0) {
                        if (writeToBuffer < bufferSize) {
                            newBuffer = Arrays.copyOf(newBuffer, writeToBuffer);
                        }
                        bufferQueue.put(newBuffer);
                    }
                    nếu (byteRead == -1) {
                        eof = đúng;
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            } bắt (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

câu trả lời hay nhất

Nghe có vẻ thú vị. Tôi chưa bao giờ thấy bất cứ thứ gì hoạt động tốt, nhưng sẽ rất có ý nghĩa nếu thử sử dụng lõi nhàn rỗi để nén nếu có.

có lẽ bạn có thể tận dụng I/O chung - Đây là một thư viện đã được thử nghiệm kỹ lưỡng, giúp giải quyết một số nội dung nhàm chán hơn, cho phép bạn tập trung vào việc mở rộng quy mô các phần song song thú vị. Có lẽ bạn thậm chí có thể đóng góp mã của mình cho dự án Commons ;-)

Về triển khai Java - nền đệm được đệm, chúng tôi đã tìm thấy một câu hỏi tương tự trên Stack Overflow: https://stackoverflow.com/questions/2153911/