Java Pooled.free方法代码示例

import org.xnio.Pooled; //导入方法依赖的package包/类
@Override
protected AbstractAjpClientStreamSourceChannel createChannel(FrameHeaderData frameHeaderData, Pooled<ByteBuffer> frameData) throws IOException {
    if (frameHeaderData instanceof SendHeadersResponse) {
        SendHeadersResponse h = (SendHeadersResponse) frameHeaderData;
        AjpClientResponseStreamSourceChannel sourceChannel = new AjpClientResponseStreamSourceChannel(this, h.headers, h.statusCode, h.reasonPhrase, frameData, (int) frameHeaderData.getFrameLength());
        this.source = sourceChannel;
        return sourceChannel;
    } else if (frameHeaderData instanceof RequestBodyChunk) {
        RequestBodyChunk r = (RequestBodyChunk) frameHeaderData;
        this.sink.chunkRequested(r.getLength());
        frameData.free();
        return null;
    } else {
        frameData.free();
        throw new RuntimeException("TODO: unknown frame");
    }

}
 

import org.xnio.Pooled; //导入方法依赖的package包/类
@Override
public void handleEvent(final StreamSourceChannel channel) {
    Pooled<ByteBuffer> resource = bufferPool.allocate();
    ByteBuffer buffer = resource.getResource();
    try {
        int r = 0;
        do {
            r = channel.read(buffer);
            if (r == 0) {
                return;
            } else if (r == -1) {
                stringDone(string.extract());
                IoUtils.safeClose(channel);
            } else {
                buffer.flip();
                string.write(buffer);
            }
        } while (r > 0);
    } catch (IOException e) {
        error(e);
    } finally {
        resource.free();
    }
}
 

import org.xnio.Pooled; //导入方法依赖的package包/类
public long transferFrom(final FileChannel src, final long position, final long count) throws IOException {
    try {
        if (state != 0) {
            final Pooled<ByteBuffer> pooled = exchange.getConnection().getBufferPool().allocate();
            ByteBuffer buffer = pooled.getResource();
            try {
                int res = src.read(buffer);
                if (res <= 0) {
                    return res;
                }
                buffer.flip();
                return write(buffer);
            } finally {
                pooled.free();
            }
        } else {
            return next.transferFrom(src, position, count);
        }
    } catch (IOException | RuntimeException e) {
        IoUtils.safeClose(exchange.getConnection());
        throw e;
    }
}
 

import org.xnio.Pooled; //导入方法依赖的package包/类
@Override
public void handle(final PartHandler handler, final ByteBuffer rawData) throws IOException {
    Pooled<ByteBuffer> resource = bufferPool.allocate();
    ByteBuffer buf = resource.getResource();
    try {
        do {
            buf.clear();
            try {
                decoder.decode(rawData, buf);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            buf.flip();
            handler.data(buf);
        } while (rawData.hasRemaining());
    } finally {
        resource.free();
    }
}
 

import org.xnio.Pooled; //导入方法依赖的package包/类
public SpdyPlainOpenListener(final Pool<ByteBuffer> pool, final Pool<ByteBuffer> heapBufferPool, final OptionMap undertowOptions) {
    this.undertowOptions = undertowOptions;
    this.bufferPool = pool;
    Pooled<ByteBuffer> buf = pool.allocate();
    this.bufferSize = buf.getResource().remaining();
    buf.free();
    this.heapBufferPool = heapBufferPool;
    Pooled<ByteBuffer> buff = heapBufferPool.allocate();
    try {
        if (!buff.getResource().hasArray()) {
            throw UndertowMessages.MESSAGES.mustProvideHeapBuffer();
        }
    } finally {
        buff.free();
    }
}
 

import org.xnio.Pooled; //导入方法依赖的package包/类
public void setup(final StreamSourceChannel channel) {
    Pooled<ByteBuffer> resource = bufferPool.allocate();
    ByteBuffer buffer = resource.getResource();
    try {
        int r = 0;
        do {
            r = channel.read(buffer);
            if (r == 0) {
                channel.getReadSetter().set(this);
                channel.resumeReads();
            } else if (r == -1) {
                stringDone(string.extract());
                IoUtils.safeClose(channel);
            } else {
                buffer.flip();
                string.write(buffer);
            }
        } while (r > 0);
    } catch (IOException e) {
        error(e);
    } finally {
        resource.free();
    }
}
 

import org.xnio.Pooled; //导入方法依赖的package包/类
/**
 * Called when data has been read from the underlying channel.
 *
 * @param headerData The frame header data. This may be null if the data is part of a an existing frame
 * @param frameData  The frame data
 */
void dataReady(FrameHeaderData headerData, Pooled<ByteBuffer> frameData) {
    if(anyAreSet(state, STATE_STREAM_BROKEN)) {
        frameData.free();
        return;
    }
    synchronized (lock) {
        boolean newData = pendingFrameData.isEmpty();
        this.pendingFrameData.add(new FrameData(headerData, frameData));
        if (newData) {
            if (waiters > 0) {
                lock.notifyAll();
            }
        }
        waitingForFrame = false;
    }
    if (anyAreSet(state, STATE_READS_RESUMED)) {
        resumeReadsInternal(true);
    }
    if(headerData != null) {
        currentStreamSize += headerData.getFrameLength();
        if(maxStreamSize > 0 && currentStreamSize > maxStreamSize) {
            handleStreamTooLarge();
        }
    }
}
 

import org.xnio.Pooled; //导入方法依赖的package包/类
@Override
public int write(final ByteBuffer src) throws IOException {
    if(toWrite >= 0 && src.remaining() > toWrite) {
        throw WebSocketMessages.MESSAGES.messageOverflow();
    }
    if(masker == null) {
        return super.write(src);
    } else {
        final Pooled<ByteBuffer> buffer = getChannel().getBufferPool().allocate();
        try {
            ByteBuffer copy = src.duplicate();
            Buffers.copy(buffer.getResource(), copy);
            buffer.getResource().flip();
            masker.beforeWrite(buffer.getResource(), 0, buffer.getResource().remaining());
            int written = super.write(buffer.getResource());
            src.position(src.position() + written);
            toWrite -= written;
            return written;
        } finally {
            buffer.free();
        }
    }
}
 

import org.xnio.Pooled; //导入方法依赖的package包/类
void startWriting() {
    Iterator<Pooled<ByteBuffer>> iterator = allocated.iterator();
    while (iterator.hasNext()) {
        Pooled<ByteBuffer> pooledBuffer = iterator.next();
        ByteBuffer byteBuffer = pooledBuffer.getResource();
        if (!byteBuffer.hasRemaining()) {
            byteBuffer.clear();
            pooledBuffer.free();
            iterator.remove();
        } else {
            break;
        }
    }
    Pooled<ByteBuffer> lastPooledBuffer = allocated.peekLast();
    if (lastPooledBuffer != null) {
        ByteBuffer lastBuffer = lastPooledBuffer.getResource();
        if (lastBuffer.limit() < lastBuffer.capacity()) {
            currentWriteBuffer = lastBuffer.compact();
        }
    }
}
 

import org.xnio.Pooled; //导入方法依赖的package包/类
public AjpOpenListener(final Pool<ByteBuffer> pool, final OptionMap undertowOptions) {
    this.undertowOptions = undertowOptions;
    this.bufferPool = pool;
    Pooled<ByteBuffer> buf = pool.allocate();
    this.bufferSize = buf.getResource().remaining();
    buf.free();
    parser = new AjpRequestParser(undertowOptions.get(URL_CHARSET, UTF_8), undertowOptions.get(DECODE_URL, true));
}
 

import org.xnio.Pooled; //导入方法依赖的package包/类
public HttpOpenListener(final Pool<ByteBuffer> pool, final OptionMap undertowOptions) {
    this.undertowOptions = undertowOptions;
    this.bufferPool = pool;
    Pooled<ByteBuffer> buf = pool.allocate();
    this.bufferSize = buf.getResource().remaining();
    buf.free();
    parser = HttpRequestParser.instance(undertowOptions);
}
 

import org.xnio.Pooled; //导入方法依赖的package包/类
public void readBlocking(StreamSourceFrameChannel channel) throws IOException {
    Pooled<ByteBuffer> pooled = channel.getWebSocketChannel().getBufferPool().allocate();
    final ByteBuffer buffer = pooled.getResource();
    try {
        for (; ; ) {
            int res = channel.read(buffer);
            if (res == -1) {
                buffer.flip();
                data.write(buffer);
                this.complete = true;
                return;
            } else if (res == 0) {
                channel.awaitReadable();
            }
            checkMaxSize(channel, res);
            if (!buffer.hasRemaining()) {
                buffer.flip();
                data.write(buffer);
                buffer.compact();
                if (!bufferFullMessage) {
                    //if we are not reading the full message we return
                    return;
                }
            }
        }
    } finally {
        pooled.free();
    }
}
 

import org.xnio.Pooled; //导入方法依赖的package包/类
/**
 * Pushes back the given data. This should only be used by transfer coding handlers that have read past
 * the end of the request when handling pipelined requests
 *
 * @param unget The buffer to push back
 */
public void ungetRequestBytes(final Pooled<ByteBuffer> unget) {
    if (getExtraBytes() == null) {
        setExtraBytes(unget);
    } else {
        Pooled<ByteBuffer> eb = getExtraBytes();
        ByteBuffer buf = eb.getResource();
        final ByteBuffer ugBuffer = unget.getResource();

        if (ugBuffer.limit() - ugBuffer.remaining() > buf.remaining()) {
            //stuff the existing data after the data we are ungetting
            ugBuffer.compact();
            ugBuffer.put(buf);
            ugBuffer.flip();
            eb.free();
            setExtraBytes(unget);
        } else {
            //TODO: this is horrible, but should not happen often
            final byte[] data = new byte[ugBuffer.remaining() + buf.remaining()];
            int first = ugBuffer.remaining();
            ugBuffer.get(data, 0, ugBuffer.remaining());
            buf.get(data, first, buf.remaining());
            eb.free();
            unget.free();
            final ByteBuffer newBuffer = ByteBuffer.wrap(data);
            setExtraBytes(new ImmediatePooled<>(newBuffer));
        }
    }
}
 

import org.xnio.Pooled; //导入方法依赖的package包/类
/**
 * Create a new {@link io.undertow.server.protocol.framed.AbstractFramedChannel}
 * 8
 *
 * @param connectedStreamChannel The {@link org.xnio.channels.ConnectedStreamChannel} over which the WebSocket Frames should get send and received.
 *                               Be aware that it already must be "upgraded".
 * @param bufferPool             The {@link org.xnio.Pool} which will be used to acquire {@link java.nio.ByteBuffer}'s from.
 * @param framePriority
 */
protected AbstractFramedChannel(final StreamConnection connectedStreamChannel, Pool<ByteBuffer> bufferPool, FramePriority<C, R, S> framePriority, final Pooled<ByteBuffer> readData) {
    this.framePriority = framePriority;
    if (readData != null) {
        if(readData.getResource().hasRemaining()) {
            this.readData = new ReferenceCountedPooled<>(readData, 1);
        } else {
            readData.free();
        }
    }
    if(bufferPool == null) {
        throw UndertowMessages.MESSAGES.argumentCannotBeNull("bufferPool");
    }
    if(connectedStreamChannel == null) {
        throw UndertowMessages.MESSAGES.argumentCannotBeNull("connectedStreamChannel");
    }
    IdleTimeoutConduit idle = createIdleTimeoutChannel(connectedStreamChannel);
    connectedStreamChannel.getSourceChannel().setConduit(idle);
    connectedStreamChannel.getSinkChannel().setConduit(idle);
    this.idleTimeoutConduit = idle;
    this.channel = connectedStreamChannel;
    this.bufferPool = bufferPool;

    closeSetter = new ChannelListener.SimpleSetter<>();
    receiveSetter = new ChannelListener.SimpleSetter<>();
    channel.getSourceChannel().getReadSetter().set(null);
    channel.getSourceChannel().suspendReads();

    channel.getSourceChannel().getReadSetter().set(new FrameReadListener());
    connectedStreamChannel.getSinkChannel().getWriteSetter().set(new FrameWriteListener());
    FrameCloseListener closeListener = new FrameCloseListener();
    connectedStreamChannel.getSinkChannel().getCloseSetter().set(closeListener);
    connectedStreamChannel.getSourceChannel().getCloseSetter().set(closeListener);
}
 

import org.xnio.Pooled; //导入方法依赖的package包/类
@Override
public long transferTo(long count, ByteBuffer throughBuffer, StreamSinkChannel target) throws IOException {
    Pooled<ByteBuffer>[] buffered = getAttachment(BUFFERED_REQUEST_DATA);
    if (buffered == null) {
        return super.transferTo(count, throughBuffer, target);
    }
    //make sure there is no garbage in throughBuffer
    throughBuffer.position(0);
    throughBuffer.limit(0);
    long copied = 0;
    for (int i = 0; i < buffered.length; ++i) {
        Pooled<ByteBuffer> pooled = buffered[i];
        if (pooled != null) {
            final ByteBuffer buf = pooled.getResource();
            if (buf.hasRemaining()) {
                int res = target.write(buf);

                if (!buf.hasRemaining()) {
                    pooled.free();
                    buffered[i] = null;
                }
                if (res == 0) {
                    return copied;
                } else {
                    copied += res;
                }
            } else {
                pooled.free();
                buffered[i] = null;
            }
        }
    }
    removeAttachment(BUFFERED_REQUEST_DATA);
    if (copied == 0) {
        return super.transferTo(count, throughBuffer, target);
    } else {
        return copied;
    }
}