Xiao_Mai
Xiao_Mai

Handler 消息机制

Handler 消息机制是由 Message MessageQueue Handler Looper 共同完成的。

你还在为开发中频繁切换环境打包而烦恼吗？快来试试 Environment Switcher 吧！使用它可以在app运行时一键切换环境，而且还支持其他贴心小功能，有了它妈妈再也不用担心频繁环境切换了。https://github.com/CodeXiaoMai/EnvironmentSwitcher

Handler 消息机制是用于在同一个进程中的多个线程之间进行通信的。由于工作线程与主线程共享地址空间，即 Handler 实例对象 mHandler 位于线程间共享的内存堆上，所以工作线程与主线程都能直接使用该对象，只需要注意多线程的同步问题。工作线程通过 mHandler 向其成员变量 MessageQueue 中添加新 Message，主线程一直处于 loop() 方法中，当收到新的 Message 时按照一定规则分发给相应的 handleMessage() 方法来处理。所以说，Handler 消息机制用于同进程的线程间通信的核心是线程间共享内存空间，而不同进程拥有不同的地址空间，也就不能用 Handler 来实现进程间通信。

既然是用来通信的消息机制，那用什么来通信呢？当然是 Message，下面就先介绍一下 Message。

Message

Message 默认提供了两个 int 属性和一个 object 属性，能够满足我们大多数情况的需求。

关于 Message 主要需要注意的是，怎样正确的创建一个 Message 对象？尽管 Message 的构造函数是公共的，但是最好的方法（效率高，避免重复创建对象）却是通过调用 Message.obtain() 或者 Handler.obtainMessage() 方法，从消息池中回收的 Message 中获取。

Message next;
private static Message sPool;
private static int sPoolSize = 0;
private static final int MAX_POOL_SIZE = 50;

上面几个属性是 Message 中声明的，每个 Message 对象都可以通过为 next 属性赋值，添加一个后继元素，这样多个 Message 对象就组成了一个单链表；而 sPool 就是链表的表头位置的 Message 对象，也就是头指针。此外我们还可以了解到这个链表的最大长度为 50。

那么这个链表有什么用呢？

答案就是用来保存已经用过的 Message，这个保存是通过 recyclerUnchecked() 方法实现的，而且这个机制是在 Looper 中消息被处理完成之后触发的。

public void recycle() {
    if (isInUse()) {
        if (gCheckRecycle) {
            throw new IllegalStateException("This message cannot be recycled because it "
                    + "is still in use.");
        }
        return;
    }
    recycleUnchecked();
}

void recycleUnchecked() {
    flags = FLAG_IN_USE;
    // 将所有数据清空
    what = 0;
    arg1 = 0;
    arg2 = 0;
    obj = null;
    replyTo = null;
    sendingUid = -1;
    when = 0;
    target = null;
    callback = null;
    data = null;
    synchronized (sPoolSync) {
        if (sPoolSize < MAX_POOL_SIZE) {
            // 如果当前消息池未满就把 Message 插入到消息池的头部
            next = sPool;
            sPool = this;
            sPoolSize++;
        }
    }
}

现在明白了消息池中的消息是怎么来的，再来看 obtain() 这个方法是怎么从消息池中取出消息的。

public static Message obtain() {
    synchronized (sPoolSync) {
        if (sPool != null) {
            // 如果消息池的第一个消息 sPool 不为null，也就意味着消息池中有消息，就将它从消息池中取出来。
            Message m = sPool;
            // 将 sPool 改为消息池的第二个消息
            sPool = m.next;
            m.next = null;
            m.flags = 0; // clear in-use flag
            sPoolSize--;
            return m;
        }
    }
    // 如果消息池中没有 Message，就创建新的 Message。
    return new Message();
}

现在已经通过正确的方式得到了一个 Message 对象实例，那么我们发送的消息在哪保存呢？下面就到了 MessageQueue 出场了。

MessageQueue

MessageQueue 的构造方法：

// True if the message queue can be quit.
private final boolean mQuitAllowed;

MessageQueue(boolean quitAllowed) {
    mQuitAllowed = quitAllowed;
    mPtr = nativeInit();
}

mQuitAllowed 用来标记这个消息队列是否可以退出，事实也证明这个变量只在 quit() 方法中用到了，主线程是不可以退出的。我们创建的 MessageQueue 都是可以退出的，严格来说是必需退出的。因为这个 MessageQueue 是在 Looper 中创建的，而且创建时也确实是传入的 true，后面在 Looper 中会介绍。

MessageQueue 的两大主要作用就是：

  • 保存消息：boolean enqueueMessage(Message msg, log when)
  • 取出消息：Message next()

enqueueuMessage()

boolean enqueueMessage(Message msg, long when) {
    if (msg.target == null) {
        throw new IllegalArgumentException("Message must have a target.");
    }
    if (msg.isInUse()) {
        throw new IllegalStateException(msg + " This message is already in use.");
    }
    synchronized (this) {
        if (mQuitting) {
            IllegalStateException e = new IllegalStateException(
                    msg.target + " sending message to a Handler on a dead thread");
            Log.w(TAG, e.getMessage(), e);
            msg.recycle();
            return false;
        }
        msg.markInUse();
        msg.when = when;
        // mMessages 代表链表头结点的消息
        Message p = mMessages;
        boolean needWake;
        if (p == null || when == 0 || when < p.when) {
            // 如果 p 为 null 表示 MessageQueue 中没有消息，如果 when = 0 或者触发时间比链表头结点的消息时间还早，就直接插入链表头部 
            // New head, wake up the event queue if blocked.
            msg.next = p;
            mMessages = msg;
            needWake = mBlocked;
        } else {
            needWake = mBlocked && p.target == null && msg.isAsynchronous();
            Message prev;
            for (;;) {
                // 要插入 msg 的前驱元素
                prev = p;
                // 要插入 msg 的后继元素
                p = p.next;
                if (p == null || when < p.when) {
                    // p 为 null 表示到达链表末尾，when < p.when 表示新 msg 的触发时间比 p 的早，插入到它的前面就行了。
                    break;
                }
                if (needWake && p.isAsynchronous()) {
                    needWake = false;
                }
            }
            msg.next = p; // invariant: p == prev.next
            prev.next = msg;
        }
        // We can assume mPtr != 0 because mQuitting is false.
        if (needWake) {
            nativeWake(mPtr);
        }
    }
    return true;
}

可以看出，MessageQueue 是将每个 Message 按照 when(触发时间)进行排列，并存储到链表中，当有新的 Message 需要添加时，从链表的第一个 Message 开始循环遍历，直到新 Message 的 when 比当前遍历到的 Message 的 when 要早，就把新 Message 插入到当前遍历到的 Message 之前，如果没有遍历到，就将新的 Message 插入到链表尾部。

next()

主要是从 MessageQueue 中取出头部的消息，具体细节都是涉及到数据结构的操作。

removeMessages()

Handler 中提供了几个 removeMessages() 和 removeCallbacks() 以及 removeCallbacksAndMessages() 方法，最终都是调用内部的 messageQueue 的 removeMessages() 方法，将消息从 MessageQueue 中移除。

现在 Message 和保存 Message 的 MessageQueue 都了解了，可谓是万事具备只欠东风了，下面开始发射。。。

Handler

Handler 允许我们发送和处理与当前线程关联的 MessageQueue 中的 Message 对象。每个 Handler 实例都与单个线程以及该线程的消息队列相关联。当创建一个新的 Handler 时，它绑定到创建它的线程和线程的消息队列上。这样，它就可以将消息传递到消息队列，并在消息从队列出来时执行它们。

当应用程序创建一个进程时，其主线程将专门运行一个消息队列，负责管理顶层应用程序对象（activities， broadcast receivers 等）以及它们创建的任何窗口。我们可以创建自己的线程，并通过 Handler 的 post 或 sendMessage 方法与应用程序主线程进行通信，然后 Message 将在 Handler 的 MessageQueue 中进行调度，并在适当的时候进行处理。

要使用 Handler，首先要获取到 Handler 的实例，因为它没有提供静态的创建实例的方法，所以我们只能通过它的构造方法创建。Handler 提供了很多构造方法，主要分为两大类：

第一类构造方法

public Handler() {
    this(null, false);
}

public Handler(Callback callback) {
    this(callback, false);
}

public Handler(boolean async) {
    this(null, async);
}

public Handler(Callback callback, boolean async) {
    if (FIND_POTENTIAL_LEAKS) {
        // 匿名类、内部类或本地类都必须申明为static，否则会警告可能出现内存泄露
        final Class klass = getClass();
        if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
                (klass.getModifiers() & Modifier.STATIC) == 0) {
            Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
                klass.getCanonicalName());
        }
    }
    mLooper = Looper.myLooper();
    if (mLooper == null) {
        throw new RuntimeException(
            "Can't create handler inside thread that has not called Looper.prepare()");
    }
    mQueue = mLooper.mQueue;
    mCallback = callback;
    mAsynchronous = async;
}

第一类构造方法，都是默认使用当前线程的 Looper 与 Handler 相关联，并且可以设置回调和是否为异步。Ok，既然有了构造方法，我们就可以使用它了。于是我们就这样创建一个 Handler 对象。

public class SampleActivity extends Activity {

  private Handler mHandler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
      // ... 
    }
  }
}

没问题吧，但是会发现 Android Studio 会发出如下警告：

This Handler class should be static or leaks might occur (anonymous android.os.Handler).
Since this Handler is declared as an inner class, it may prevent the outer class from being garbage collected. If the Handler is using a Looper or MessageQueue for a thread other than the main thread, then there is no issue. If the Handler is using the Looper or MessageQueue of the main thread, you need to fix your Handler declaration, as follows: Declare the Handler as a static class; In the outer class, instantiate a WeakReference to the outer class and pass this object to your Handler when you instantiate the Handler; Make all references to members of the outer class using the WeakReference object.

巴拉巴拉一大堆，其实就是告诉我们这样创建 Handler 可能会发生内存泄漏。因为在 Java 中，非静态内部类或匿名类会持有其外部类的引用，导致即使外部类不再使用也不能被垃圾回收机制回收。如果 Handler 是在非主线程中使用 Looper 或 MessageQueue，则没有问题（不明白为什么，虽然非主线程的 Loop 在 MessageQueue 中没有消息后就会退出 loop() 方法，但消息没有处理的时候还是会持有 Activity 的引用啊）。如果 Handler 在使用主线程（主线程的 loop() 方法不会退出）的 Looper 或 MessageQueue，则需要将 Handler 声明为静态类; 在外部类中，实例化 WeakReference 到外部类，并在实例化 Handler 时将此对象传递给Handler; 使用WeakReference对象来引用外部类的所有成员。

我们再来捋一遍发生内存泄漏的原因：我们发送的 Message 对象持有 Activity 中的 Handler 的引用，Handler 又隐式的持有它的外部类(也就是 Activity )的引用。而这个引用会一直存在，直到这个消息被处理，所以垃圾回收机制就没法回收这个 Activity，内存泄露就发生了。

因此创建 Handler 的正确姿势如下：

public class SampleActivity extends Activity {

    private static class MyHandler extends Handler {

        private WeakReference activityWeakReference;

        private MyHandler(SampleActivity activity) {
            activityWeakReference = new WeakReference<>(activity);
        }

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            SampleActivity sampleActivity = activityWeakReference.get();
            if (sampleActivity != null) {
                sampleActivity.handleMessage(msg);
            }
        }
    }

    private MyHandler mHandler = new MyHandler(SampleActivity.this);

    private void handlerMessage(Message msg) {
        // 处理消息
    }
}

第二类构造方法

public Handler(Looper looper) {
    this(looper, null, false);
}

public Handler(Looper looper, Callback callback) {
    this(looper, callback, false);
}

public Handler(Looper looper, Callback callback, boolean async) {
    mLooper = looper;
    mQueue = looper.mQueue;
    mCallback = callback;
    mAsynchronous = async;
}

第二类构造方法可以设置指定的 Looper 与 Handler 相关联，当然同样可以设置回调和是否为异步。

现在我们已经创建了 Handler 的实例，接下来就可以用它来发送消息了。

Handler 发送消息主要分为两大类：

  • Message 类型的消息
  • Runnable 类型的消息（最终还是转换为 Message 类型的消息）

sendMessage

public final boolean sendEmptyMessage(int what){
    return sendEmptyMessageDelayed(what, 0);
}

public final boolean sendMessage(Message msg){
    return sendMessageDelayed(msg, 0);
}

public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
    Message msg = Message.obtain();
    msg.what = what;
    return sendMessageDelayed(msg, delayMillis);
}

public final boolean sendMessageDelayed(Message msg, long delayMillis){
    if (delayMillis < 0) {
        delayMillis = 0;
    }
    return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}

public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
    MessageQueue queue = mQueue;
    if (queue == null) {
        RuntimeException e = new RuntimeException(
                this + " sendMessageAtTime() called with no mQueue");
        Log.w("Looper", e.getMessage(), e);
        return false;
    }
    return enqueueMessage(queue, msg, uptimeMillis);
}

public final boolean sendMessageAtFrontOfQueue(Message msg) {
    MessageQueue queue = mQueue;
    if (queue == null) {
        RuntimeException e = new RuntimeException(
            this + " sendMessageAtTime() called with no mQueue");
        Log.w("Looper", e.getMessage(), e);
        return false;
    }
    return enqueueMessage(queue, msg, 0);
}

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
    msg.target = this;
    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    return queue.enqueueMessage(msg, uptimeMillis);
}

对比上面几个方法后可以发现无论是以何种方式发送消息，最终都是调用 enqueueMessage() 方法将 Message 保存到当前 Handler 的 MessageQueue 中。

那么 post() 方法呢？

post()

public final boolean post(Runnable r){
   return  sendMessageDelayed(getPostMessage(r), 0);
}

public final boolean postAtTime(Runnable r, long uptimeMillis){
    return sendMessageAtTime(getPostMessage(r), uptimeMillis);
}

public final boolean postAtTime(Runnable r, Object token, long uptimeMillis){
    return sendMessageAtTime(getPostMessage(r, token), uptimeMillis);
}

public final boolean postDelayed(Runnable r, long delayMillis){
    return sendMessageDelayed(getPostMessage(r), delayMillis);
}

public final boolean postAtFrontOfQueue(Runnable r){
    return sendMessageAtFrontOfQueue(getPostMessage(r));
}

private static Message getPostMessage(Runnable r) {
    Message m = Message.obtain();
    m.callback = r;
    return m;
}

private static Message getPostMessage(Runnable r, Object token){
    Message m = Message.obtain();
    m.obj = token;
    m.callback = r;
    return m;
}

我们也可以看到，只是将 runnable 作为 message.callback，其实还是先调用与之对应的 senMessageXXX()方法，最终调用 enqueueMessage() 方法。

dispatchMessage

消息发送后，会进入当前 Handler 的 MessageQueue 中，而 Handler 持有的 MessageQueue 其实就是与当前线程相关联的 Looper 持有的 MessageQueue，Looper 的 loop() 方法，会不断的从 MessageQueue 中取出消息进行分发，这个分发机制就是通过调用 Message 中的 target (其实就是Handler) 的 dispatchMessage() 方法实现的。

Looper.java

public static void loop() {
    ...
    msg.target.dispatchMessage(msg);
    ...
}

Message.java

/*package*/ Handler target;

Handler.java

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
    msg.target = this;
    ...
}

通过上面几段代码可以看出，msg.target 就是一个 Handler 对象，而这个 target 是在 enqueueMessage() 方法中被赋值的，而且这个值就是 Handler 实例本身。下面就可以看 Handler 的 dispatchMessage() 方法了。

Handler.java

public void dispatchMessage(Message msg) {
    if (msg.callback != null) {
        // 如果 message 设置了 callback，也就是 runnable 消息，调用 callback.run()方法。
        // 源代码为 handleCallback(msg)；实际上 handleCallback(msg) 的具体实现就是下面这行代码。
        msg.callback.run();
    } else {
        // 如果 handler 设置了 callback，执行 callback 回调。
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        // 这个方法默认是空的，需要重写该方法来处理消息。
        handleMessage(msg);
    }
}

从 dispatchMessage 发放中，还可以看出消息分发是有三个级别的：

  1. Message 的回调方法 callback 不为空时，则回调方法 msg.callback.run()
  2. Handler 的 mCallback 成员变量不为空时，则回调方法 mCallback.handleMessage(msg)
  3. Handler 自身的回调方法 handleMessage()，该方法默认为空，我们可以通过重写该方法来完成具体的逻辑。

现在消息也已经发送了，剩下的就交给 Looper 来处理了。

Looper

Looper 是用于一个线程运行消息循环的类。每个线程默认情况下没有与它相关联的消息循环，可以通过调用 Looper.prepare() 方法创建，创建完成后调用Lopper.loop()方法开始循环处理消息。

Looper.prepare()

上面已经提过了，可以通过调用 Looper.prepare() 方法创建 Looper 的实例与一个线程相关联，那就先看看这个方法。

Looper提供了两个prepare()方法：

public static void prepare() {
    prepare(true);
}

private static void prepare(boolean quitAllowed) {
    if (sThreadLocal.get() != null) {
        throw new RuntimeException("Only one Looper may be created per thread");
    }
    sThreadLocal.set(new Looper(quitAllowed));
}

我们只能调用无参的 prepare()方法（有参的方法是私有的），而且无参的方法内部也是调用有参的方法，并传入参数 true，表示允许退出，false 表示不允许退出。而直接调用这个私有的构造方法，并传入 false 的地方只有一个，那主是 prepareMainLooper() 方法：

/**
 * Initialize the current thread as a looper, marking it as an
 * application's main looper. The main looper for your application
 * is created by the Android environment, so you should never need
 * to call this function yourself.  See also: {@link #prepare()}
 */
public static void prepareMainLooper() {
    prepare(false);
    synchronized (Looper.class) {
        if (sMainLooper != null) {
            throw new IllegalStateException("The main Looper has already been prepared.");
        }
        sMainLooper = myLooper();
    }
}

从注释中也可以看出，这个方法是创建 Application 的主 Looper，由Android系统调用（ActivityThread.main()和SystemServer.run()），我们不能调用这个方法。

ThreadLocal

再回到prepare()方法，第一行中的 sThreadLocal 是什么？

// sThreadLocal.get() will return null unless you've called prepare().
static final ThreadLocal sThreadLocal = new ThreadLocal();

private static void prepare(boolean quitAllowed) {
    if (sThreadLocal.get() != null) {
        throw new RuntimeException("Only one Looper may be created per thread");
    }
    sThreadLocal.set(new Looper(quitAllowed));
}

可以看到 sThreadLocal 是一个 ThreadLocal 类型的静态变量。

什么是 ThreadLocal 呢?

ThreadLocal 是一个用于创建线程局部变量的类。

线程局部变量又是什么呢？

通常情况下，我们创建的变量是可以被任何一个线程访问并修改的。而使用 ThreadLocal 创建的变量只能被当前线程访问，其他线程则无法访问和修改，这就是线程局部变量。

ThreadLocal的特点：

  • Global：在当前线程中，任何地方都可以访问到 ThreadLocal 的值。
  • Local：该线程的 ThreadLocal 的值只能被该线程自己访问和修改，一般情况下 其他线程访问不到。

下面是通过在主线程中创建 ThreadLocal 实例并为其赋值，然后测试子线程能否成功访问的示例：

public static void main(String[] args) {
    final ThreadLocal threadLocal = new ThreadLocal<>();
    threadLocal.set("hello");
    String s = threadLocal.get();
    System.out.printf("当前线程 %s %s\n", Thread.currentThread().getName(), s);
    new Thread() {
        @Override
        public void run() {
            super.run();
            String s = threadLocal.get();
            System.out.printf("当前线程 %s %s\n", Thread.currentThread().getName(), s);
        }
    }.start();
}

打印结果：

当前线程 main hello
当前线程 Thread-0 null

从上面的输出可以证明：在主线程创建的 ThreadLocal 可以在主线程中获取到它的值，而在子线程中，就不能获取到了。

上面说一般情况下 ThreadLocal 的值只能被当前线程访问，那么当然就存在特殊情况了，我们可以使用 ThreadLocal 的子类 InheritableThreadLocal 实现在子线程中访问主线程中创建的值。

final ThreadLocal threadLocal = new InheritableThreadLocal<>();
threadLocal.set("hello");
System.out.printf("当前线程 %s %s\n", Thread.currentThread().getName(), threadLocal.get());
new Thread() {
    @Override
    public void run() {
        super.run();
        System.out.printf("当前线程 %s %s\n", Thread.currentThread().getName(), threadLocal.get());
    }
}.start();

打印结果：

当前线程 main hello
当前线程 Thread-0 hello

结果确实是主线程和子线程都可以访问。

ThreadLocal 怎样实现线程局部变量

我们使用 ThreadLocal 的目的就是通过它的线程局部变量这个特性，保证数据不能被其他线程访问和修改。

这里既然关系到数据的访问与修改，那么必然就联系到了 ThreadLocal 内部的 set() 和 get() 方法了。

ThreadLocal.java

/**
 * Sets the current thread's copy of this thread-local variable
 * to the specified value.  Most subclasses will have no need to
 * override this method, relying solely on the {@link #initialValue}
 * method to set the values of thread-locals.
 *
 * @param value the value to be stored in the current thread's copy of
 *        this thread-local.
 */
public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

/**
 * Returns the value in the current thread's copy of this
 * thread-local variable.  If the variable has no value for the
 * current thread, it is first initialized to the value returned
 * by an invocation of the {@link #initialValue} method.
 *
 * @return the current thread's value of this thread-local
 */
public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null)
            return (T)e.value;
    }
    return setInitialValue();
}

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

Thread.java

/* ThreadLocal values pertaining to this thread. This map is maintained
 * by the ThreadLocal class. 
 */
ThreadLocal.ThreadLocalMap threadLocals = null;

通过 set() 和 get() 方法的前两行代码，可以看到它们都是首先获取当前线程的实例，然后再获取当前线程的 threadLocals 属性，最后才去对这个 threadLocals 进行赋值或取值操作。这样就保证了每个线程操作的只是它自己的 threadLocals，从而实现线程局部变量的效果。

Looper 的构造方法

现在已经明白了 ThreadLocal 的实现原理，再次回到 prepare() 方法。

private static void prepare(boolean quitAllowed) {
    if (sThreadLocal.get() != null) {
        throw new RuntimeException("Only one Looper may be created per thread");
    }
    sThreadLocal.set(new Looper(quitAllowed));
}

当我们第一次调用 sThreadLocal.get() 方法时，得到的肯定是 null，所以就向 sThreadLocal 中赋值一个 Looper 对象。

下面看一下 Looper 的构造方法：

final MessageQueue mQueue;
final Thread mThread;

private Looper(boolean quitAllowed) {
    mQueue = new MessageQueue(quitAllowed);
    mThread = Thread.currentThread();
}

在构造方法中可以看到，分别为 mQueue 和 mThread 赋值，而且 quitAllowed 也传递给 MessageQueue 的构造方法，还记得前面在 MessageQueue 中已经介绍过了吗？而且我们创建的 MessageQueue 都是必须退出的，只有主线程才不可以也不能退出。

其实 Looper 只有这一个私有的构造方法，这再一次证明我们不能直接创建 Looper 的实例，而是应该通过调用 Looper.prepare() 方法创建。

到此为止，我们通过调用 Looper.prepare() 方法已经创建了一个与当前线程绑定，并通过 ThreadLocal 保证每个线程只有一个的 Looper 实例，同时这个 Looper 实例持有一个 MessageQueue 对象实例。

Looper.loop()

现在有了 MessageQueue 的实例，我们就可以调用 Looper.loop() 循环处理消息了。

下面是精简过的 loop() 方法：

/**
 * Run the message queue in this thread. Be sure to call
 * {@link #quit()} to end the loop.
 */
public static void loop() {
    final Looper me = myLooper();
    if (me == null) {
        throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
    }
    final MessageQueue queue = me.mQueue;
    for (;;) {
        Message msg = queue.next(); // might block
        if (msg == null) {
            // No message indicates that the message queue is quitting.
            return;
        }
        try {
            msg.target.dispatchMessage(msg);
        } finally {
            if (traceTag != 0) {
                Trace.traceEnd(traceTag);
            }
        }
        msg.recycleUnchecked();
    }
}

public static @Nullable Looper myLooper() {
    return sThreadLocal.get();
}

首先从 sThreadLocal 中获取当前线程唯一的 Looper 实例 me，然后得到这个 Looper 实例的 MessageQueue 实例，接着就开始无限循环处理消息了。每当得到一个 Message 实例，只要不为空就调用 msg.target.dispatchMessage(msg) 开始分发消息。

总结

  • 创建一个 Message 的正确方式是：Message.obtain() 或 Handler.obtain()
  • 创建 Handler 时要注意避免内存泄漏
  • Looper 的 prepare() 方法，将 Looper 实例与当前线程绑定，通过 ThreadLocal 保证每个线程只有一个 Looper 实例，同时一个 Looper 实例也只有一个 MessageQueue 实例.
  • Looper 的 loop() 方法，不断从 MessageQueue 中取出 message 对象，并调用 message.target.dispatchMessage() 方法分发处理。

附

如果上面的内容都理解了，就通过下面这个问题检测一下吧！

我们平时都是使用 Handler 在子线程发送消息、主线程中接收与处理消息，那么 Handler 可以在主线程中发送消息，在子线程中接收与处理消息吗？如果可以怎么实现呢？

答案是可以的。因为我们通过 Handler 发送的 Message，都会保存到与它相关联的 Looper 的 MessageQueue 中，Looper 的 loop() 方法会不断循环取出 MessageQueue 中的 Message 并调用 message.target.dispatchMessage() 方法进行分发处理。

还记得 Handler 怎么与 Looper 关联，Looper 又是怎样与线程关联的吗？再来回顾一下。

Handler 除了可以与创建它的线程相关联的 Looper 相关联外，还可以与指定的 Looper 相关联，因此我们可以直接指定子线程的Looper 与 Handler 关联。但是，因为每个线程默认情况下没有与它相关联的 Looper，所以需要在子线程中先调用 Looper.prepare() 方法将 Looper 与子线程关联，创建完成后就可以调用Lopper.loop()方法开始循环处理消息了。

下面是详细代码：

public class SampleActivity extends Activity {

    private static class MyThread extends Thread {

        private WeakReference activityWeakReference;
        private MyHandler mHandler;

        private MyThread(SampleActivity activity) {
            activityWeakReference = new WeakReference<>(activity);
        }

        @Override
        public void run() {
            super.run();
            
            Looper.prepare();

            SampleActivity sampleActivity = activityWeakReference.get();
            if (sampleActivity != null) {
                mHandler = new MyHandler(sampleActivity);
            }

            Looper.loop();
        }
    }

    private static class MyHandler extends Handler {

        private WeakReference activityWeakReference;

        private MyHandler(SampleActivity activity) {
            activityWeakReference = new WeakReference<>(activity);
        }

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);

            SampleActivity sampleActivity = activityWeakReference.get();
            if (sampleActivity != null) {
                sampleActivity.handleMessage(msg);
            }
        }
    }

    private void handleMessage(Message message) {
        Log.e("handlerMessage", "currentThread:" + Thread.currentThread().getName() + "message.what:" + message.what);
    }

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        Log.e("onCreate", "currentThread:" + Thread.currentThread().getName());
        // 创建子线程
        final MyThread myThread = new MyThread(this);
        // 开启子线程接收消息
        myThread.start();

        // 创建一个发送消息的线程
        new Thread() {
            @Override
            public void run() {
                super.run();

                while (true) {
                    SystemClock.sleep(3000);
                    myThread.mHandler.sendEmptyMessage(new Random().nextInt(10));
                }
            }
        }.start();
    }
}

打印结果：

E/onCreate: currentThread:main
E/handleMessage: currentThread:Thread-9430,message.what:9
E/handleMessage: currentThread:Thread-9430,message.what:2
E/handleMessage: currentThread:Thread-9430,message.what:7
E/handleMessage: currentThread:Thread-9430,message.what:7
E/handleMessage: currentThread:Thread-9430,message.what:9
E/handleMessage: currentThread:Thread-9430,message.what:3
E/handleMessage: currentThread:Thread-9430,message.what:5
E/handleMessage: currentThread:Thread-9430,message.what:2
E/handleMessage: currentThread:Thread-9430,message.what:3
E/handleMessage: currentThread:Thread-9430,message.what:6

很明显可以看出消息是在子线程中接收与处理的。

延伸

再来一个问题，Android 中什么情况下会在子线程中发送消息和处理消息呢？

当然是耗时操作，而耗时操作又使用什么来实现呢？ Service，其实 IntentService 就是利用 Handler 机制实现的。

你可能感兴趣的:(Handler 消息机制)

  • spring security中几大组件的作用和执行顺序 阿信在这里 javaspring
    springsecurity中几大组件的作用和执行顺序在SpringSecurity中，AuthenticationProvider、GroupPermissionEvaluator、PermissionEvaluator、AbstractAuthenticationProcessingFilter、DefaultMethodSecurityExpressionHandler和ManageSecu
  • python字符串相等怎么表示_python怎样判断字符串相等 weixin_39993989 python字符串相等怎么表示
    python字符串如何判断相等1.is来判断groupName=params['groupName']##groupName的值是'url'reqBody['dim']=groupNameprint("reqBody_dim-SummaryListHandler",reqBody['dim'])##('reqBody_dim-SummaryListHandler',u'url')print("re
  • Java内存模型基础 2401_84002271 程序员java学习经验分享
    1.2Java内存模型的抽象结构Java中所有的实例域、静态域和数组元素都存储在堆内存中，堆内存在线程之间共享（文章中用“共享变量”指代）。局部变量(LocalVariables)、方法定义参数(FormalMethodParameters)和异常处理器参数(ExceptionHandlerParameters)不会在线程之间共享，它们不会存在内存可见性问题，因此也不受内存模型的影响。Java线程
  • netty-简易聊天 2401_84046645 程序员java开发语言
    publicvoidsend(Stringtext){channel.writeAndFlush(Unpooled.copiedBuffer(text.getBytes()));}publicvoidcloseConnect(){send(“bye”);channel.close();}}classMyHandlerextendsChannelInboundHandlerAdapter{@Over
  • Android 用线程池实现一个简单的任务队列(Kotlin) 深海呐 Android#Android进阶#Kotlinandroidkotlin线程池延时任务队列线程池延时任务
    关于线程池,Kotlin和java的使用方式一样在Android中,很多人喜欢用Handler的postDelayed()去实现延时任务.要使用postDelayed(),去实现延时任务队列,就不可避免要使用递归.但是这样做,代码的简洁性,和书写的简易,就远不如使用线程池.使用线程池的简单程度:privatevalmThreadPool=Executors.newSingleThreadSched
  • openGauss 扩展FDW与其他openGauss特性 openGaussMan 数据库openGauss
    扩展FDW与其他openGauss特性openGauss基于PostgreSQL，而PostgreSQL没有内置存储引擎适配器，如MySQL的handlerton。为了使MOT存储引擎能够集成到openGauss中，我们利用并扩展了现有的FDW机制。随着FDW引入PostgreSQL9.1，现在可以将这些外表和数据源呈现为统一、本地可访问的关系来访问外部管理的数据库。和PostgreSQL不同的是
  • 非线性成长 yeedom
    前言一个环境长期越稳定，线性法则在其中就越适用；相反，如果一个环境变化越快、越频繁，则非线性法则越容易在其中起主导作用创业是让人快速精进、快速成长的最好环境，至少是之一解决问题，是创业过程中我所有学习和成长的唯一意义，也是我学习和成长的唯一动力打破自身边界，不断上行去看到更大的世界，了解更多顶尖高手在关注什么、如何思考，以及如何才能成为那样的高手职业生涯三阶段工具人（Handler）需要什么，就学
  • mybatis支持json，Spring boot配置 Knight_9
    mysql5.7版本以后支持原生json格式，基于Springboot进行配置说明。mybatis支持mysql的json格式mysql-connector，mysql的驱动版本要大于等于5.1.40，否则json字段查询会发生乱码。继承BaseTypeHandler自定义一个json类型处理器，放到一个handler包下，例：packagecom.c.config.handler;importc
  • App发生崩溃保存崩溃日志在本地，并发送邮件给开发人员 猝死的咸鱼 android异常邮件androidapp
    App在客户手中时不时会出现闪退，崩溃等现象。但蛋疼的时有时候无法重现崩溃原因处理。于是，崩溃保存日志出来了，但保存在用户本地也看不到啊，于是，发邮件又来了。效果如图再说个蛋疼的问题，我在公司Androidstadio2.3.3版本UncaughtExceptionHandler不会跳到这个奔溃的提示页面，但我在家里的Androidstadio3.0.1版本有没问题。默默的问问，2.3.3-3.0
  • ios runtime 简单路由 Mjs
    1.协议本路由通过协议方式实现首先定义一个必须实现的方法typedefvoid(^JCompletionHandler)(id_Nullableresult,NSError*_Nullableerror);@protocolJRouteHandler@required+(void)handleRequestWithParameters:(nullableJParameters)parameters
  • C语言写一个奔跑的火柴人 BABA8891 c语言nginx服务器
    创建一个“奔跑的火柴人”程序可以用简单的文本字符来表示火柴人的动作。这里我们可以使用C语言，在控制台上显示一个简单的动画效果。这个动画会循环显示火柴人的不同姿态，模拟奔跑的效果。下面是一个简单的示例代码：#include#include//Forsleep()#include//ForcatchingSIGINTvolatilesig_atomic_trun=1;voidsignalHandler
  • vba把excel导入mysql_VBA将Excel数据表格直接导入SQL Server数据库 weixin_39757040
    [vb]代码库'把当前Excel工作簿的所有工作表的数据表格转换为Insert语句并导入SQLServer数据库中。OptionExplicitPublicSubCreateAllSheetsInsertScript()OnErrorGoToErrorHandler'recordsetandconnectionvariablesDimRowAsLongDimColAsInteger'Tostore
  • Django项目中log日志的配置 叫我DPT Django项目中常用组件脚本功能djangologging
    文章目录日志配置模板日志处理器Handlers日志配置模板#日志LOGGING={'version':1,#使用的日志模块的版本，目前官方提供的只有版本1，但是官方有可能会升级，为了避免升级出现的版本问题，所以这里固定为1'disable_existing_loggers':False,#是否禁用其他的已经存在的日志功能？肯定不能，有可能有些第三方模块在调用，所以禁用了以后，第三方模块无法捕获自身
  • python并发与并行（十一） ———— 让asyncio的事件循环保持畅通，以便进一步提升程序的响应能力 bug404_ python并发与并行python开发语言
    前一篇blog说明了怎样把采用线程所实现的项目逐步迁移到asyncio方案上面。迁移后的run_tasks协程，可以将多份输入文件通过tail_async协程正确地合并成一份输出文件。importasyncio#OnWindows,aProactorEventLoopcan'tbecreatedwithin#threadsbecauseittriestoregistersignalhandlers
  • linux生成mux节点,mux - 路由 另一个21 linux生成mux节点
    [TOC]>[参考文档](https://github.com/gorilla/mux)##安装``goget-ugithub.com/gorilla/mux`##实例###path解析```r:=mux.NewRouter()r.HandleFunc("/products/{key}",ProductHandler)r.HandleFunc("/articles/{category}/",Art
  • 《Spring实战》读书笔记-第5章 构建Spring Web应用程序 2401_86367086 面试辅导大厂内推spring前端java
    5.1SpringMVC起步SpringMVC框架主要包括请求调度Servlet、处理器映射（handlermapping）、控制器以及视图解析器（viewresolver）这些组件。跟踪SpringMVC的请求Web请求从离开浏览器开始到获取响应返回，它会经历好多站，每站都会留下一些信息同时带上其他信息。一路上请求会将信息带到很多站点，并产生期望的结果请求带着URL以及其他信息离开浏览器后，第一
  • idea2023版使用Free MyBatis plugin插件报错 涛哥是个大帅比 问题mybatisjavaidea
    项目场景：新版的idea使用FreeMyBatisplugin插件报错问题描述错误信息java.lang.Throwable:'#LineMarkerInfo(T,TextRange,Icon,int,Function,GutterIconNavigationHandler,Alignment)'isdeprecatedandgoingtoberemovedsoon.Pleaseuse`LineM
  • MxGraph上下文按钮实现 随风九天 前端mxgraph浮动按钮
    1介绍mxGraph是一个强大的JavaScript图形前端库，可以快速创建交互式图表和图表应用程序，国内外著名的ProcessOne和draw.io都是使用该库创建的强大的在线流程图绘制网站.1.1编写顶点事件functionmxVertexToolHandler(state){mxVertexHandler.apply(this,arguments);};mxVertexToolHandler
  • Spring MVC请求处理(五) - 拦截器 buzzerrookie
    DispatcherServlet的doDispatch方法在调用处理器处理请求前后分别调用了拦截器的前置和后置处理方法，代码如下所示：if(!mappedHandler.applyPreHandle(processedRequest,response)){return;}//Actuallyinvokethehandler.mv=ha.handle(processedRequest,respon
  • llm在网页中的流式输出（langchain与streamlit库） 格瑞Lxf langchain
    一、手动进行流式输出llm本身是支持在终端流式输出的，以ollama为例llm=Ollama(base_url="http://localhost:11434",model="qwen",callback_manager=CallbackManager([StreamingStdOutCallbackHandler()]),)查看源码StreamingStdOutCallbackHandler类中
  • Netty实战二-实现UDP的单播和广播(1) 2401_84048671 程序员udp网络协议网络
    publicclassAnswerHandlerextendsSimpleChannelInboundHandler{/应答的具体内容从常量字符串数组中取得，由nextQuote方法随机获取/privatestaticfinalString[]DICTIONARY={“一个男生暗恋一个女生很久了。一天自习课上，男生偷偷的传了小纸条给女生，上面写着“其实我注意你很久了”。不一会儿，女生传了另一张纸条
  • hutool获取大数据量的excel内容及sheet名称问题 liu_qixiang excel
    读取大数据量的excel时代码如下privatestaticRowHandlercreateRowHandler(){returnnewRowHandler(){@Overridepublicvoidhandle(inti,longl,Listlist){System.out.println(i+""+l+""+list);}};}publicstaticvoidmain(String[]args
  • 2019-11-18 轻微强迫症_7280
    fiddler添加查看响应时间原文来自：https://www.jianshu.com/p/c9efa41bdd25fiddler的statistics标签可以查看但是这样查看需要点开每个链接进行查看，不是很方便，为了能够方便的查看各链接的响应时间，可以通过一下几种方法实现1、在菜单栏上面找到Rules->CustomRules在classHandlers{里面添加以下代码functionBegi
  • http.FileServer修改Header hengshen
    定义一个函数包裹Handler，返回HandleFunc，然后通过ResponseWriter修改Header。funcchangeHeaderThenServe(hhttp.Handler)http.HandlerFunc{returnfunc(whttp.ResponseWriter,r*http.Request){//Setsomeheader.w.Header().Add("Keep-Al
  • Spring MVC 架构详解 firepation SpringJavaspringmvc
    SpringMVC（Model-View-Controller）是Spring框架中用于构建Web应用程序的模块。它通过分离应用程序的不同方面（输入逻辑、业务逻辑和UI逻辑）来简化开发工作。本文将详细介绍SpringMVC架构及其基本组件，包括DispatcherServlet、HandlerMapping、Controller和ViewResolver。SpringMVC架构SpringMVC架
  • SpringMvc参数解析器HandlerMethodArgumentResolver Yx8080 SpringMvc大数据
    介绍首先什么是Handler？我的理解是SpringMVC中真正用于处理业务逻辑的类，也就是常说的、标注了@Controller注解的Controller类；Controller类中使用@RequestMapping(或GetMapping等变种注解)标注的方法称为处理器方法；处理器方法的参数指的就是该方法的参数。处理器方法参数解析器HandlerMethodArgumentResolver用于自
  • SpringMVC参数解析器HandlerMethodArgumentResolver 这是一条海鱼 SpringMVC
    前言在享受SpringMVC带给你便捷的时候，你是否曾经这样疑问过：Controller的handler方法参数能够自动完成参数封装（有时即使没有@PathVariable、@RequestParam、@RequestBody等注解都可），甚至在方法参数任意位置写HttpServletRequest、HttpSession、Writer…等类型的参数，它自动就有值了便可直接使用。对此你是否想问一句
  • HandlerMethodArgumentResolver-处理器参数解析 后台开发者Ethan springmvcspringjava
    HandlerMethodArgumentResolverspringmvc中仅仅加个@Controller@RequestMaping等注解就可以将普通的java方法成为一个Handler处理器。spring通过HandlerMethodArgumentResolver来解析handler处理器参数问题。HandlerMethodArgumentResolver接口booleansupports
  • 出现 [Vue warn]: Unhandled error during execution of component event handler 解决方法 码农研究僧 BUGvue.jsjavascriptecmascript
    目录前言1.问题所示2.原理分析3.解决方法3.1第一次遇到3.2第二次遇到前言基本的知识推荐阅读：详细分析Js中的Promise.all基本知识（附Demo）1.问题所示点击按钮的时候，浏览器出现如下提示虽然它是warn，但是本着解决问题的本质还是理性分析下use-button.ts:57[Vuewarn]:Unhandlederrorduringexecutionofcomponenteven
  • spring-websocket基于stomp实现websocket 飘零未归人 前端javawebsocket网络协议网络
    目录概述后端代码拦截器HandshakeInterceptor拦截器ChannelInterceptor拦截器消息转换器配置类消息处理广播模式用户模式自定义请求头用户信息ChannelInterceptor拦截器设置用户信息DefaultHandshakeHandler的继承类中设置用户对象前端代码概述WebSocket协议是一种相当低级的协议。它定义了如何将字节流转换为帧。帧可以包含文本或二进制
  • 项目中 枚举与注解的结合使用 飞翔的马甲 javaenumannotation
    前言：版本兼容，一直是迭代开发头疼的事，最近新版本加上了支持新题型，如果新创建一份问卷包含了新题型，那旧版本客户端就不支持，如果新创建的问卷不包含新题型，那么新旧客户端都支持。这里面我们通过给问卷类型枚举增加自定义注解的方式完成。顺便巩固下枚举与注解。 一、枚举 1.在创建枚举类的时候，该类已继承java.lang.Enum类，所以自定义枚举类无法继承别的类，但可以实现接口。
  • 【Scala十七】Scala核心十一：下划线_的用法 bit1129 scala
    下划线_在Scala中广泛应用，_的基本含义是作为占位符使用。_在使用时是出问题非常多的地方，本文将不断完善_的使用场景以及所表达的含义   1. 在高阶函数中使用 scala> val list = List(-3,8,7,9) list: List[Int] = List(-3, 8, 7, 9) scala> list.filter(_ > 7) r
  • web缓存基础：术语、http报头和缓存策略 dalan_123 Web
    对于很多人来说，去访问某一个站点，若是该站点能够提供智能化的内容缓存来提高用户体验，那么最终该站点的访问者将络绎不绝。缓存或者对之前的请求临时存储，是http协议实现中最核心的内容分发策略之一。分发路径中的组件均可以缓存内容来加速后续的请求，这是受控于对该内容所声明的缓存策略。接下来将讨web内容缓存策略的基本概念，具体包括如如何选择缓存策略以保证互联网范围内的缓存能够正确处理的您的内容，并谈论下
  • crontab 问题 周凡杨 linuxcrontabunix
      一： 0481-079   Reached   a   symbol   that   is   not   expected.   背景： */5   *   *   *   *  /usr/IBMIHS/rsync.sh 
  • 让tomcat支持2级域名共享session g21121 session
    tomcat默认情况下是不支持2级域名共享session的，所有有些情况下登陆后从主域名跳转到子域名会发生链接session不相同的情况，但是只需修改几处配置就可以了。 打开tomcat下conf下context.xml文件 找到Context标签,修改为如下内容 如果你的域名是www.test.com <Context sessionCookiePath="/path&q
  • web报表工具FineReport常用函数的用法总结（数学和三角函数） 老A不折腾 Webfinereport总结
      ABS ABS(number):返回指定数字的绝对值。绝对值是指没有正负符号的数值。 Number:需要求出绝对值的任意实数。 示例: ABS(-1.5)等于1.5。 ABS(0)等于0。 ABS(2.5)等于2.5。   ACOS ACOS(number):返回指定数值的反余弦值。反余弦值为一个角度，返回角度以弧度形式表示。 Number:需要返回角
  • linux 启动java进程 sh文件 墙头上一根草 linuxshelljar
    #!/bin/bash #初始化服务器的进程PId变量 user_pid=0; robot_pid=0; loadlort_pid=0; gateway_pid=0; ######### #检查相关服务器是否启动成功 #说明： #使用JDK自带的JPS命令及grep命令组合，准确查找pid #jps 加 l 参数，表示显示java的完整包路径 #使用awk，分割出pid
  • 我的spring学习笔记5-如何使用ApplicationContext替换BeanFactory aijuans Spring 3 系列
    如何使用ApplicationContext替换BeanFactory？ package onlyfun.caterpillar.device; import org.springframework.beans.factory.BeanFactory; import org.springframework.beans.factory.xml.XmlBeanFactory; import
  • Linux 内存使用方法详细解析 annan211 linux内存Linux内存解析
    来源 http://blog.jobbole.com/45748/ 我是一名程序员，那么我在这里以一个程序员的角度来讲解Linux内存的使用。 一提到内存管理，我们头脑中闪出的两个概念，就是虚拟内存，与物理内存。这两个概念主要来自于linux内核的支持。 Linux在内存管理上份为两级，一级是线性区，类似于00c73000-00c88000，对应于虚拟内存，它实际上不占用
  • 数据库的单表查询常用命令及使用方法(-) 百合不是茶 oracle函数单表查询
        创建数据库;       --建表 create table bloguser(username varchar2(20),userage number(10),usersex char(2));       创建bloguser表,里面有三个字段     &nbs
  • 多线程基础知识 bijian1013 java多线程threadjava多线程
    一．进程和线程 进程就是一个在内存中独立运行的程序，有自己的地址空间。如正在运行的写字板程序就是一个进程。 “多任务”：指操作系统能同时运行多个进程（程序）。如WINDOWS系统可以同时运行写字板程序、画图程序、WORD、Eclipse等。 线程：是进程内部单一的一个顺序控制流。 线程和进程 a.       每个进程都有独立的
  • fastjson简单使用实例 bijian1013 fastjson
    一.简介         阿里巴巴fastjson是一个Java语言编写的高性能功能完善的JSON库。它采用一种“假定有序快速匹配”的算法，把JSON Parse的性能提升到极致，是目前Java语言中最快的JSON库；包括“序列化”和“反序列化”两部分，它具备如下特征：     
  • 【RPC框架Burlap】Spring集成Burlap bit1129 spring
    Burlap和Hessian同属于codehaus的RPC调用框架，但是Burlap已经几年不更新，所以Spring在4.0里已经将Burlap的支持置为Deprecated,所以在选择RPC框架时，不应该考虑Burlap了。 这篇文章还是记录下Burlap的用法吧，主要是复制粘贴了Hessian与Spring集成一文，【RPC框架Hessian四】Hessian与Spring集成  
  • 【Mahout一】基于Mahout 命令参数含义 bit1129 Mahout
    1. mahout seqdirectory   $ mahout seqdirectory --input (-i) input Path to job input directory(原始文本文件). --output (-o) output The directory pathna
  • linux使用flock文件锁解决脚本重复执行问题 ronin47 linux lock　重复执行
    linux的crontab命令，可以定时执行操作，最小周期是每分钟执行一次。关于crontab实现每秒执行可参考我之前的文章《linux crontab 实现每秒执行》现在有个问题，如果设定了任务每分钟执行一次，但有可能一分钟内任务并没有执行完成，这时系统会再执行任务。导致两个相同的任务在执行。 例如： <? //  test .php
  • java-74-数组中有一个数字出现的次数超过了数组长度的一半，找出这个数字 bylijinnan java
    public class OcuppyMoreThanHalf { /** * Q74 数组中有一个数字出现的次数超过了数组长度的一半，找出这个数字 * two solutions: * 1.O(n) * see <beauty of coding>--每次删除两个不同的数字，不改变数组的特性 * 2.O(nlogn) * 排序。中间
  • linux 系统相关命令 candiio linux
    系统参数 cat /proc/cpuinfo  cpu相关参数 cat /proc/meminfo 内存相关参数 cat /proc/loadavg 负载情况 性能参数 1）top M：按内存使用排序 P：按CPU占用排序 1：显示各CPU的使用情况 k：kill进程 o：更多排序规则 回车：刷新数据 2）ulimit ulimit -a：显示本用户的系统限制参
  • [经营与资产]保持独立性和稳定性对于软件开发的重要意义 comsci 软件开发
         一个软件的架构从诞生到成熟，中间要经过很多次的修正和改造       如果在这个过程中，外界的其它行业的资本不断的介入这种软件架构的升级过程中           那么软件开发者原有的设计思想和开发路线
  • 在CentOS5.5上编译OpenJDK6 Cwind linuxOpenJDK
    几番周折终于在自己的CentOS5.5上编译成功了OpenJDK6，将编译过程和遇到的问题作一简要记录，备查。 0. OpenJDK介绍 OpenJDK是Sun（现Oracle）公司发布的基于GPL许可的Java平台的实现。其优点： 1、它的核心代码与同时期Sun（-> Oracle）的产品版基本上是一样的，血统纯正，不用担心性能问题，也基本上没什么兼容性问题；（代码上最主要的差异是
  • java乱码问题 dashuaifu java乱码问题js中文乱码
    swfupload上传文件参数值为中文传递到后台接收中文乱码     在js中用setPostParams（{"tag" : encodeURI( document.getElementByIdx_x("filetag").value，"utf-8")}）; 然后在servlet中String t
  • cygwin很多命令显示command not found的解决办法 dcj3sjt126com cygwin
    cygwin很多命令显示command not found的解决办法   修改cygwin.BAT文件如下 @echo off D: set CYGWIN=tty notitle glob set PATH=%PATH%;d:\cygwin\bin;d:\cygwin\sbin;d:\cygwin\usr\bin;d:\cygwin\usr\sbin;d:\cygwin\us
  • [介绍]从 Yii 1.1 升级 dcj3sjt126com PHPyii2
    2.0 版框架是完全重写的，在 1.1 和 2.0 两个版本之间存在相当多差异。因此从 1.1 版升级并不像小版本间的跨越那么简单，通过本指南你将会了解两个版本间主要的不同之处。 如果你之前没有用过 Yii 1.1，可以跳过本章，直接从"入门篇"开始读起。 请注意，Yii 2.0 引入了很多本章并没有涉及到的新功能。强烈建议你通读整部权威指南来了解所有新特性。这样有可能会发
  • Linux SSH免登录配置总结 eksliang ssh-keygenLinux SSH免登录认证Linux SSH互信
    转载请出自出处：http://eksliang.iteye.com/blog/2187265 一、原理      我们使用ssh-keygen在ServerA上生成私钥跟公钥，将生成的公钥拷贝到远程机器ServerB上后,就可以使用ssh命令无需密码登录到另外一台机器ServerB上。      生成公钥与私钥有两种加密方式，第一种是
  • 手势滑动销毁Activity gundumw100 android
    老是效仿ios，做android的真悲催！ 有需求：需要手势滑动销毁一个Activity 怎么办尼？自己写？ 不用~，网上先问一下百度。 结果： http://blog.csdn.net/xiaanming/article/details/20934541 首先将你需要的Activity继承SwipeBackActivity，它会在你的布局根目录新增一层SwipeBackLay
  • JavaScript变换表格边框颜色 ini JavaScripthtmlWebhtml5css
    效果查看：http://hovertree.com/texiao/js/2.htm代码如下，保存到HTML文件也可以查看效果： <html> <head> <meta charset="utf-8"> <title>表格边框变换颜色代码-何问起</title> </head> <body&
  • Kafka Rest : Confluent kane_xie kafkaRESTconfluent
    最近拿到一个kafka rest的需求，但kafka暂时还没有提供rest api（应该是有在开发中，毕竟rest这么火），上网搜了一下，找到一个Confluent Platform，本文简单介绍一下安装。 这里插一句，给大家推荐一个九尾搜索，原名叫谷粉SOSO，不想fanqiang谷歌的可以用这个。以前在外企用谷歌用习惯了，出来之后用度娘搜技术问题，那匹配度简直感人。 环境声明：Ubu
  • Calender不是单例 men4661273 单例Calender
             在我们使用Calender的时候，使用过Calendar.getInstance()来获取一个日期类的对象，这种方式跟单例的获取方式一样，那么它到底是不是单例呢，如果是单例的话，一个对象修改内容之后，另外一个线程中的数据不久乱套了吗？从试验以及源码中可以得出，Calendar不是单例。 测试： Calendar c1 =
  • 线程内存和主内存之间联系 qifeifei java thread
    1， java多线程共享主内存中变量的时候，一共会经过几个阶段，    lock:将主内存中的变量锁定，为一个线程所独占。   unclock:将lock加的锁定解除，此时其它的线程可以有机会访问此变量。   read:将主内存中的变量值读到工作内存当中。   load:将read读取的值保存到工作内存中的变量副本中。  
  • schedule和scheduleAtFixedRate tangqi609567707 javatimerschedule
    原文地址：http://blog.csdn.net/weidan1121/article/details/527307 import java.util.Timer;import java.util.TimerTask;import java.util.Date; /** * @author vincent */public class TimerTest {  
  • erlang 部署 wudixiaotie erlang
    1.如果在启动节点的时候报这个错 ： {"init terminating in do_boot",{'cannot load',elf_format,get_files}} 则需要在reltool.config中加入 {app, hipe, [{incl_cond, exclude}]},     2.当generate时，遇到： ERROR
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他