Java中支持的InputStream监视标记

我试图在Java中为

InputStream

类实现自己的监视器。我使用类

FilterInputStream

只覆盖我需要在应用程序中调用的方法，避免重新实现所有内容。我想知道如何处理对

标记（int readlimit）

和

reset（）

方法的调用。下面是一个示例代码：

public class MonitoredInputStream extends FilterInputStream implements
        ProgressMonitor {

    /**
     * List of displays associated to this progress monitor
     */
    private final List<ProgressDisplay> displays = new ArrayList<ProgressDisplay>();

    private final int size;

    private int progress = 0;

    private int marked = -1;

    /**
     * Creates a monitored input stream
     * 
     * @param in
     *            the input stream
     * @throws IOException 
     */
    public MonitoredInputStream(InputStream in) throws IOException {
        super(in);
        this.size = in.available();
    }

    @Override
    public void addProgressDisplay(ProgressDisplay display) {
        int index = displays.indexOf(display);
        if (index < 0) {
            displays.add(display);
        }
    }

    @Override
    public void removeProgressDisplay(ProgressDisplay display) {
        int index = displays.indexOf(display);
        if (index > 0) {
            displays.remove(display);
        }
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.io.FilterInputStream#read()
     */
    @Override
    public int read() throws IOException {
        int read = super.read();
        updateDisplays(read);
        return read;
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.io.FilterInputStream#read(byte[], int, int)
     */
    @Override
    public int read(byte[] b, int off, int len) throws IOException {
        int read = super.read(b, off, len);
        updateDisplays(read);
        return read;
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.io.FilterInputStream#read(byte[])
     */
    @Override
    public int read(byte[] b) throws IOException {
        int read = super.read(b);
        updateDisplays(read);
        return read;
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.io.FilterInputStream#skip(long)
     */
    @Override
    public long skip(long n) throws IOException {
        long skipped = super.skip(n);
        if (skipped > Integer.MAX_VALUE) {
            skipped = Integer.MAX_VALUE;
        }
        updateDisplays((int) skipped);
        return skipped;
    }

    @Override
    public void updateDisplays(int progress) {
        addProgress(progress);
        displays.forEach(d -> d.progress(getProgress()));
    }

    /* (non-Javadoc)
     * @see java.io.FilterInputStream#mark(int)
     */
    @Override
    public synchronized void mark(int readlimit) {
        marked = 0;
        super.mark(readlimit);
    }

    /* (non-Javadoc)
     * @see java.io.FilterInputStream#reset()
     */
    @Override
    public synchronized void reset() throws IOException {
        marked = -1;
        super.reset();
    }

    private void addProgress(int prog){
        if(marked == -1){
            progress += prog;
        }else{
            marked += prog;
        }
    }

    private double getProgress() {
        int p = (marked == -1) ? progress : progress + marked;
        BigDecimal num = new BigDecimal(p);
        BigDecimal den = new BigDecimal(size);

        return num.divide(den, 10, BigDecimal.ROUND_CEILING).doubleValue();
    }
}

公共类MonitoredInputStream扩展FilterInputStream实现
进度监视器{
/**
*与此进度监视器关联的显示列表
*/
私有最终列表显示=新建ArrayList（）；
私人最终整数大小；
私有int进程=0；
私有int标记=-1；
/**
*创建受监视的输入流
* 
*@param-in
*输入流
*@抛出异常
*/
公共MonitoredInputStream（InputStream in）引发IOException{
超级(in),；
this.size=in.available（）；
}
@凌驾
public void addProgressDisplay（进程显示）{
int index=displays.indexOf（display）；
如果（指数<0）{
显示。添加（显示）；
}
}
@凌驾
public void removeProgressDisplay（进程显示）{
int index=displays.indexOf（display）；
如果（索引>0）{
显示。删除（显示）；
}
}
/*
*（非Javadoc）
* 
*@see java.io.FilterInputStream#read（）
*/
@凌驾
public int read（）引发IOException{
int read=super.read（）；
更新显示（读取）；
返回读取；
}
/*
*（非Javadoc）
* 
*@see java.io.FilterInputStream#read（字节[]，int，int）
*/
@凌驾
公共整数读取（字节[]b，整数关闭，整数长度）引发IOException{
int read=super.read（b，off，len）；
更新显示（读取）；
返回读取；
}
/*
*（非Javadoc）
* 
*@see java.io.FilterInputStream#read（字节[]）
*/
@凌驾
公共整数读取（字节[]b）引发IOException{
int read=super.read（b）；
更新显示（读取）；
返回读取；
}
/*
*（非Javadoc）
* 
*@see java.io.FilterInputStream#跳过（长）
*/
@凌驾
公共长跳过（长n）引发IOException{
长跳过=超级跳过（n）；
如果（跳过>整数最大值）{
跳过=整数最大值；
}
updateDisplays（（int）已跳过）；
返回跳过；
}
@凌驾
public void updateDisplays（整数进度）{
添加进度（进度）；
显示.forEach（d->d.progress（getProgress（））；
}
/*（非Javadoc）
*@see java.io.FilterInputStream#mark（int）
*/
@凌驾
公共同步无效标记（int readlimit）{
标记=0；
超级标记（读取限制）；
}
/*（非Javadoc）
*@see java.io.FilterInputStream#reset（）
*/
@凌驾
public synchronized void reset（）引发IOException{
标记=-1；
super.reset（）；
}
私有void addProgress（int prog）{
如果（标记==-1）{
进步+=进步；
}否则{
标记+=程序；
}
}
私有双getProgress（）{
INTP=（标记==-1）？进度：进度+标记；
BigDecimal num=新的BigDecimal（p）；
BigDecimal den=新的BigDecimal（大小）；
返回num.divide（den，10，BigDecimal.ROUND_天花板）.doubleValue（）；
}
}

我将该类与显示类结合使用，显示类基本上打印出

InputStream

报告的进度，但当我使用标记流时，它会给我带来奇怪的结果（例如负面进度或其他奇怪的行为）

任何帮助都将不胜感激

谢谢，乔瓦尼