如何避免制作 ByteBuffer 的防御性副本？

Question

我有一个类，它采用 ByteBuffer 作为构造函数参数。有没有办法避免制作防御性副本，以确保缓冲区不会在该点之后被修改？

ByteBuffer.isReadOnly() 不保证原始所有者不会修改缓冲区。更糟糕的是，似乎没有办法子类化 ByteBuffer。有什么想法吗？

Answer 1

正如您所说，唯一真正的方法是 buf.asReadOnlyBuffer()，然后将其传递到构造函数中。除此之外没有其他选择，尽管您可以将内容复制到新的 ByteBuffer 中，然后将其传递。

Answer 2

这是我目前能做的最好的事情：

/**
 * Helper functions for java.nio.Buffer.
 * <p/>
 * @author Gili Tzabari
 */
public final class Buffers
{
    /**
     * Returns a ByteBuffer that is identical but distinct from the original buffer.
     * <p/>
     * @param original the buffer to copy
     * @return an independent copy of original
     * @throws NullPointerException if original is null
     */
    public static ByteBuffer clone(ByteBuffer original)
    {
        Preconditions.checkNotNull(original, "original may not be null");

        ByteBuffer result = ByteBuffer.allocate(original.capacity());
        ByteBuffer source = original.duplicate();
        source.rewind();
        result.put(source);

        try
        {
            source.reset();
            result.position(source.position());
            result.mark();
        }
        catch (InvalidMarkException unused)
        {
            // Mark is unset, ignore.
        }
        result.position(original.position());
        result.limit(original.limit());
        return result;
    }

    /**
     * Returns an array representation of a buffer. The returned buffer may, or may not, be tied to
     * the underlying buffer's contents (so it should not be modified).
     * <p/>
     * @param buffer the buffer
     * @return the remaining bytes
     */
    public static byte[] toArray(ByteBuffer buffer)
    {
        if (buffer.hasArray() && !buffer.isReadOnly() && buffer.position() == 0
            && buffer.remaining() == buffer.limit())
        {
            return buffer.array();
        }
        ByteBuffer copy = buffer.duplicate();
        byte[] result = new byte[copy.remaining()];
        copy.get(result);
        return result;
    }

    /**
     * Prevent construction.
     */
    private Buffers()
    {
    }
}

我还向 Oracle 提交了功能请求： https://bugs.java.com/bugdatabase/view_bug?bug_id=7130631

Answer 3

不避免复制，但也许：

1. 的预填充池
2. 使用预分配的ByteBuffer
   作者类的构造函数允许传入的“副本”
   ByteBuffer，但让类使用池中的 ByteBuffer 进行移动
   应用程序启动/关闭的分配/释放成本。这样只需要支付内存复制成本。

Answer 4

这并不能完全回答问题，但是，对于某些用途（例如，如果您主要试图强制执行“按合同设计”），它可能足够好并且更高效。对于其他用途，它将不起作用并且效率可能会低得多。

在构造函数期间，保存 ByteBuffer 的 hashCode

Final int OriginalBBHashCode = byteBuffer.hashCode();

然后，在代码中要验证 ByteBuffer 是否未更改的几个关键位置，验证 byteBuffer.hashCode() == OriginalBBHashCode。如果不是，则抛出异常。坦率地说，我很想抛出 ConcurrentModificationException，因为这是您正在模仿的行为，但是 YMMV。