我对 Python 还是很陌生，并且完全混淆了.join()我所读过的连接字符串的首选方法。

我试过了：

strid = repr(595)
print array.array('c',random.sample(string.ascii_letters,20 - len(strid)))
    .tostring().join(strid)

并得到类似的东西：

5wlfgALGbXOahekxSs9wlfgALGbXOahekxSs5

为什么它会这样工作？不应该595只是自动附加吗？

我正在开发android应用程序一段时间，并关注了很多关于活动生命周期和应用程序生命周期的帖子。

我知道Activity.finish()在某处调用方法Activity.onDestroy()，并从堆栈中删除活动，我猜它以某种方式指向操作系统和垃圾收集器，他可以“做他的伎俩”并在发现它的好时机释放内存所以....

这让我对这个方法到底做了什么感到有点困惑finish()。

有没有机会我会打电话finish()而onDestroy()不会被打电话？

@Override
-----------ChannelHandlerContext的write方法其实是调用的pipeline的write方法，到最后调用的是tail的write方法，
    public final ChannelFuture write(Object msg) {
        return tail.write(msg);
    }

--------------------这里根据传入的boolean值，决定是write还是writeAndflush，先看write
private void write(Object msg, boolean flush, ChannelPromise promise) {
-----------------因为这里执行的是tail的write方法， 所以要看tail的findContextOutbound的逻辑，tail这个context在初始化的时候inbound是true，但是outbound属性是false，所以要从tail往前，找outboundHandler，而head的outbound属性是true的，看它的write方
法，调用的是unsafe的write方法，是AbstractChannel的write方法。看下一段

        AbstractChannelHandlerContext next = findContextOutbound();
        final Object m = pipeline.touch(msg, next);
        EventExecutor executor = next.executor();
        if (executor.inEventLoop()) {
            if (flush) {
                next.invokeWriteAndFlush(m, promise);
            } else {
                next.invokeWrite(m, promise);
            }
        } else {
            AbstractWriteTask task;
            if (flush) {
                task = WriteAndFlushTask.newInstance(next, m, promise);
            }  else {
                task = WriteTask.newInstance(next, m, promise);
            }
            safeExecute(executor, task, promise, m);
        }
    }

@Override
-----------------unsafe的write方法
        public final void write(Object msg, ChannelPromise promise) {
            assertEventLoop();
----------------ChannelOutboundBuffer这个类，维护这一个由他自己的内部类entry组成的一个单链表，entry有着指向byteBuffer和byteBuffer数组的指针，本方法的最下面的addMessage，就是新建一个entry，然后放到链表里，ChannelOutboundBuffer自己有三个属性：
----------------flushedEntry ：指向第一个已经被flush的entry
----------------unflushedEntry ：指向第一个没有被flush的entry
----------------tailEntry ： 队尾的指针。这三个其实很简单

            ChannelOutboundBuffer outboundBuffer = this.outboundBuffer;
            if (outboundBuffer == null) {
                safeSetFailure(promise, WRITE_CLOSED_CHANNEL_EXCEPTION);
                ReferenceCountUtil.release(msg);
                return;
            }
            int size;
            try {
                msg = filterOutboundMessage(msg);
                size = pipeline.estimatorHandle().size(msg);
                if (size < 0) {
                    size = 0;
                }
            } catch (Throwable t) {
                safeSetFailure(promise, t);
                ReferenceCountUtil.release(msg);
                return;
            }
            outboundBuffer.addMessage(msg, size, promise);
        }

@Override
        public final void flush() {
            assertEventLoop();
            ChannelOutboundBuffer outboundBuffer = this.outboundBuffer;
            if (outboundBuffer == null) {
                return;
            }
------------这个方法是把flushedEntry指针置空，把unFlushedEntry指针放到队列头部
            outboundBuffer.addFlush();
------------下文
            flush0();
        }

@Override
-----------------从flush0到这一步的逻辑比较复杂，涉及到各种判断，简单起见，直接看这一步NioSocketChannel的doWriteBytes方法，netty的写，对应的是buf的readBytes，这其实只是方法名字取的问题。回忆之前的doReadBytes对应的是buf的writeBytes方法，
当时是把channel的数据读到nio的ByteBuffer中，现在应该是把byteBuffer中的数据write到channel中了,写到内核
    protected int doWriteBytes(ByteBuf buf) throws Exception {
        final int expectedWrittenBytes = buf.readableBytes();
        return buf.readBytes(javaChannel(), expectedWrittenBytes);
    }

---------------还是找到之前的那个byteBuf的实现类，可以看出，还是调用nio的socketChannel的write方法，把tmpBuf（一个Nio的ByteBuffer）写到channel中。
 private int getBytes(int index, GatheringByteChannel out, int length, boolean internal) throws IOException {
        ensureAccessible();
        if (length == 0) {
            return 0;
        }

        ByteBuffer tmpBuf;
        if (internal) {
            tmpBuf = internalNioBuffer();
        } else {
            tmpBuf = buffer.duplicate();
        }
        tmpBuf.clear().position(index).limit(index + length);
        return out.write(tmpBuf);
    }