import org.apache.mina.core.write.WriteRequestQueue; //导入依赖的package包/类
private void clearWriteRequestQueue(S session, IOException ioe) {
	WriteRequestQueue writeRequestQueue = session.getWriteRequestQueue();
	WriteRequest req = session.getCurrentWriteRequest();
	if (req == null) {
		req = writeRequestQueue.poll();
		if (req == null) {
			return;
		}
	} else {
		session.setCurrentWriteRequest(null);
	}

	// Create an exception and notify.
	Throwable cause = (ioe != null ? new WriteToClosedSessionException(ioe) : new WriteToClosedSessionException());

	do {
		req.getFuture().setException(cause);

		Object message = req.getMessage();
		if (message instanceof IoBuffer) {
			((IoBuffer) message).free();
		}
	} while ((req = writeRequestQueue.poll()) != null);

	session.getFilterChain().fireExceptionCaught(cause);
}
 

import org.apache.mina.core.write.WriteRequestQueue; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
public void write(VmPipeSession session, WriteRequest writeRequest) {
    WriteRequestQueue writeRequestQueue = session.getWriteRequestQueue();

    writeRequestQueue.offer(session, writeRequest);

    if (!session.isWriteSuspended()) {
        this.flush(session);
    }
}
 

import org.apache.mina.core.write.WriteRequestQueue; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
public final WriteRequestQueue getWriteRequestQueue() {
    if (writeRequestQueue == null) {
        throw new IllegalStateException();
    }
    return writeRequestQueue;
}
 

import org.apache.mina.core.write.WriteRequestQueue; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
public void write(S session, WriteRequest writeRequest) {
    WriteRequestQueue writeRequestQueue = session.getWriteRequestQueue();

    writeRequestQueue.offer(session, writeRequest);

    if (!session.isWriteSuspended()) {
        this.flush(session);
    }
}
 

import org.apache.mina.core.write.WriteRequestQueue; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public void filterWrite(NextFilter nextFilter, IoSession session, WriteRequest writeRequest) throws Exception {

    AbstractIoSession s = (AbstractIoSession) session;

    // Maintain counters.
    if (writeRequest.getMessage() instanceof IoBuffer) {
        IoBuffer buffer = (IoBuffer) writeRequest.getMessage();
        // I/O processor implementation will call buffer.reset()
        // it after the write operation is finished, because
        // the buffer will be specified with messageSent event.
        buffer.mark();
        int remaining = buffer.remaining();

        if (remaining == 0) {
            // Zero-sized buffer means the internal message
            // delimiter.
            s.increaseScheduledWriteMessages();
        } else {
            s.increaseScheduledWriteBytes(remaining);
        }
    } else {
        s.increaseScheduledWriteMessages();
    }

    WriteRequestQueue writeRequestQueue = s.getWriteRequestQueue();

    if (!s.isWriteSuspended()) {
        if (writeRequestQueue.size() == 0) {
            // We can write directly the message
            s.getProcessor().write(s, writeRequest);
        } else {
            s.getWriteRequestQueue().offer(s, writeRequest);
            s.getProcessor().flush(s);
        }
    } else {
        s.getWriteRequestQueue().offer(s, writeRequest);
    }
}
 

import org.apache.mina.core.write.WriteRequestQueue; //导入依赖的package包/类
WriteRequestQueue getWriteRequestQueue0() {
    return super.getWriteRequestQueue();
}
 

import org.apache.mina.core.write.WriteRequestQueue; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
public CloseAwareWriteQueue(WriteRequestQueue queue) {
    this.queue = queue;
}
 

import org.apache.mina.core.write.WriteRequestQueue; //导入依赖的package包/类
public WriteRequestQueue getWriteRequestQueue(IoSession session) throws Exception {
    return new DefaultWriteRequestQueue();
}
 

import org.apache.mina.core.write.WriteRequestQueue; //导入依赖的package包/类
private boolean flush( S session, long currentTime ) throws Exception
{
    final WriteRequestQueue writeRequestQueue = session.getWriteRequestQueue();
    final int maxWrittenBytes = session.getConfig().getMaxReadBufferSize()
        + ( session.getConfig().getMaxReadBufferSize() >>> 1 );

    int writtenBytes = 0;

    try
    {
        for ( ;; )
        {
            WriteRequest req = session.getCurrentWriteRequest();

            if ( req == null )
            {
                req = writeRequestQueue.poll( session );

                if ( req == null )
                {
                    setInterestedInWrite( session, false );
                    break;
                }

                session.setCurrentWriteRequest( req );
            }

            IoBuffer buf = ( IoBuffer ) req.getMessage();

            if ( buf.remaining() == 0 )
            {
                // Clear and fire event
                session.setCurrentWriteRequest( null );
                buf.reset();
                session.getFilterChain().fireMessageSent( req );
                continue;
            }

            SocketAddress destination = req.getDestination();

            if ( destination == null )
            {
                destination = session.getRemoteAddress();
            }

            int localWrittenBytes = send( session, buf, destination );

            if ( ( localWrittenBytes == 0 ) || ( writtenBytes >= maxWrittenBytes ) )
            {
                // Kernel buffer is full or wrote too much
                setInterestedInWrite( session, true );

                return false;
            }
            else
            {
                setInterestedInWrite( session, false );

                // Clear and fire event
                session.setCurrentWriteRequest( null );
                writtenBytes += localWrittenBytes;
                buf.reset();
                session.getFilterChain().fireMessageSent( req );
            }
        }
    }
    finally
    {
        session.increaseWrittenBytes( writtenBytes, currentTime );
    }

    return true;
}
 

import org.apache.mina.core.write.WriteRequestQueue; //导入依赖的package包/类
@Override
public WriteRequestQueue getWriteRequestQueue() {
    return null;
}
 

import org.apache.mina.core.write.WriteRequestQueue; //导入依赖的package包/类
@Override
public WriteRequestQueue getWriteRequestQueue() {
	throw new UnsupportedOperationException("Not supported yet.");
}
 

import org.apache.mina.core.write.WriteRequestQueue; //导入依赖的package包/类
@Override
public WriteRequestQueue getWriteRequestQueue() {
    // TODO Auto-generated method stub
    return null;
}
 

import org.apache.mina.core.write.WriteRequestQueue; //导入依赖的package包/类
@Override
public WriteRequestQueue getWriteRequestQueue(IoSession session)
{
	_wrqCount.getAndIncrement();
	return new WriteRequestQueue()
	{
		private final ArrayDeque<WriteRequest> _wrq = new ArrayDeque<>();

		@Override
		public synchronized int size()
		{
			return _wrq.size();
		}

		@Override
		public synchronized boolean isEmpty()
		{
			return _wrq.isEmpty();
		}

		@Override
		public synchronized void clear()
		{
			_wrq.clear();
		}

		@Override
		public WriteRequest poll()
		{
			WriteRequest wr;
			synchronized(this)
			{
				wr = _wrq.pollFirst();
			}
			if(wr == AbstractIoSession.CLOSE_REQUEST)
			{
				wr = null;
				session.closeNow();
				dispose();
			}
			return wr;
		}

		@Override
		public synchronized void offer(WriteRequest writeRequest) // message must be IoBuffer or FileRegion
		{
			_wrq.addLast(writeRequest);
		}

		@Override
		public void dispose()
		{
		}

		@Override
		public synchronized String toString()
		{
			return _wrq.toString();
		}
	};
}
 

import org.apache.mina.core.write.WriteRequestQueue; //导入依赖的package包/类
@Override
public final WriteRequestQueue getWriteRequestQueue() {
	return writeRequestQueue;
}
 

import org.apache.mina.core.write.WriteRequestQueue; //导入依赖的package包/类
@Override
public WriteRequestQueue getWriteRequestQueue(IoSession session) {
	return new DefaultWriteRequestQueue(session);
}
 

import org.apache.mina.core.write.WriteRequestQueue; //导入依赖的package包/类
/**
    * @see IoSession#getWriteRequestQueue()
    */
   public WriteRequestQueue getWriteRequestQueue() {
return wrappedSession.getWriteRequestQueue();
   }
 

import org.apache.mina.core.write.WriteRequestQueue; //导入依赖的package包/类
/**
 * TODO Add method documentation
 */
WriteRequestQueue getWriteRequestQueue();
 

import org.apache.mina.core.write.WriteRequestQueue; //导入依赖的package包/类
/**
 * Create a new close aware write queue, based on the given write queue.
 *
 * @param writeRequestQueue
 *            The write request queue
 */
public final void setWriteRequestQueue(WriteRequestQueue writeRequestQueue) {
    this.writeRequestQueue = new CloseAwareWriteQueue(writeRequestQueue);
}
 

import org.apache.mina.core.write.WriteRequestQueue; //导入依赖的package包/类
/**
 * Returns an {@link WriteRequest} which is going to be associated with
 * the specified <tt>session</tt>.  Please note that the returned
 * implementation must be thread-safe and robust enough to deal
 * with various messages types (even what you didn't expect at all),
 * especially when you are going to implement a priority queue which
 * involves {@link Comparator}.
 */
WriteRequestQueue getWriteRequestQueue(IoSession session) throws Exception;
 

import org.apache.mina.core.write.WriteRequestQueue; //导入依赖的package包/类
/**
 * Get the queue that contains the message waiting for being written.
 * As the reader might not be ready, it's frequent that the messages aren't written completely,
 * or that some older messages are waiting to be written when a new message arrives.
 * This queue is used to manage the backlog of messages.
 *
 * @return The queue containing the pending messages.
 */
WriteRequestQueue getWriteRequestQueue();