class DownloadTask extends AsyncTask<String, Integer, String> {

        @Override
        protected String doInBackground(String... params) {
            String result = "";
            OutputStream output = null;
            try {
                URL url = new URL(params[0]);
                // 创建一个HttpURLConnection连接
                URLConnection urlConn = (URLConnection ) url
                        .openConnection();
              
                InputStream input = urlConn.getInputStream();

                // 文件夹
                File dir = new File(Constant.K0_VOICE_DIR);
                if (!dir.exists()) {
                    dir.mkdirs();
                }
                // 本地文件
                File file = new File(Constant.K0_VOICE_DIR + params[1]);
                if (!file.exists()) {
                    file.createNewFile();
                    // 写入本地
                    output = new FileOutputStream(file);
                    result = file.getAbsolutePath();
                    byte buffer[] = new byte[4*1024];
                    int inputSize = -1;
                    while ((inputSize = input.read(buffer)) != -1) {
                        output.write(buffer, 0, inputSize);
                    }
                    output.flush();
                }

            } catch (MalformedURLException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    output.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            return result;
        }

        @Override
        protected void onPreExecute() {
            super.onPreExecute();
        }

        @Override
        protected void onPostExecute(String result) {

         //下载完成.....

            super.onPostExecute(result);
        }
    }

public String getRequests() throws IOException {
        OkHttpClient client = new OkHttpClient();

        String url = "http://www.baidu.com";
        Request request = new Request.Builder()
                .url(url)
                .build();

        Response response = client.newCall(request).execute();
        return response.body().string();
 }

final MediaType JSON = MediaType.parse("application/json; charset=utf-8");

        String json = "http://www.roundsapp.com/post";
        String url = bowlingJson("Jesse","Jake");//json字符串

        OkHttpClient client = new OkHttpClient();
        RequestBody body = RequestBody.create(JSON,json);

        Request request = new Request.Builder()
                .url(url)
                .post(body)
                .build();

        Response response = client.newCall(request).execute();
        return response.body().string();

@Override public Response execute() throws IOException {
    //1.判断是否执行过，每个Call请求只能请求一次，如果需要重复执行可以使用clone 方法
    synchronized (this) {
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }
    captureCallStackTrace();
    timeout.enter();
    eventListener.callStart(this);
    try {
        //2.获取分发器 dispatcher, 执行 execute
      client.dispatcher().executed(this);
        //3.获取网络请求的结果
      Response result = getResponseWithInterceptorChain();
      if (result == null) throw new IOException("Canceled");
      return result;
    } catch (IOException e) {
      e = timeoutExit(e);
      eventListener.callFailed(this, e);
      throw e;
    } finally {
        //4.最后通知 dispatcher 执行完毕
      client.dispatcher().finished(this);
    }
  }

@Override public RealCall clone() {
    return RealCall.newRealCall(client, originalRequest, forWebSocket);
  }

//当异步线程执行时，会依照不同的策略执行
* Policy on when async requests are executed.

Response getResponseWithInterceptorChain() throws IOException {
   // Build a full stack of interceptors.一个集合存储所有的拦截器啊
   List<Interceptor> interceptors = new ArrayList<>();
    //用户自定义的拦截器，能拦截所有的请求
   interceptors.addAll(client.interceptors());
    //猜测是重试机制
   interceptors.add(retryAndFollowUpInterceptor);
    //请求的头信息，cookie,gzip
   interceptors.add(new BridgeInterceptor(client.cookieJar()));
    //猜测是缓存
   interceptors.add(new CacheInterceptor(client.internalCache()));
    //开始与目标服务器建立连接，获得RealConnection
   interceptors.add(new ConnectInterceptor(client));
   if (!forWebSocket) {
       //用户自定义的 interceptor, 仅在生产网络请求时生效
     interceptors.addAll(client.networkInterceptors());//猜测是网络请求
   }
    //向服务器发出一次网络请求的地方
   interceptors.add(new CallServerInterceptor(forWebSocket));

   Interceptor.Chain chain = new RealInterceptorChain(interceptors, null, null, null, 0,
       originalRequest, this, eventListener, client.connectTimeoutMillis(),
       client.readTimeoutMillis(), client.writeTimeoutMillis());

   return chain.proceed(originalRequest);
 }

/**
 * A concrete interceptor chain that carries the entire interceptor chain: all application
 * interceptors, the OkHttp core, all network interceptors, and finally the network caller.
 */
public final class RealInterceptorChain implements Interceptor.Chain {
  private final List<Interceptor> interceptors;//所有的拦截器集合
  private final StreamAllocation streamAllocation;
  private final HttpCodec httpCodec;
  private final RealConnection connection;
  private final int index;
  private final Request request;
  private final Call call;
  private final EventListener eventListener;
  private final int connectTimeout;
  private final int readTimeout;
  private final int writeTimeout;
  private int calls;

  public RealInterceptorChain(List<Interceptor> interceptors, StreamAllocation streamAllocation,
      HttpCodec httpCodec, RealConnection connection, int index, Request request, Call call,
      EventListener eventListener, int connectTimeout, int readTimeout, int writeTimeout) {
    this.interceptors = interceptors;
    this.connection = connection;
    this.streamAllocation = streamAllocation;
    this.httpCodec = httpCodec;
    this.index = index;
    this.request = request;
    this.call = call;
    this.eventListener = eventListener;
    this.connectTimeout = connectTimeout;
    this.readTimeout = readTimeout;
    this.writeTimeout = writeTimeout;
  }

  @Override public Connection connection() {
    return connection;
  }

  @Override public int connectTimeoutMillis() {
    return connectTimeout;
  }

  @Override public Interceptor.Chain withConnectTimeout(int timeout, TimeUnit unit) {
    int millis = checkDuration("timeout", timeout, unit);
    return new RealInterceptorChain(interceptors, streamAllocation, httpCodec, connection, index,
        request, call, eventListener, millis, readTimeout, writeTimeout);
  }

  @Override public int readTimeoutMillis() {
    return readTimeout;
  }

  @Override public Interceptor.Chain withReadTimeout(int timeout, TimeUnit unit) {
    int millis = checkDuration("timeout", timeout, unit);
    return new RealInterceptorChain(interceptors, streamAllocation, httpCodec, connection, index,
        request, call, eventListener, connectTimeout, millis, writeTimeout);
  }

  @Override public int writeTimeoutMillis() {
    return writeTimeout;
  }

  @Override public Interceptor.Chain withWriteTimeout(int timeout, TimeUnit unit) {
    int millis = checkDuration("timeout", timeout, unit);
    return new RealInterceptorChain(interceptors, streamAllocation, httpCodec, connection, index,
        request, call, eventListener, connectTimeout, readTimeout, millis);
  }

  public StreamAllocation streamAllocation() {
    return streamAllocation;
  }

  public HttpCodec httpStream() {
    return httpCodec;
  }

  @Override public Call call() {
    return call;
  }

  public EventListener eventListener() {
    return eventListener;
  }

  @Override public Request request() {
    return request;
  }

  @Override public Response proceed(Request request) throws IOException {
    return proceed(request, streamAllocation, httpCodec, connection);
  }

  public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec,
      RealConnection connection) throws IOException {
    if (index >= interceptors.size()) throw new AssertionError();

    calls++;

    // If we already have a stream, confirm that the incoming request will use it.
    if (this.httpCodec != null && !this.connection.supportsUrl(request.url())) {
      throw new IllegalStateException("network interceptor " + interceptors.get(index - 1)
          + " must retain the same host and port");
    }

    // If we already have a stream, confirm that this is the only call to chain.proceed().
    if (this.httpCodec != null && calls > 1) {
      throw new IllegalStateException("network interceptor " + interceptors.get(index - 1)
          + " must call proceed() exactly once");
    }

    // Call the next interceptor in the chain.
    RealInterceptorChain next = new RealInterceptorChain(interceptors, streamAllocation, httpCodec,
        connection, index + 1, request, call, eventListener, connectTimeout, readTimeout,
        writeTimeout);
    Interceptor interceptor = interceptors.get(index);
    Response response = interceptor.intercept(next);

    // Confirm that the next interceptor made its required call to chain.proceed().
    if (httpCodec != null && index + 1 < interceptors.size() && next.calls != 1) {
      throw new IllegalStateException("network interceptor " + interceptor
          + " must call proceed() exactly once");
    }

    // Confirm that the intercepted response isn't null.
    if (response == null) {
      throw new NullPointerException("interceptor " + interceptor + " returned null");
    }

    if (response.body() == null) {
      throw new IllegalStateException(
          "interceptor " + interceptor + " returned a response with no body");
    }

    return response;
  }
}

/**
 * This interceptor recovers from failures and follows redirects as necessary. It may throw an
 * {@link IOException} if the call was canceled.
 这个拦截器必要时会重试和重定向，可能会抛出异常在call被取消的时候
 */
public final class RetryAndFollowUpInterceptor implements Interceptor {
....
    
    @Override public Response intercept(Chain chain) throws IOException {
    Request request = chain.request();
    RealInterceptorChain realChain = (RealInterceptorChain) chain;
    Call call = realChain.call();
    EventListener eventListener = realChain.eventListener();

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

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

for (int j = 0; j < src.length; ++j) {
    
     Entry<K,V> e = src[j];//src 表示原table
        while(null != e) {
        //此处表示取出下一个位置的Entry(键值对)
        Entry<K<V> next = e.next;
        //计算得出在扩容后新数组table中的下标，因为扩容后要重新计算下标
        //未扩容前下标:index = hash(key) & (length-1)
        int i= indexFor(e.hash,newCapacity);
        //根据下标取出在新表newTable中的Entry<K,V>
        e.next = newTable[i];
        //将当前e 赋值给newTable[i](Entry<K,V>)
        newTable[i] = e;
		//将下一个next.Entry 赋值给当前的e	
        e = next;
    }
}

for (int j = 0; j < src.length; ++j) {
    
     Entry<K,V> e = src[j];//src 表示原table
        while(null != e) {
        //next = Entry2
        Entry<K<V> next = e.next;
        //假设计算结果为3；循环第二次：假设Entry2计算的位置也是3
        int i= indexFor(e.hash,newCapacity);
       //第一次Entry1.next = newTable[3]，此时newTable[3]还为null；所以是Entry1.next地址指向null
       //循环第二次：Entry2.next = Entry1
        e.next = newTable[i];
       //newTable[3] = Entry1, 此时e是 Entry1;
       //循环第二次： newTable[3] = Entry2
        newTable[i] = e;
		//Entry1 = Entry2,e 指向了Entry2,好再次循环;
        //循环第二次：e = null,跳出循环
        e = next;
    }
}

for (int j = 0; j < src.length; ++j) {
    //src 表示原table
     Entry<K,V> e = src[j];
        while(null != e) {
            Entry<K<V> next = e.next;//假设线程一执行到这里就被调度挂起了
            int i= indexFor(e.hash,newCapacity);
            e.next = newTable[i];
            newTable[i] = e;
            e = next;
    }
}

while(null != e) {//再次循环，e:key(7) next:key(3)
    		//假设线程一执行到这里就被调度挂起了,开始继续执行
    		//第二次循环：next = key(3),next 指向key(3)
    		//e:key(3) next:null
           Entry<K<V> next = e.next;
           int i= indexFor(e.hash,newCapacity);//根据线程二的计算不难推出线程一计算的i = 3
           //key(7).next 指向 key(3)
    		//key(3).next 指向 key(7)
           e.next = newTable[i];
    		//first :   newTable[3] = key(3)
    		//second ： newTable[3] = key(7)
    		//third :   newTable[3] = key(3)
           newTable[i] = e;
    		//e 指向key(7)
    		//e = key(3)
    		//e = null//退出循环
           e = next

key(7).next 指向 key(3)
key(3).next 指向 key(7)

while(null != e) {
            Entry<K<V> next = e.next;//第一次的时候，线程一被卡住在这里，当时状态是：e:key(3),next:key(7)  这应该都没什么问题
    
    		//根据线程二的计算，这个值也应该是int i = 3
            int i= indexFor(e.hash,newCapacity);
    		//key(3).next = newTable[3], 此时newTable[3]为null, key(3).next指向null
            e.next = newTable[i];
    		//newTable[3] = key(3)
            newTable[i] = e;
    		//e = key(7),e指向key(7)
            e = next
}

while(null != e) {//e:key(7) 
    		//next = key(3)
            Entry<K<V> next = e.next;
    		//int i = 3
            int i= indexFor(e.hash,newCapacity);
    		//key(7).next = key(3) , key(7).next指向key(3)
            e.next = newTable[i];
    		//newTable[3] = key(7)
            newTable[i] = e;
    		//e = key(3) e指向key(3),不为null,循环继续
            e = next
}

while(null != e) {//e:key(3) 
    		//next = null next指向null
            Entry<K<V> next = e.next;
    		//int i = 3
            int i= indexFor(e.hash,newCapacity);
    		//key(3).next = key(7) key(3).next指向key(7)
            e.next = newTable[i];
    		//newTable[3] = key(3)
            newTable[i] = e;
    		//e = null, 循环结束
            e = next
}

//key(7).next指向key(3)
//key(3).next指向key(7)    这里产生死循环

i = (n-1) & hash

public void getInfo(){
        try{
            Class<?> class1 = Class.forName("android.support.v7.widget.RecyclerView");
            Field field = class1.getDeclaredField("mRecycler");
            field.setAccessible(true);

            RecyclerView.Recycler recycler = (RecyclerView.Recycler) field.get(recyclerView);
            Field field1 = recycler.getClass().getDeclaredField("mCachedViews");
            field1.setAccessible(true);
            ArrayList<RecyclerView.ViewHolder> mCachedViews = (ArrayList<RecyclerView.ViewHolder>) field1.get(recycler);

            for(int i=0;i<mCachedViews.size();i++){

                Log.i("xx","mCachedViews::"+mCachedViews.get(i));
            }


            RecyclerView.RecycledViewPool viewPool = recyclerView.getRecycledViewPool();
            //这里之所以能获取到 RecycledViewPool中的mScrpa，需要新建一个android.support.v7.widget包，将该类放入该包下即可访问到。
            SparseArray<RecyclerView.RecycledViewPool.ScrapData> list = viewPool.mScrap;
            //这里传入的类型type 是我在adapter中定义的，如下：
            //@Override
            //public int getItemViewType(int position) {
                //return 666;
            //}
            RecyclerView.RecycledViewPool.ScrapData spra = list.get(666);

            Field field2 = spra.getClass().getDeclaredField("mScrapHeap");
            ArrayList<RecyclerView.ViewHolder> mScrapHeap= (ArrayList<RecyclerView.ViewHolder>) field2.get(spra);
            for(int i=0;i<mScrapHeap.size();i++){
                    Log.i("xx","mScrapHeapInfo::"+mScrapHeap.get(i));
            }
            Log.i("xx","=================================================");
        }catch (Exception e) {
            Log.i("xx", "error");
            e.printStackTrace();
        }
    }

recyclerView.addOnScrollListener(new RecyclerView.OnScrollListener() {
            @Override
            public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
                super.onScrolled(recyclerView, dx, dy);
//                int recycleCount = recyclerView.getRecycledViewPool().getRecycledViewCount(666);
//                Log.i("xx","recyclePoolCount::"+recycleCount);

                getInfo();
            }
        });

@Override
  public void onViewRecycled(ViewHolder holder) {
      Log.i("xx","holder被回收了"+holder);//可以拿到被回收holder的相关信息
      super.onViewRecycled(holder);
  }

public class ConcurrentHashMap<K,V> extends AbstractMap<K,V>
    implements ConcurrentMap<K,V>, Serializable {
    .....
 }

public int size() {
    // Try a few times to get accurate count. On failure due to
   // continuous async changes in table, resort to locking.
   final Segment<K,V>[] segments = this.segments;
    int size;
    boolean overflow; // true if size overflows 32 bits
    long sum;         // sum of modCounts
    long last = 0L;   // previous sum
    int retries = -1; // first iteration isn't retry
    try {
        for (;;) {
            if (retries++ == RETRIES_BEFORE_LOCK) {
                for (int j = 0; j < segments.length; ++j)
                    ensureSegment(j).lock(); // force creation
            }
            sum = 0L;
            size = 0;
            overflow = false;
            for (int j = 0; j < segments.length; ++j) {
                Segment<K,V> seg = segmentAt(segments, j);
                if (seg != null) {
                    sum += seg.modCount;
                    int c = seg.count;
                    if (c < 0 || (size += c) < 0)
                        overflow = true;
                }
            }
            if (sum == last)
                break;
            last = sum;
        }
    } finally {
        if (retries > RETRIES_BEFORE_LOCK) {
            for (int j = 0; j < segments.length; ++j)
                segmentAt(segments, j).unlock();
        }
    }
    return overflow ? Integer.MAX_VALUE : size;
}