任建勇的博客

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null)  //从数组中取出node赋值给p
        tab[i] = newNode(hash, key, value, null);
    ......
}

//生成目录位于module-kotlin/build/generated/source/kapt/debug/com/alibaba/android/arouter/routes
public class ARouter$$Root$$modulekotlin implements IRouteRoot {
  @Override
  public void loadInto(Map<String, Class<? extends IRouteGroup>> routes) {
    routes.put("one", ARouter$$Group$$one.class);
    routes.put("two", ARouter$$Group$$two.class);
  }
}

public class ARouter$$Group$$one implements IRouteGroup {
  @Override
  public void loadInto(Map<String, RouteMeta> atlas) {
    atlas.put("/one/first", RouteMeta.build(RouteType.ACTIVITY, FistActivity.class, "/one/first", "one", null, -1, -2147483648));
    atlas.put("/one/second", RouteMeta.build(RouteType.ACTIVITY, SecondActivity.class, "/one/second", "two", null, -1, -2147483648));
  }
}

public class ARouter$$Group$$two implements IRouteGroup {
  @Override
  public void loadInto(Map<String, RouteMeta> atlas) {
    atlas.put("/two/test", RouteMeta.build(RouteType.ACTIVITY, TestActivity.class, "/two/test", "two", null, -1, -2147483648));
  }
}

class LooperThread extends Thread {
    public Handler mHandler;
    public void run() {
        Looper.prepare();
        mHandler = new Handler(Looper.myLooper()) {
            public void handleMessage(Message msg) {
                //在此处理消息
            }
        };
        Looper.loop();
    }
}

//android-12.1.0_r27\frameworks\base\core\java\android\os\Looper.java
    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

    public static void prepare() { //prepare是静态方法
        prepare(true);
    }

    private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            //一个线程中Looper.prepare()只能执行一次，否则会抛出异常
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        //构造了一个Looper放到ThreadLocal中
        sThreadLocal.set(new Looper(quitAllowed));
    }

    //Looper的构造方法也很简单：1）创建消息队列；2）获取当先线程句柄；
    private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
    }

// 【AbstractQueuedSynchronizer.java】
    public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }
// 【ReentrantLock.java】
    static final class FairSync extends Sync {
        ......
        /**
         * Fair version of tryAcquire.  Don't grant access unless
         * recursive call or no waiters or is first.
         */
        // 只有锁未被锁定、锁重入或者等待队列中没有前辈的情况才会获取成功
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) { //state为0表示当前是未被锁定状态
                if (!hasQueuedPredecessors() && //判断等待队列是否有排在自己前面的线程
                    compareAndSetState(0, acquires)) { //通过CAS设置锁定状态
                    setExclusiveOwnerThread(current); //独占线程设置为自己
                    return true; //加锁成功
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                // 锁的重入，状态加1
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true; //加锁成功
            }
            return false; //加锁失败
        }
    }
// 【AbstractQueuedSynchronizer.java】
// addWaiter的作用就是将当前线程添加到等待队列的队尾
    private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        enq(node);
        return node;
    }
    final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) { //循环
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    // 请求锁的当前线程排在了队首，且获取锁成功
                    setHead(node); //设置为head，所以head是持有锁的线程
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt()) //进入blocked状态
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

//示例代码在Fragment#onViewCreated中调用
Uri uri = Uri.parse("https://frescolib.org/static/sample-images/animal_a.png");
SimpleDraweeView draweeView = (SimpleDraweeView) findViewById(R.id.my_image_view);
draweeView.setImageURI(uri);

public class AtomicInteger extends Number implements java.io.Serializable {
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

    static {
        try {
            //获取value变量地址
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }
    ......
    private volatile int value; //volatile类型的变量
    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }
    ......
}

/** Unsafe.java **/
    //native方法，通过jni来调用
    public final native boolean compareAndSwapInt(Object o, long offset,int expected, int x);

    public final int getAndAddInt(Object o, long offset, int delta) {
        int v;
        do {
            v = getIntVolatile(o, offset);
        } while (!compareAndSwapInt(o, offset, v, v + delta));
        return v;
    }

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)