Handler handler = new Handler(){
    @Override
    public void handleMessage(Message msg) {
        super.handleMessage(msg);
    }
};
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    new Thread(new Runnable() {
        @Override
        public void run() {

            Message msg = handler.obtainMessage();
            handler.sendMessage(msg);
        }
    }).start();
}

  public static void loop() {
    
        final Looper me = myLooper();
        //有looper才能循环吧，获取当前线程的 looper
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        // 获取当前looper 中的 MessageQueue 
        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);
                end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }
。。。

            msg.recycleUnchecked();
        }
    }

经过看源码 msg.target 的赋值是在这做的 Message 类中

    public static Message obtain(Handler h, int what,
            int arg1, int arg2, Object obj) {
        Message m = obtain();
        m.target = h;
        m.what = what;
        m.arg1 = arg1;
        m.arg2 = arg2;
        m.obj = obj;

        return m;
    }



    public static Message obtain() {
        synchronized (sPoolSync) {
            if (sPool != null) {
                Message m = sPool;
                sPool = m.next;
                m.next = null;
                m.flags = 0; // clear in-use flag
                sPoolSize--;
                return m;
            }
        }
        return new Message();
    }

  public void dispatchMessage(Message msg) {
      if (msg.callback != null) {
          handleCallback(msg);
      } else {
          if (mCallback != null) {
              if (mCallback.handleMessage(msg)) {
                  return;
              }
          }
          handleMessage(msg);
      }
  }

先判断msg.的callback是否为空，接着再判断handler的mCallBack是否为空，
如果都为空，所以执行handleMessage()，这里面是一个空方法，需要我们重写。
上面那个 msg.callback 和  mCallback 怎么用呢？请接着往下看

  
     handler.post(new Runnable() {
           @Override
           public void run() {
               
           }
       });


   public final boolean post(Runnable r)
    {
       return  sendMessageDelayed(getPostMessage(r), 0);
    }
    
    
    
    private static Message getPostMessage(Runnable r) {
        Message m = Message.obtain();
        m.callback = r;
        return m;
    }
    
    最后把 Runnable 的callback 赋值成 Message 的 callback  
    再结合上面的 dispatchMessage 方法  ， msg.callback 就不是空了 
    
    
    private static void handleCallback(Message message) {
        message.callback.run();
    }

调用 callback 的 run 方法。 handler 的 post 方法就这这么简单，
把一个可以可以执行的 runnable 放到 msg 的 callback 中抛到主线程，
调用 run 方法执行，然后这个 run 方法中的内容就是在主线程执行的了。



接下来看 创建Handler 的另一种方式，可以有个 callback 的写法， 这个时候
handler 中的 mCallback 就不为空了， 就可以执行了，直接执行 callback 中的方法即可
这个也是在当前线程（主线程）执行的。
    Handler handler = new Handler(new Handler.Callback() {
        @Override
        public boolean handleMessage(Message msg) {
            return false;
        }
    });

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

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


最后都会调用到 

  private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }
    
    接着看 queue.enqueueMessage 是怎么处理的呢
    
    
    
     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;
            Message p = mMessages;
            boolean needWake;
            if (p == null || when == 0 || when < p.when) {
                // 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 (;;) {
                    prev = p;
                    p = p.next;
                    if (p == null || when < p.when) {
                        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;
    }

主要目的就是把 Message 添加到 MessageQueue 中 
如果消息在此时queue 中没有消息，就加入队列后 nativeWake  唤醒，通知取消息，
如果队列中有消息，就加入进去。

@Override
public final void runOnUiThread(Runnable action) {
    if (Thread.currentThread() != mUiThread) {
        mHandler.post(action);
    } else {
        action.run();
    }
}

public static final long DEFAULT_MILLISECONDS = 10_000L;
    private volatile static OkHttpUtils mInstance;
    private OkHttpClient mOkHttpClient;
    private Platform mPlatform;

    public OkHttpUtils(OkHttpClient okHttpClient)
    {
        if (okHttpClient == null)
        {
            mOkHttpClient = new OkHttpClient();
        } else
        {
            mOkHttpClient = okHttpClient;
        }

        mPlatform = Platform.get();
    }


    public static OkHttpUtils initClient(OkHttpClient okHttpClient)
    {
        if (mInstance == null)
        {
            synchronized (OkHttpUtils.class)
            {
                if (mInstance == null)
                {
                    mInstance = new OkHttpUtils(okHttpClient);
                }
            }
        }
        return mInstance;
    }

    public static OkHttpUtils getInstance()
    {
        return initClient(null);
    }


    public Executor getDelivery()
    {
        return mPlatform.defaultCallbackExecutor();
    }

    public OkHttpClient getOkHttpClient()
    {
        return mOkHttpClient;
    }

    public static GetBuilder get()
    {
        return new GetBuilder();
    }

    public static PostStringBuilder postString()
    {
        return new PostStringBuilder();
    }

    public static PostFileBuilder postFile()
    {
        return new PostFileBuilder();
    }

    public static PostFormBuilder post()
    {
        return new PostFormBuilder();
    }

    public static OtherRequestBuilder put()
    {
        return new OtherRequestBuilder(METHOD.PUT);
    }

    public static HeadBuilder head()
    {
        return new HeadBuilder();
    }

    public static OtherRequestBuilder delete()
    {
        return new OtherRequestBuilder(METHOD.DELETE);
    }

    public static OtherRequestBuilder patch()
    {
        return new OtherRequestBuilder(METHOD.PATCH);
    }

...

private static final Platform PLATFORM = findPlatform();

public static Platform get()
{
    L.e(PLATFORM.getClass().toString());
    return PLATFORM;
}

private static Platform findPlatform()
{
    try
    {
        Class.forName("android.os.Build");
        if (Build.VERSION.SDK_INT != 0)
        {
            return new Android();
        }
    } catch (ClassNotFoundException ignored)
    {
    }
    return new Platform();
}


static class Android extends Platform
{
    @Override
    public Executor defaultCallbackExecutor()
    {
        return new MainThreadExecutor();
    }

    static class MainThreadExecutor implements Executor
    {
        private final Handler handler = new Handler(Looper.getMainLooper());

        @Override
        public void execute(Runnable r)
        {
            handler.post(r);
        }
    }
}

public void sendSuccessResultCallback(final Object object, final Callback callback, final int id)
{
    if (callback == null) return;
    mPlatform.execute(new Runnable()
    {
        @Override
        public void run()
        {
            callback.onResponse(object, id);
            callback.onAfter(id);
        }
    });
}

@Override public void enqueue(Callback responseCallback) {
  synchronized (this) {
    if (executed) throw new IllegalStateException("Already Executed");
    executed = true;
  }
  captureCallStackTrace();
  client.dispatcher().enqueue(new AsyncCall(responseCallback));
}

@Override public Response intercept(Chain chain) throws IOException {
   Request request = chain.request();

   streamAllocation = new StreamAllocation(
       client.connectionPool(), createAddress(request.url()), callStackTrace);

   int followUpCount = 0;
   Response priorResponse = null;
   while (true) {
     if (canceled) {
       streamAllocation.release();
       throw new IOException("Canceled");
     }

     Response response = null;
     boolean releaseConnection = true;
     try {
       response = ((RealInterceptorChain) chain).proceed(request, streamAllocation, null, null);
       releaseConnection = false;
     } catch (RouteException e) {
       // The attempt to connect via a route failed. The request will not have been sent.
       if (!recover(e.getLastConnectException(), false, request)) {
         throw e.getLastConnectException();
       }
       //如果出现异常 不释放连接， 继续重试
       releaseConnection = false;
       continue;
     } catch (IOException e) {
       // An attempt to communicate with a server failed. The request may have been sent.
       boolean requestSendStarted = !(e instanceof ConnectionShutdownException);
       //如果出现异常 不释放连接， 继续重试
       if (!recover(e, requestSendStarted, request)) throw e;
       releaseConnection = false;
       continue;
     } finally {
       // We're throwing an unchecked exception. Release any resources.
       if (releaseConnection) {
         streamAllocation.streamFailed(null);
         streamAllocation.release();
       }
     }

     // Attach the prior response if it exists. Such responses never have a body.
     if (priorResponse != null) {
       response = response.newBuilder()
           .priorResponse(priorResponse.newBuilder()
                   .body(null)
                   .build())
           .build();
     }

     Request followUp = followUpRequest(response);

     if (followUp == null) {
       if (!forWebSocket) {
         streamAllocation.release();
       }
       return response;
     }

     closeQuietly(response.body());

//重试次数大于20次 ，不再试了，释放连接，
     if (++followUpCount > MAX_FOLLOW_UPS) {
       streamAllocation.release();
       throw new ProtocolException("Too many follow-up requests: " + followUpCount);
     }

     if (followUp.body() instanceof UnrepeatableRequestBody) {
       streamAllocation.release();
       throw new HttpRetryException("Cannot retry streamed HTTP body", response.code());
     }

     if (!sameConnection(response, followUp.url())) {
       streamAllocation.release();
       streamAllocation = new StreamAllocation(
           client.connectionPool(), createAddress(followUp.url()), callStackTrace);
     } else if (streamAllocation.codec() != null) {
       throw new IllegalStateException("Closing the body of " + response
           + " didn't close its backing stream. Bad interceptor?");
     }

     request = followUp;
     priorResponse = response;
   }
 }

/** 空闲 socket 最大连接数 */
 private final int maxIdleConnections;
 socket 的 keepAlive 时间
 private final long keepAliveDurationNs;
 private final Deque<RealConnection> connections = new ArrayDeque<>();
 final RouteDatabase routeDatabase = new RouteDatabase();
 boolean cleanupRunning;
 
 
 public ConnectionPool() {
   this(5, 5, TimeUnit.MINUTES);
 }

 public ConnectionPool(int maxIdleConnections, long keepAliveDuration, TimeUnit timeUnit) {
   this.maxIdleConnections = maxIdleConnections;
   this.keepAliveDurationNs = timeUnit.toNanos(keepAliveDuration);

   // Put a floor on the keep alive duration, otherwise cleanup will spin loop.
   if (keepAliveDuration <= 0) {
     throw new IllegalArgumentException("keepAliveDuration <= 0: " + keepAliveDuration);
   }
 }

private final Runnable cleanupRunnable = new Runnable() {
  @Override public void run() {
    while (true) {
      long waitNanos = cleanup(System.nanoTime());
      if (waitNanos == -1) return;
      if (waitNanos > 0) {
        long waitMillis = waitNanos / 1000000L;
        waitNanos -= (waitMillis * 1000000L);
        synchronized (ConnectionPool.this) {
          try {
            ConnectionPool.this.wait(waitMillis, (int) waitNanos);
          } catch (InterruptedException ignored) {
          }
        }
      }
    }
  }
};
线程会不停的调用cleanup方法进行清理， 并返回下次需要清理的间隔时间， 然后调用 wait方法进行等待，当时间到了之后再次进行清理。 一直这样下去。

会调用 cleanup方法，下面是cleanup方法


 long cleanup(long now) {
  int inUseConnectionCount = 0;
  int idleConnectionCount = 0;
  RealConnection longestIdleConnection = null;
  long longestIdleDurationNs = Long.MIN_VALUE;

  // Find either a connection to evict, or the time that the next eviction is due.
  synchronized (this) {
    for (Iterator<RealConnection> i = connections.iterator(); i.hasNext(); ) {
      RealConnection connection = i.next();

      // If the connection is in use, keep searching.
      if (pruneAndGetAllocationCount(connection, now) > 0) {
        inUseConnectionCount++;
        continue;
      }

      idleConnectionCount++;

      // If the connection is ready to be evicted, we're done.
      long idleDurationNs = now - connection.idleAtNanos;
      if (idleDurationNs > longestIdleDurationNs) {
        longestIdleDurationNs = idleDurationNs;
        longestIdleConnection = connection;
      }
    }

    if (longestIdleDurationNs >= this.keepAliveDurationNs
        || idleConnectionCount > this.maxIdleConnections) {
      // We've found a connection to evict. Remove it from the list, then close it below (outside
      // of the synchronized block).
      connections.remove(longestIdleConnection);
    } else if (idleConnectionCount > 0) {
      // A connection will be ready to evict soon.
      return keepAliveDurationNs - longestIdleDurationNs;
    } else if (inUseConnectionCount > 0) {
      // All connections are in use. It'll be at least the keep alive duration 'til we run again.
      return keepAliveDurationNs;
    } else {
      // No connections, idle or in use.
      cleanupRunning = false;
      return -1;
    }
  }

  closeQuietly(longestIdleConnection.socket());

  // Cleanup again immediately.
  return 0;
}