书生依旧
书生依旧

Android Handler 消息机制详述

版权声明： 本文来自 书生依旧 的，转载请注明出处。
原文链接： http://www.jianshu.com/p/1a5a3db45cfa

一. What、Handler 是什么

Handler 与 Message、MessageQueue、Looper 一起构成了 Android 的消息机制，Android 系统通过大量的消息来与用户进行交互，View 的绘制、点击事件、Activity 的生命周期回调等都作为消息由主线程的 Handler 来处理。

Handler 在消息机制中的作用是：发送和处理消息。

Handler 还有另一个重要的作用，跨线程通信。最常见的就是子线程请求网络，然后使用 Handler 将请求到的数据 post 到主线程刷新 UI，大名鼎鼎的 Retrofit 也是这么做的。

二. How、如何使用 Handler

  • 创建 Handler

    private Handler handler = new Handler() {
  // 重写 handleMessage 来根据不同 what 来处理 Message
  // 这个方法在 Handler 创建的线程执行
  @Override public void handleMessage(Message msg) {
        super.handleMessage(msg);
        switch (msg.what) {
            case 0:
              MLog.i(msg.obj);
              break;
            case 1:
              break;
            default:

        }
    }
};

  • 创建并发送 Message

    // 获取一个 Message
Message message = Message.obtain();
message.what = 0;
message.obj = new Object();
// 使用 Handler 发送 Message
// 消息发送完成后 Handler 的 handleMessage(Message msg) 会处理消息
handler.sendMessage(message);

// 延迟 1s 发送 Message
handler.sendMessageDelayed(message, 1000);
// 发送一个空的 Message
handler.sendEmptyMessage(msg.what);  
// 延迟发送一个空的 Message
handler.sendEmptyMessageDelayed(0, 1000);

// 还可以这样
// 创建 Message 并绑定 Handler
Message message = handler.obtainMessage();
message.what = 0;
message.obj = new Object();

// 发送 Message
message.sendToTarget();

  • 使用 Handler 子线程请求数据，主线程刷新 UI

    // 1. 在主线程创建 Handler（略）
// 2. 子线程请求数据，主线程刷新 UI
new Thread(new Runnable() {
    @Override public void run() {
        // 获取网络数据
        final List datas = getNetData();

        // 方法一：将数据作为 Message 的 obj 发送出去，在 handleMessage 中刷新 UI
        Message msg = Message.obtain();
        msg.what = 1;
        msg.obj = data;
        handler.sendMessage(msg);

        // 方法二：直接在 post 中刷新 UI
        handler.post(new Runnable() {
            @Override public void run() {
              // 使用 datas 刷新 UI
              // 这个方法也会在 Handler 创建的线程执行
            }
        });
    }
}).start();
  
  
 
    三. Handler 的内存泄漏
     
 
    不得不说，上面使用 Handler 的方法会有内存泄漏的风险
     
 
       
  
    •  
      Handler 内存泄漏的两个原因
       
   
         
    
      •  
        Java 中非静态内部类和匿名内部类会持有外部类的引用
         
        // 这是一个外部类 Handler 不会持有外部类引用
// 显然 handleMessage 没地方写了
Handler handler = new Handler();

// 重写 handleMessage 后将得到一个内部类 Handler，以内 handleMessage 是在外部类中实现的
// 它持有外部类引用，可能会引起内存泄漏
Handler handler = new Handler() {
  @Override public void handleMessage(Message msg) {
        super.handleMessage(msg);
        switch (msg.what) {
            case 0:
              MLog.i(msg.obj);
              break;
            case 1:
              break;
            default:

        }
    }
};

// 这里 Handler 是一个匿名类，但不是内部类
// Runnable 是一个匿名内部类，持有外部类引用，可能会引起内存泄漏
new Handler().post(new Runnable() {
    @Override public void run() {
      // ...
    }
});

         
        ​
         
        •  
    
      • Handler 的生命周期比外部类长。
        •  
   
       
      •  
  
    •  
      分析
       
   
         
    
      • 非静态的内部 Handler 子类、匿名 Handler 子类会持有外部类的引用(Activity)，而 Handler 可能会因为要等待处理耗时操作导致存活时间超过 Activity，或者消息队列中存在未被 Looper 处理的 Message ，而 Message 会持有 Handler 的引用。于是，在 Activity 退出时，其引用还是被 Handler 持有，导致 Activity 无法被及时回收，造成内存泄露。
        •  
    
      • 非静态的内部 Runnable 子类、匿名 Runnable 子类 post 到任意 Handler 上时，Runnable 其实是 Massage中的 Callback，持有 Message 引用，如果这个 Massage 在消息队列还没有被处理，那么就会造成 Runnable 一直持有外部类的引用而造成内存泄露。
        •  
   
       
      •  
  
    •  
      解决方案：
       
   
         
    
      • 通过静态内部类或者外部类来声明 Handler 和 Runnable。
        •  
    
      • 通过弱引用来拿到外部类的变量。
        •  
    
      • 在 Activity/Fragment 销毁的时候请空 MessageQueue 中的消息。
        •  
   
       
      •  
  
    •  
      代码
       
      // Handler 弱引用封装
public class SafetyHandler extends Handler {
    /**
     * 外部引用, 例如 Activity, Fragment, Dialog, View 等
     */
    private WeakReference mTargetRef;
    public SafetyHandler() {
    }
    public SafetyHandler(T target) {
        this.mTargetRef = new WeakReference<>(target);
    }
    
    public T getTarget() {
        if (isTargetAlive()) {
            return mTargetRef.get();
        } else {
            removeCallbacksAndMessages(null);
            return null;
        }
    }
  
    public void setTarget(T target) {
        this.mTargetRef = new WeakReference<>(target);
    }
  
    private boolean isTargetAlive() {
        return mTargetRef != null && mTargetRef.get() != null;
    }
}

// 在 Fragment 中使用方法
// 想重写 handleMessage 的话，要创建静态内部类或者外部类，否则有内存泄漏风险
private static class MyHandler extends SafetyHandler {

    MyHandler(MyFragment fragment) {
          super(fragment);
    }

    @Override public void handleMessage(Message msg) {
        super.handleMessage(msg);
        if(getTarget() != null) {
            MyFragment fragment = getTarget();
            switch (msg.what) {
               // 操作 fragment
            }
        }
    }
}

// 声明 Handler
MyHandler handler = new MyHandler(this);

// 使用 Handler
handler.sendMessage() ...
  
// onDestroy   
@Override public void onDestroy() {
      super.onDestroy();
      handler.removeCallbacksAndMessages(null);
}

       
      ​
       
      •  
 
     
 
    四. Why、Handler 消息机制的原理
     
 
     
  
    这部分从 ActivityThread 的 main 方法出发，打通整个消息机制的流程，结合源码体验效果更佳。
     
 
     
 
    概述
     
 
    介绍消息机制的原理前，我们先来看一下 Handler 与 Message、MessageQueue、Looper 这个四个类的作用
     
 
       
  
    • Handler：前面已经说过，Handler 负责发送和处理 Message。
      •  
  
    • Message：消息，负责传递标示(what) 和数据(obj) ；每个 Message 都会通过 target 这个成员变量来绑定一个 Handler，由这个 Handler 来发送和处理 Message。
      •  
  
    • MessageQueue：消息队列，负责存放有 Handler 发送过来的消息；每个 Handler 中都有一个 final MessageQueue mQueue，Handler 发送消息就是把消息加入这个 MessageQueue 。
      •  
  
    • Looper：负责不断的从 MessageQueue 中取出消息然后交给 Handler（Message#target ） 处理；每个 Looper 中都有一个唯一的消息队列（final MessageQueue mQueue），每个 Handler 中都有一个 final Looper mLooper，Handler 中的 MessageQueue 就是来自 Looper。
      •  
 
     
 
    注意：每个线程只能有一个 Looper 和 一个 MessageQueue，可以有多个 Handler，每个 Handler 可以发送和处理多个 Message。
     
 
    另外，提到消息机制就不得不说一下 Android 中的主线程（UI 线程）
     
 
     
  
     
   
     
    Android Handler 消息机制详述_第1张图片 
   
     
  
     
  
     
 
     
 
    Android 中的主线程通过 Looper.loop() 进入一个无线循环中，不断的从一个 MessageQueue 取出消息，处理消息，我们每触发一个事件，就会向这个 MessageQueue 中添加一个消息，Looper 取出这个消息，Handler 处理这个消息，正是 Looper.loop() 在驱动着 Android 应用运行下去 ，这也是为什么 Looper.loop 为什么不会阻塞住主线程的原因（当然前提是在 ActivityThread 的 main 函数 中调用）。
     
 
    正式进入源码分析
     
 
     
  
    本源码分析基于 API 25，以下源码中删除了一些无关的代码
     
 
     
 
    1、在主线程的入口，ActivityThread 的 main 方法
     
 
    public static void main(String[] args) {
        // 准备主线程的 Looer     
        Looper.prepareMainLooper();
        // 创建 ActivityThread
        ActivityThread thread = new ActivityThread();
        thread.attach(false);
        // 获取主线程的 Handler 
        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }
  
        // 对消息队列进行无线轮询，处理消息
        Looper.loop();
        // 一旦跳出循环，抛出异常（Android 不允许跳出主线程的 Looper.loop()）
        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

     
 
    -> Looper.prepareMainLooper()
     
 
    public static void prepareMainLooper() {
     // 准备一个 Looper
     prepare(false);
     synchronized (Looper.class) {
         // main Looper 只能初始化一次，再次初始化会抛出异常
         if (sMainLooper != null) {
             throw new IllegalStateException("The main Looper has already been prepared.");
         }
         // 获取 main Looper
         sMainLooper = myLooper();
     }
 }

     
 
    -> prepare(false)
     
 
    // 准备一个 Looper，quitAllowed 是否允许 Looper 中的 MessageQueue 退出
// 默认 prepare() 允许退出，主线程这里不允许退出
private static void prepare(boolean quitAllowed) {
 // 先看下 sThreadLocal 是什么
 // static final ThreadLocal sThreadLocal = new ThreadLocal();
 // ThreadLocal:线程本地存储区，每个线程都有本地存储区域，这个区域是每个线程私有的，不同的线程不能之间不能彼此访问
 // 如果 sThreadLocal 中有数据，抛出异常，换句话说 prepare() 这个函数每个线程只能执行一次
 if (sThreadLocal.get() != null) {
     throw new RuntimeException("Only one Looper may be created per thread");
 }
 // 创建 Looper 保存到该线程的 ThreadLocal 中
 sThreadLocal.set(new Looper(quitAllowed));
}

     
 
    -> new Looper(quitAllowed)
     
 
    private Looper(boolean quitAllowed) {
 // 在 Looper 创建的时候创建一个消息队列
 // quitAllowed:消息队列是否可以退出，主线的消息队列肯定不允许退出，所以上面是 prepare(false)
 // quitAllowed 为 false 执行 MessageQueue#quit 退出消息队列时会出现异常
 mQueue = new MessageQueue(quitAllowed);
 // 获取 Looper 存在于哪个线程
 mThread = Thread.currentThread();
}

     
 
    -> sMainLooper = myLooper()
     
 
    public static @Nullable Looper myLooper() {
 // 从 sThreadLocal 中获取当前线程的 Looper 
 // 如果当前线程没有掉用 Looper.prepare 返回 null
 return sThreadLocal.get();
}

     
 
    -> sMainThreadHandler = thread.getHandler();
     
 
    final Handler getHandler() {
 // 返回 mH
 return mH;
}

// mH 在成员变量的位置 new H()
final H mH = new H();

// H 继承了 Handler 封装了一系列关于 Acitivty、Service 以及其他 Android 相关的操作
private class H extends Handler 

     
 
    总结：在主线程的 main 方法中，会创建主线程的 Looper、MessageQueue，然后进入 Looper.loop() 循环中，不断的取出消息，处理消息，以此来驱动 Android 应用的运行。
     
 
    2、Handler 的创建，Handler 的所有构造方法都会跳转到下面两个之一
     
 
    public Handler(Callback callback, boolean async) {
 // Hanlder 是匿名类、内部类、本地类时，如果没有声明为 static 则会出现内存泄漏的警告
 if (FIND_POTENTIAL_LEAKS) {
     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());
     }
 }
 
 // 获取 Looper
 mLooper = Looper.myLooper();
 if (mLooper == null) {
     throw new RuntimeException("Can't create handler inside thread that has not called Looper.prepare()");
 }
 // 消息队列，从 Looper 中获取
 mQueue = mLooper.mQueue;
 // 处理消息的回调接口
 mCallback = callback;
 // 处理消息的方式是否为异步，默认同步
 mAsynchronous = async;
}

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

     
 
    总结：在 Handler 的构造方法中，Handler 和 Looper、MessageQueue 绑定起来，如果当前线程没有 Looper 抛出异常（这也是为什么直接在子线程创建 Handler 会出现异常）。
     
 
    3、使用 Handler 发送消息
     
 
    -> sendMessageAtTime(Message msg, long uptimeMillis)
     
 
    // 除了 sendMessageAtFrontOfQueue，Handler 所有的 post、sendMessage 都会跳到这个方法
// Message msg: 要发送的消息
// long uptimeMillis: 发送消息的绝对时间，通过 SystemClock.uptimeMillis() 加上我们自己的延迟时间 delayMillis 计算而来
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
  MessageQueue queue = mQueue;
  // 消息队列为空（可能已经退出）返回 false 入队失败
  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);
}

     
 
    -> sendMessageAtFrontOfQueue(Message msg)
     
 
    // 发送消息到 MessageQueeu 的队头
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;
 }
 // 通过设置 uptimeMillis 为 0，是消息加入到 MessageQueue 的队头
 return enqueueMessage(queue, msg, 0);
}

     
 
    -> enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis)
     
 
    // 所有 Handler 的 post 、sendMessage 系列方法和 runOnUiThread 最终都会调用这个方法
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
 // msg.target 是一个 Handler，将 Message 和 Handler 绑定
 // 也就是用哪个 Handler 发送消息，这个 Message 就和哪个 Handler 绑定
 msg.target = this;
 // 如果设置了消息处理方式为异步处理
 if (mAsynchronous) {
     msg.setAsynchronous(true);
 }
 // MessageQueue 的方法，将消息入队
 return queue.enqueueMessage(msg, uptimeMillis);
}

     
 
    -> MessageQueue#enqueueMessage(Message msg, long when)
     
 
    boolean enqueueMessage(Message msg, long when) {
     // Messgae 没有绑定 Handler 抛出异常
     if (msg.target == null) {
         throw new IllegalArgumentException("Message must have a target.");
     }
     // Messgae 正在使用 抛出异常
     if (msg.isInUse()) {
         throw new IllegalStateException(msg + " This message is already in use.");
     }
 
     synchronized (this) {
         // 消息队列正在退出，回收 Message
         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();  // 调用 Message#recycleUnchecked() 
             return false;
         }
         msg.markInUse();  // 标记 Message 正在使用
         msg.when = when;  // 设置 Message 的触发时间
       
         // mMessages 记录着 MessageQueue 的队头的消息 
         Message p = mMessages;  
         boolean needWake;
         // MessageQueue 没有消息、Message 触发时间为 0、Messgae 触发时间比队头 Message 早
         // 总之这个 Message 在 MessageQueue 中需要最先被分发
         if (p == null || when == 0 || when < p.when) {
             // New head, wake up the event queue if blocked.
             msg.next = p;     // 将以前的队头 Message 链接在这个 Message 后面
             mMessages = msg;  // 将这个 Message 赋值给 mMessages
             needWake = mBlocked;  // 队列是否阻塞
         } else {
             // 标记队列是否阻塞
             needWake = mBlocked && p.target == null && msg.isAsynchronous();
             Message prev;
           
             // 按照时间顺序将 Message 插入消息队列
             for (;;) {
                 prev = p;   // prev 记录队头
                 p = p.next; // p 记录队头的后一个
                 // 队头后面没有消息或者其触发事件比要插入的 Message 晚，跳出循环
                 if (p == null || when < p.when) {
                     break;
                 }
                 if (needWake && p.isAsynchronous()) {
                     needWake = false;
                 }
             }
             // 将 Message 插入队列
             msg.next = p; 
             prev.next = msg;
         }

         // We can assume mPtr != 0 because mQuitting is false.
         if (needWake) {
             nativeWake(mPtr);
         }
     }
     return true;
 }

     
 
    总结：到现在为止，我们的 Handler 已经将 Message 发送到了 MessageQueue，Message 静静的等待被处理。
     
 
    4、Looper.loop() 还记得这个方法在 ActivityThread 的 main 调用了吗？正是它在不断处理 MessageQueue 里面的消息。
     
 
    public static void loop() {
     // 获取 Looper.Looper.prepare 准备好的 Looper
     final Looper me = myLooper();
     if (me == null) {
         throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
     }
     // 获取 Looper 中的消息队列
     final MessageQueue queue = me.mQueue;

     // 进入无线循环
     for (;;) {
         // 取出下一条消息
         Message msg = queue.next(); 
         
         // 没有消息，退出 loop
         // 其实上面 queue.next() 也是一个无限循环，获取到消息就返回，没有消息就一直循环
         if (msg == null) {
             return;
         }

         try {
             // msg.target 实际上就是一个 Handler
             // 获取到了消息，使用绑定的 Handler#dispatchMessage 分发消息
             msg.target.dispatchMessage(msg);
         } finally {
             
         }

         // 释放消息，把 Message 的各个变量清空然后放进消息池中
         msg.recycleUnchecked();
     }
 }

     
 
    5、Handler#dispatchMessage(msg) 消息是如何处理的
     
 
    public void dispatchMessage(Message msg) {
 // 1
 if (msg.callback != null) {
     handleCallback(msg);
 } else {
     // 2
     if (mCallback != null) {
         if (mCallback.handleMessage(msg)) {
             return;
         }
     }
     // 3. 看到这个方法没有！就是我们创建 Handler 时重写的 handleMessage
     // OK 整个流程打通！
     handleMessage(msg);
 }
}

     
 
    总结：流程虽然通了，但是处理 Message 的方法貌似有三种(我标记了序号)，而且我们的 handleMessage 的优先级最低，其他方法会在什么情况下执行呢？ 直接说结论了，调用 Handler 的 post 系列方法会走序号1的处理，创建 Handler 传入 Callback 会走序号2 的处理。
     
 
    Handler 机制总结：想使用 Handler 必须要有 Looper，创建 Looper 的时候会创建 MessageQueue，在 Handler 的构造的时候会绑定这个 Looper 和 MessageQueue，Handler 将 Message 发送到 MessageQueue 中，Looper.loop() 会不断的从 MessageQueue 取出消息再交给这个 Handler 处理。
     
 
    五. HandlerThread 的使用及源码解读
     
 
    在子线程中能直接创建 Handler 吗？
     
 
       
  
    • new Thread(new Runnable() {
    @Override public void run() {
        new Handler().post(new Runnable() {
            @Override public void run() {
                  MLog.i("Handler in " + Thread.currentThread().getName());
            }
        });
    }
}).start();

      •  
  
    • 答案前面提到了是不能，执行上面的代码会出现 java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare() 这个异常，异常提示我们，不能再没有调用 Looper.prepare() 的线程中创建 Handler。
      •  
  
    •  
      简单修改下代码就可以了，给线程准备好 Looper
       
      new Thread(new Runnable() {
    @Override public void run() {
        // 准备一个 Looper，Looper 创建时对应的 MessageQueue 也会被创建
        Looper.prepare();
        // 创建 Handler 并 post 一个 Message 到 MessageQueue
        new Handler().post(new Runnable() {
            @Override public void run() {
                  MLog.i("Handler in " + Thread.currentThread().getName());
            }
        });
        // Looper 开始不断的从 MessageQueue 取出消息并再次交给 Handler 执行
        // 此时 Lopper 进入到一个无限循环中，后面的代码都不会被执行
        Looper.loop();
    }
}).start();

       
      •  
 
     
 
       
  
    • 上面的操作 Android 都帮我们封装好了，正是 HandlerThread 这个类。
      •  
 
     
 
    HandlerThread 的简单使用
     
 
    // 1. 创建 HandlerThread
handlerThread = new HandlerThread("myHandlerThread") {
    // onLooperPrepared 这个方法子线程执行，由线程的 run 方法调用，可以在里面直接创建 Handler
    @Override protected void onLooperPrepared() {
        super.onLooperPrepared();
        new Handler().post(new Runnable() {
            @Override public void run() {
                // 注意：Handler 在子线程创建，这个方法也会运行在子线程，不可以更新 UI
                MLog.i("Handler in " + Thread.currentThread().getName());
            }
        });
    }
};

// 2. 准备 HandlerThread 的 Looper 并调用 onLooperPrepared
handlerThread.start();


// 3. 退出
@Override public void onDestroy() {
    super.onDestroy();
    handlerThread.quit();
}

// 也可以这样用
// 1. 创建 HandlerThread 并准备 Looper
handlerThread = new HandlerThread("myHandlerThread");
handlerThread.start();

// 2. 创建 Handler 并绑定 handlerThread 的 Looper
new Handler(handlerThread.getLooper()).post(new Runnable() {
    @Override public void run() {
        // 注意：Handler 绑定了子线程的 Looper，这个方法也会运行在子线程，不可以更新 UI
        MLog.i("Handler in " + Thread.currentThread().getName());
    }
});

// 3. 退出
@Override public void onDestroy() {
    super.onDestroy();
    handlerThread.quit();
}

     
 
    HandlerThread 源码解读
     
 
       
  
    • HandlerThread 继承了 Thread，本质是一个拥有 Looper 的线程，因此在 HandlerThread 我们可以直接使用 Handler。
      •  
  
    •  
      构造方法
       
      public HandlerThread(String name) {
    super(name);
    mPriority = Process.THREAD_PRIORITY_DEFAULT;
}

// 传入线程的名称和优先级
// 注意 priority 的值必须来自 android.os.Process 不能来自 java.lang.Thread
public HandlerThread(String name, int priority) {
    super(name);
    mPriority = priority;
}

       
      •  
  
    •  
      run 方法：创建子线程的 Looper
       
      @Override
public void run() {
    mTid = Process.myTid();
    // 准备一个 Looper
    Looper.prepare();
    synchronized (this) {
        // 获取 Looper
        mLooper = Looper.myLooper();
        // Looper 获取成功后，唤醒 getLooper 的 wait
        notifyAll();
  }
  Process.setThreadPriority(mPriority);
    // Looper 准备好的回调，在这个方法里可以使用 Handler 了
    onLooperPrepared();
    // Looper 开始循环取消息
    Looper.loop();
    mTid = -1;
}

       
      •  
  
    •  
      getLooper 方法：获取子线程的 Looper
       
      public Looper getLooper() {
    // 线程没有开始或者死亡，返回 null
      if (!isAlive()) {
          return null;
    }

    // If the thread has been started, wait until the looper has been created.
    // Looper 的创建时在子线程完成的，而 getLooper 可能会在主线程调用
    // 当 Looper 没有创建完成时，使用 wait 阻塞等待
    // 上面在 Looper 创建好后会 notifyAll 来唤醒 wait
     synchronized(this) {
        while (isAlive() && mLooper == null) {
            try {
                  wait();
            } catch (InterruptedException e) {
            }
        }
    }
    return mLooper;
}

       
      •  
  
    •  
      quit 和 quitSafely ：结束 Looper 的运行
       
      // quit
quit() -> looper.quit() -> mQueue.quit(false);
// quitSafely 
quitSafely() -> looper.quitSafely() -> mQueue.quit(true);

// 这两个方法最终都会调用到 MessageQueue 的 void quit(boolean safe) 方法
// 前者会直接移除 MessageQueue 中的所有消息，然后终止 MessageQueue
// 后者会将 MessageQueue 中已有消息处理完成后（不再接收新消息）终止 MessageQueue

       
      六.参考文章
       
   
         
    
      • Android API 25 源码
        •  
    
      • Android消息机制1-Handler(Java层)
        •  
   
       
      •  
 
     

                            
                        
                    
                    
                    
    
                    
                    
                    
    
                
                
    
                    
                
    
            
        
    
    
    
        
    你可能感兴趣的:(Android Handler 消息机制详述)
    
        
    
            
    
                
      
                    
    • android系统selinux中添加新属性property
                        辉色投像

                        
      1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
      
                    
      • 
                    
    • 2.2.6 通知类控件 Toast、Menu
                        常思行

                        
      本文例程下载：WillFlow_Toast、WillFlowMenu一、什么是Toast？Toast也被叫做吐司，是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，它有如下两个特点：Toast是没有焦点的Toast显示的时间有限过一定的时间就会自动消失所以一般来讲Toast的使用并不会影响我们的正常操作，并且它通常不会占用太大的屏幕空间，有着良好的用户体
      
                    
      • 
                    
    • mac 备份android 手机通讯录导入iphone,iphone如何导出通讯录（轻松教你iPhone备份通讯录的方法）...
                        weixin_39762838
mac备份android手机通讯录导入iphone
                        
      在日新月异的手机更替中，换手机已经成为一个非常稀松平常的事情，但将旧手机上面的通讯录导入到新手机还是让不少小伙伴为难，本篇将给大家详细讲解这方面的知识：“苹果手机通讯录怎么导入到新手机”及“安卓手机通讯录导入到新手机”的方法。一、苹果手机通讯录导入到新手机常用方法(SIM卡导入)在苹果手机主频幕上找到“设置”，单击进入设置菜单，下拉菜单列表，点击“邮件、通讯录、日历”，然后找到“导入SIM卡通讯录
      
                    
      • 
                    
    • android 更改窗口的层次,浮窗开发之窗口层级
                        Ms.Bu
android更改窗口的层次
                        
      最近在项目中遇到了这样的需求：需要在特定的其他应用之上悬浮自己的UI交互(拖动、输入等复杂的UI交互)，和九游的浮窗类似，不过我们的比九游的体验更好，我们越过了很多授权的限制。浮窗效果很多人都知道如何去实现一个简单的浮窗，但是却很少有人去深入的研究背后的流程机制，由于项目中浮窗交互比较复杂，遇到了些坑查看了很多资料，故总结浮窗涉及到的知识点：窗口层级关系(浮窗是如何“浮”的)？浮窗有哪些限制，如何
      
                    
      • 
                    
    • Android应用性能优化
                        轻口味
Android
                        
      Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
      
                    
      • 
                    
    • Android实现监听事件的方法
                        Amy木婉清

                        
      1.通过内部类实现2.通过匿名内部类实现3.通过事件源所在类实现4.通过外部类实现5.布局文件中onclick属性(针对点击事件)1.通过内部类实现代码:privateButtonmBtnEvent;//oncreate中mBtnEvent.setOnClickListener(newOnClick());//内部类实现监听classOnClickimplementsView.OnClickLis
      
                    
      • 
                    
    • 高级UI<第二十四篇>：Android中用到的矩阵常识
                        NoBugException

                        
      （1）定义在数学中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合。由m×n个数aij排成的m行n列的数表称为m行n列的矩阵，简称m×n矩阵。记作：图片.png这m×n个数称为矩阵A的元素，简称为元，数aij位于矩阵A的第i行第j列，称为矩阵A的(i,j)元，以数aij为(i,j)元的矩阵可记为(aij)或(aij)m×n，m×n矩阵A也记作Amn。元素是实数的矩阵称为实矩阵，元素是复
      
                    
      • 
                    
    • RK3229_Android9.0_Box 4G模块EC200A调试
                        suifen_
网络
                        
      0、kernel修改这部分完全可以参考Linux的移植：RK3588EC200A-CN【4G模块】调试_rkec200a-cn-CSDN博客1、修改device/rockchip/rk322xdiff--gita/device.mkb/device.mkindexec6bfaa..e7c32d1100755---a/device.mk+++b/device.mk@@-105,6+105,8@@en
      
                    
      • 
                    
    • kt文件和java文件_Java与Kotlin之间怎样进行互操作
                        铭空间
kt文件和java文件
                        
      Java与Kotlin之间怎样进行互操作发布时间：2021-02-0210:50:43来源：亿速云阅读：98作者：小新这篇文章主要介绍了Java与Kotlin之间怎样进行互操作，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。前言目前kotlin是谷歌首推的开发Android的语言，但由于历史原因，我们绝大部分项目依旧还是以Java为主
      
                    
      • 
                    
    • spring security中几大组件的作用和执行顺序
                        阿信在这里
javaspring
                        
      springsecurity中几大组件的作用和执行顺序在SpringSecurity中，AuthenticationProvider、GroupPermissionEvaluator、PermissionEvaluator、AbstractAuthenticationProcessingFilter、DefaultMethodSecurityExpressionHandler和ManageSecu
      
                    
      • 
                    
    • Android shell 常用 debug 命令
                        晨春计
Audiodebugandroidlinux
                        
      目录1、查看版本2、am命令3、pm命令4、dumpsys命令5、sed命令6、log定位查看APK进程号7、log定位使用场景1、查看版本1.1、Android串口终端执行getpropro.build.version.release#获取Android版本uname-a#查看linux内核版本信息uname-r#单独查看内核版本1.2、linux服务器执行lsb_release-a#查看Lin
      
                    
      • 
                    
    • 2024年最全Flutter如何和Native通信-Android视角，Electron开发Android界面
                        2401_84544531
程序员android面试学习
                        
      总结【Android详细知识点思维脑图（技能树）】其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。虽然Android没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明Android中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪
      
                    
      • 
                    
    • 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
      
                    
      • 
                    
    • 分享一个基于python的电子书数据采集与可视化分析 hadoop电子书数据分析与推荐系统 spark大数据毕设项目（源码、调试、LW、开题、PPT)
                        计算机源码社
Python项目大数据大数据pythonhadoop计算机毕业设计选题计算机毕业设计源码数据分析spark毕设
                        
      作者：计算机源码社个人简介：本人八年开发经验，擅长Java、Python、PHP、.NET、Node.js、Android、微信小程序、爬虫、大数据、机器学习等，大家有这一块的问题可以一起交流！学习资料、程序开发、技术解答、文档报告如需要源码，可以扫取文章下方二维码联系咨询Java项目微信小程序项目Android项目Python项目PHP项目ASP.NET项目Node.js项目选题推荐项目实战|p
      
                    
      • 
                    
    • android ndk 开发jni调用对象方法，数组参数
                        wulongkou
开发问题安卓的事ndkandroidstudiojni
                        
      一、JNI和NDK关系JNI是Java语言提供的Java和C/C++相互沟通的机制，Java可以通过JNI调用本地的C/C++代码，本地的C/C++的代码也可以调用java代码。JNI是本地编程接口，Java和C/C++互相通过的接口。Java通过C/C++使用本地的代码的一个关键性原因在于C/C++代码的高效性。NDK是一系列工具的集合。它提供了一系列的工具，帮助开发者快速开发C（或C++）的动
      
                    
      • 
                    
    • Android jni中数组参数的传递方式
                        lokeyme
Andriodandroid开发JNINDKjavac语言
                        
      1、背景今天调试了一下Androidjni关于Java中调用C代码的程序，发现我的数组参数传递方式不对，导致值传递不正确，我的方法是：C代码，入口函数#include#includejintJava_sony_MedicalRecordDemo_MainActivity_decryptionSuccess(JNIEnv*env,jobjectthiz,jintAttr[]){returnAttr[
      
                    
      • 
                    
    • Java内存模型基础
                        2401_84002271
程序员java学习经验分享
                        
      1.2Java内存模型的抽象结构Java中所有的实例域、静态域和数组元素都存储在堆内存中，堆内存在线程之间共享（文章中用“共享变量”指代）。局部变量(LocalVariables)、方法定义参数(FormalMethodParameters)和异常处理器参数(ExceptionHandlerParameters)不会在线程之间共享，它们不会存在内存可见性问题，因此也不受内存模型的影响。Java线程
      
                    
      • 
                    
    • 1-1.Jetpack 之 Navigation 简单编码模板
                        我命由我12345
Android-Jetpack简化编程javajava-eeandroid-studioandroidstudio安卓androidjetpack
                        
      一、Navigation1、Navigation概述Navigation是Jetpack中的一个重要成员，它主要是结合导航图（NavigationGraph）来控制和简化Fragment之间的导航，即往哪里走，该怎么走2、Navigate引入在模块级build.gradle中引入相关依赖implementation'androidx.navigation:navigation-fragment:2
      
                    
      • 
                    
    • Android JetPack架构——结合记事本Demo一篇打通对Sqlite的增删改查结合常用jetpack架构应用
                        erhtre
程序员androidjetpack架构sqlite
                        
      为什么要用Jetpack?========================================================================关于为什么要用Jetpack，我参考了许多的博客和官方文档，开阔了我对Android生态圈的理解和认识，在Jetpack推出前出现的许许多多强大的第三方框架与语言，典型代表无疑是强大的RxJava在Jetpack仍然有许多粉丝在一
      
                    
      • 
                    
    • Android干净架构MVI模板使用指南
                        井美婵Toby

                        
      Android干净架构MVI模板使用指南android-clean-architecture-mvi-boilerplateAforkofourcleanarchitectureboilerplateusingtheModel-View-Intentpattern项目地址:https://gitcode.com/gh_mirrors/an/android-clean-architecture-mv
      
                    
      • 
                    
    • ⭐Unity 安卓环境中正确地读取和处理 XML 文件
                        惊鸿醉
Unityunityandroidxml
                        
      写了一个选择题Demo，电脑包和编辑器内无问题，但是打包安卓手机之后题目无法正常使用，想到的是安卓环境中正确地读取文件的问题改进方案：1.由于XmlDocument.Load方法在Android上的路径问题（由于文件位于APK内部，无法像在文件系统中那样直接访问），需要先使用UnityWebRequest来异步加载文件内容，然后再解析XML。2.异步处理：修改你的代码，以支持异步文件加载和处理，这
      
                    
      • 
                    
    • 《Android进阶之光》读书笔记
                        soleil雪寂
读书笔记#Android进阶之光
                        
      文章目录第1章Android新特性1.1.Android5.0新特性1.2.RecyclerView1.1.4.3种Notification1.1.5.Toolbar与Palette1.1.6.Palette1.2.Android6.0新特性1.2.2.运行时权限机制1.3.Android7.0新特性第2章MaterialDesign2.2.DesignSupportLibrary常用控件详解第3
      
                    
      • 
                    
    • 《Android进阶之光》— Android 书籍
                        王睿丶
Android永无止境《Android进阶之光》Android书籍Androidphoenix移动开发
                        
      文章目录第1章Android新特性1第2章MaterialDesign48第3章View体系与自定义View87第4章多线程编程165第5章网络编程与网络框架204第6章设计模式271第7章事件总线308第8章函数响应式编程333第9章注解与依赖注入框架382第10章应用架构设计422第11章系统架构与MediaPlayer框架460出版年:2017-7简介：《Android进阶之光》是一本And
      
                    
      • 
                    
    • 《android进阶之光》——多线程编程（上）
                        TAING要一直努力
读书笔记
                        
      今天了解了下多线程编程，知识点如下：进程与线程：进程是什么？线程是什么？进程可以看作是程序的实体，是线程的容器，是受操作系统管理的基本运行单元，例如exe文件就是一个进程。线程是进程运行的一些子任务，是操作系统调度的最小单元，各线程拥有自己的计数器，堆栈，局部变量等，也可以访问线程间共享的内存。线程的状态有哪些？新创建，可运行，等待，超时等待，阻塞，终止怎么创建一个线程？-三种方法第一种，MyTr
      
                    
      • 
                    
    • android进阶之光！Android面试必备的集合源码详解，系列篇
                        程序员Sunbu
程序员Android
                        
      前言面试：如果不准备充分的面试，完全是浪费时间，更是对自己的不负责。文末会给大家分享下我整理的Android面试专题及答案其中大部分都是大企业面试常问的面试题，可以对照这查漏补缺，当然了，这里所列的肯定不可能覆盖全部方式，不过对大家找工作肯定是有帮助！本月飞机到达上海，到今天第6天了，四家大公司华为，小米，映客，抖音，还有二家中小型公司。有几家已经面了几轮，下周还要面，挂了几家，不过目前已经选择了
      
                    
      • 
                    
    • netty-简易聊天
                        2401_84046645
程序员java开发语言
                        
      publicvoidsend(Stringtext){channel.writeAndFlush(Unpooled.copiedBuffer(text.getBytes()));}publicvoidcloseConnect(){send(“bye”);channel.close();}}classMyHandlerextendsChannelInboundHandlerAdapter{@Over
      
                    
      • 
                    
    • Android-悬浮窗功能的实现（附Java、KT实现源码）(1)
                        egrhef
程序员androidjava开发语言
                        
      //获取服务的操作对象valbinder=serviceasFloatWinfowServices.MyBinderbinder.service}overridefunonServiceDisconnected(name:ComponentName){}}overridefunonActivityResult(requestCode:Int,resultCode:Int,data:Intent){
      
                    
      • 
                    
    • Visual Studio中的Android模拟器使用详解
                        wurui8
androidandroidstudioandroidandroid应用
                        
      关注微信号：javalearns随时随地学Java或扫一扫随时随地学JavaMicrosoft本周发布了VisualStudio2015预览版,里面包含Android开发工具.安装的时候,如果选Android开发,VisualStudio会把调试Android应用程序用的VisualStudio模拟器也装上.在介绍这个新模拟器之前,我们先来聊一聊,为什么需要一个新的Android模拟器–当然,你也
      
                    
      • 
                    
    • Unity 热更 之 【HybirdCLR】+【YooAsset】 [安卓 Android端] [代码 + 资源热更] 功能的 简单实现演示
                        仙魁XAN
Unity进阶unityHybirdCLRYooAssetHotUpdate热更新
                        
      Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示目录Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示一、简单介绍二、HybridCLR三、YooAsset四、HybirdCLR引入工程五、YooAsset引入工程六、Python服务器简单构建七、Hybir
      
                    
      • 
                    
    • Android 用线程池实现一个简单的任务队列(Kotlin)
                        深海呐
Android#Android进阶#Kotlinandroidkotlin线程池延时任务队列线程池延时任务
                        
      关于线程池,Kotlin和java的使用方式一样在Android中,很多人喜欢用Handler的postDelayed()去实现延时任务.要使用postDelayed(),去实现延时任务队列,就不可避免要使用递归.但是这样做,代码的简洁性,和书写的简易,就远不如使用线程池.使用线程池的简单程度:privatevalmThreadPool=Executors.newSingleThreadSched
      
                    
      • 
                                
    • jQuery 键盘事件keydown ,keypress ,keyup介绍
                                    107x
jsjquerykeydownkeypresskeyup
                                    
      本文章总结了下些关于jQuery 键盘事件keydown ,keypress ,keyup介绍，有需要了解的朋友可参考。 
一、首先需要知道的是：  1、keydown()  keydown事件会在键盘按下时触发.  2、keyup()     代码如下 复制代码    
$('input').keyup(funciton(){      
      
                                
      • 
                                
    • AngularJS中的Promise
                                    bijian1013
JavaScriptAngularJSPromise
                                    
      一.Promise 
        Promise是一个接口，它用来处理的对象具有这样的特点：在未来某一时刻（主要是异步调用）会从服务端返回或者被填充属性。其核心是，promise是一个带有then()函数的对象。 
        为了展示它的优点，下面来看一个例子，其中需要获取用户当前的配置文件： 
var cu
      
                                
      • 
                                
    • c++ 用数组实现栈类
                                    CrazyMizzz
数据结构C++
                                    
      #include<iostream>
#include<cassert>
using namespace std;

template<class T, int SIZE = 50>
class Stack{
private:
	T list[SIZE];//数组存放栈的元素
	int top;//栈顶位置

public:
	Stack(
      
                                
      • 
                                
    • java和c语言的雷同
                                    麦田的设计者
java递归scaner
                                    
      软件启动时的初始化代码，加载用户信息2015年5月27号 
从头学java二 
1、语言的三种基本结构：顺序、选择、循环。废话不多说，需要指出一下几点： 
     a、return语句的功能除了作为函数返回值以外，还起到结束本函数的功能，return后的语句 
不会再继续执行。 
     b、for循环相比于whi
      
                                
      • 
                                
    • LINUX环境并发服务器的三种实现模型
                                    被触发
linux
                                    
      服务器设计技术有很多，按使用的协议来分有TCP服务器和UDP服务器。按处理方式来分有循环服务器和并发服务器。 
1  循环服务器与并发服务器模型 
在网络程序里面，一般来说都是许多客户对应一个服务器，为了处理客户的请求，对服务端的程序就提出了特殊的要求。 
目前最常用的服务器模型有： 
·循环服务器：服务器在同一时刻只能响应一个客户端的请求 
·并发服务器：服
      
                                
      • 
                                
    • Oracle数据库查询指令
                                    肆无忌惮_
oracle数据库
                                    
      20140920 
  
单表查询 
-- 查询************************************************************************************************************ 
-- 使用scott用户登录 
  
-- 查看emp表 
  
desc emp 
  

      
                                
      • 
                                
    • ext右下角浮动窗口
                                    知了ing
JavaScriptext
                                    
      第一种 
 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/
      
                                
      • 
                                
    • 浅谈REDIS数据库的键值设计
                                    矮蛋蛋
redis
                                    
      http://www.cnblogs.com/aidandan/ 
原文地址：http://www.hoterran.info/redis_kv_design 
 
丰富的数据结构使得redis的设计非常的有趣。不像关系型数据库那样，DEV和DBA需要深度沟通，review每行sql语句，也不像memcached那样，不需要DBA的参与。redis的DBA需要熟悉数据结构，并能了解使用场景。 
 
      
                                
      • 
                                
    • maven编译可执行jar包
                                    alleni123
maven
                                    
      http://stackoverflow.com/questions/574594/how-can-i-create-an-executable-jar-with-dependencies-using-maven 
 
 
<build>
  <plugins>
    <plugin>
      <artifactId>maven-asse
      
                                
      • 
                                
    • 人力资源在现代企业中的作用
                                    百合不是茶
HR 企业管理
                                    
      //人力资源在在企业中的作用人力资源为什么会存在，人力资源究竟是干什么的 人力资源管理是对管理模式一次大的创新，人力资源兴起的原因有以下点： 工业时代的国际化竞争，现代市场的风险管控等等。所以人力资源 在现代经济竞争中的优势明显的存在，人力资源在集团类公司中存在着 明显的优势(鸿海集团)，有一次笔者亲自去体验过红海集团的招聘，只 知道人力资源是管理企业招聘的 当时我被招聘上了，当时给我们培训 的人
      
                                
      • 
                                
    • Linux自启动设置详解
                                    bijian1013
linux
                                    
      linux有自己一套完整的启动体系，抓住了linux启动的脉络，linux的启动过程将不再神秘。 
阅读之前建议先看一下附图。 
本文中假设inittab中设置的init tree为： 
/etc/rc.d/rc0.d
/etc/rc.d/rc1.d
/etc/rc.d/rc2.d
/etc/rc.d/rc3.d
/etc/rc.d/rc4.d
/etc/rc.d/rc5.d
/etc
      
                                
      • 
                                
    • Spring Aop Schema实现
                                    bijian1013
javaspringAOP
                                    
      本例使用的是Spring2.5 
1.Aop配置文件spring-aop.xml 
<?xml version="1.0" encoding="UTF-8"?>  
<beans  
    xmlns="http://www.springframework.org/schema/beans"  
    xmln
      
                                
      • 
                                
    • 【Gson七】Gson预定义类型适配器
                                    bit1129
gson
                                    
      Gson提供了丰富的预定义类型适配器，在对象和JSON串之间进行序列化和反序列化时，指定对象和字符串之间的转换方式， 
  DateTypeAdapter 
  
public final class DateTypeAdapter extends TypeAdapter<Date> {
  public static final TypeAdapterFacto
      
                                
      • 
                                
    • 【Spark八十八】Spark Streaming累加器操作（updateStateByKey)
                                    bit1129
update
                                    
      在实时计算的实际应用中，有时除了需要关心一个时间间隔内的数据，有时还可能会对整个实时计算的所有时间间隔内产生的相关数据进行统计。 
比如： 对Nginx的access.log实时监控请求404时，有时除了需要统计某个时间间隔内出现的次数，有时还需要统计一整天出现了多少次404，也就是说404监控横跨多个时间间隔。 
  
Spark Streaming的解决方案是累加器，工作原理是，定义
      
                                
      • 
                                
    • linux系统下通过shell脚本快速找到哪个进程在写文件
                                    ronin47

                                    
      一个文件正在被进程写 我想查看这个进程 文件一直在增大 找不到谁在写 使用lsof也没找到 
这个问题挺有普遍性的，解决方法应该很多，这里我给大家提个比较直观的方法。 
linux下每个文件都会在某个块设备上存放，当然也都有相应的inode, 那么透过vfs.write我们就可以知道谁在不停的写入特定的设备上的inode。 
幸运的是systemtap的安装包里带了inodewatch.stp，位
      
                                
      • 
                                
    • java-两种方法求第一个最长的可重复子串
                                    bylijinnan
java算法
                                    
      
import java.util.Arrays;
import java.util.Collections;
import java.util.List;


public class MaxPrefix {

	
	public static void main(String[] args) {
		String str="abbdabcdabcx";

      
                                
      • 
                                
    • Netty源码学习-ServerBootstrap启动及事件处理过程
                                    bylijinnan
javanetty
                                    
      Netty是采用了Reactor模式的多线程版本，建议先看下面这篇文章了解一下Reactor模式： 
 
http://bylijinnan.iteye.com/blog/1992325 
 
Netty的启动及事件处理的流程，基本上是按照上面这篇文章来走的 
文章里面提到的操作，每一步都能在Netty里面找到对应的代码 
其中Reactor里面的Acceptor就对应Netty的ServerBo
      
                                
      • 
                                
    • servelt filter listener 的生命周期
                                    cngolon
filterlistenerservelt生命周期
                                    
      1. servlet    当第一次请求一个servlet资源时，servlet容器创建这个servlet实例，并调用他的 init(ServletConfig config)做一些初始化的工作，然后调用它的service方法处理请求。当第二次请求这个servlet资源时，servlet容器就不在创建实例，而是直接调用它的service方法处理请求，也就是说
      
                                
      • 
                                
    • jmpopups获取input元素值
                                    ctrain
JavaScript
                                    
      jmpopups 获取弹出层form表单 
首先，我有一个div，里面包含了一个表单，默认是隐藏的，使用jmpopups时，会弹出这个隐藏的div，其实jmpopups是将我们的代码生成一份拷贝。 
当我直接获取这个form表单中的文本框时，使用方法：$('#form input[name=test1]').val()；这样是获取不到的。 
我们必须到jmpopups生成的代码中去查找这个值，$(
      
                                
      • 
                                
    • vi查找替换命令详解
                                    daizj
linux正则表达式替换查找vim
                                    
      一、查找 
 
查找命令 
 
/pattern<Enter> ：向下查找pattern匹配字符串 
?pattern<Enter>：向上查找pattern匹配字符串 
使用了查找命令之后，使用如下两个键快速查找： 
n：按照同一方向继续查找 
N：按照反方向查找 
 
字符串匹配 
 
pattern是需要匹配的字符串，例如： 
 
1:  /abc<En
      
                                
      • 
                                
    • 对网站中的js,css文件进行打包
                                    dcj3sjt126com
PHP打包
                                    
      一，为什么要用smarty进行打包 
apache中也有给js,css这样的静态文件进行打包压缩的模块，但是本文所说的不是以这种方式进行的打包，而是和smarty结合的方式来把网站中的js,css文件进行打包。 
为什么要进行打包呢，主要目的是为了合理的管理自己的代码 。现在有好多网站，你查看一下网站的源码的话，你会发现网站的头部有大量的JS文件和CSS文件，网站的尾部也有可能有大量的J
      
                                
      • 
                                
    • php Yii: 出现undefined offset 或者 undefined index解决方案
                                    dcj3sjt126com
undefined
                                    
      在开发Yii 时，在程序中定义了如下方式： 
       if($this->menuoption[2] === 'test')，那么在运行程序时会报：undefined offset:2，这样的错误主要是由于php.ini 里的错误等级太高了，在windows下错误等级
      
                                
      • 
                                
    • linux 文件格式（1） sed工具
                                    eksliang
linuxlinux sed工具sed工具linux sed详解
                                    
      转载请出自出处：
http://eksliang.iteye.com/blog/2106082  
简介 
      sed 是一种在线编辑器，它一次处理一行内容。处理时，把当前处理的行存储在临时缓冲区中，称为“模式空间”（pattern space），接着用sed命令处理缓冲区中的内容，处理完成后，把缓冲区的内容送往屏幕。接着处理下一行，这样不断重复，直到文件末尾
      
                                
      • 
                                
    • Android应用程序获取系统权限
                                    gqdy365
android
                                    
      引用   
如何使Android应用程序获取系统权限 
 
 
        第一个方法简单点，不过需要在Android系统源码的环境下用make来编译： 
 
        1. 在应用程序的AndroidManifest.xml中的manifest节点
      
                                
      • 
                                
    • HoverTree开发日志之验证码
                                    hvt
.netC#asp.nethovertreewebform
                                    
      HoverTree是一个ASP.NET的开源CMS，目前包含文章系统，图库和留言板功能。代码完全开放，文章内容页生成了静态的HTM页面，留言板提供留言审核功能，文章可以发布HTML源代码，图片上传同时生成高品质缩略图。推出之后得到许多网友的支持，再此表示感谢！留言板不断收到许多有益留言，但同时也有不少广告，因此决定在提交留言页面增加验证码功能。ASP.NET验证码在网上找，如果不是很多，就是特别多
      
                                
      • 
                                
    • JSON API：用 JSON 构建 API 的标准指南中文版
                                    justjavac
json
                                    
      译文地址：https://github.com/justjavac/json-api-zh_CN 
如果你和你的团队曾经争论过使用什么方式构建合理 JSON 响应格式， 那么 JSON API 就是你的 anti-bikeshedding 武器。 
通过遵循共同的约定，可以提高开发效率，利用更普遍的工具，可以是你更加专注于开发重点：你的程序。 
基于 JSON API 的客户端还能够充分利用缓存，
      
                                
      • 
                                
    • 数据结构随记_2
                                    lx.asymmetric
数据结构笔记
                                    
      第三章 栈与队列 
一．简答题 
1. 在一个循环队列中，队首指针指向队首元素的  前一个    位置。  
2.在具有n个单元的循环队列中，队满时共有  n-1  个元素。  
3. 向栈中压入元素的操作是先  移动栈顶指针&n
      
                                
      • 
                                
    • Linux下的监控工具dstat
                                    网络接口
linux
                                    
      1) 工具说明dstat是一个用来替换 vmstat,iostat netstat,nfsstat和ifstat这些命令的工具, 是一个全能系统信息统计工具. 与sysstat相比, dstat拥有一个彩色的界面, 在手动观察性能状况时, 数据比较显眼容易观察; 而且dstat支持即时刷新, 譬如输入dstat 3, 即每三秒收集一次, 但最新的数据都会每秒刷新显示. 和sysstat相同的是, 
      
                                
      • 
                                
    • C 语言初级入门--二维数组和指针
                                    1140566087
二维数组c/c++指针
                                    
      /* 
 二维数组的定义和二维数组元素的引用 
 
 二维数组的定义： 
 当数组中的每个元素带有两个下标时，称这样的数组为二维数组； 
 (逻辑上把数组看成一个具有行和列的表格或一个矩阵); 
 语法： 
 类型名 数组名[常量表达式1][常量表达式2] 
 
 二维数组的引用： 
 引用二维数组元素时必须带有两个下标，引用形式如下： 
 例如： 
 int a[3][4];  引用：
      
                                
      • 
                                
    • 10点睛Spring4.1-Application Event
                                    wiselyman
application
                                    
      10.1 Application Event 
 
 Spring使用Application Event给bean之间的消息通讯提供了手段 
 应按照如下部分实现bean之间的消息通讯 
   
   继承ApplicationEvent类实现自己的事件 
   实现继承ApplicationListener接口实现监听事件 
   使用ApplicationContext发布消息 
    
 
      
                                
      •