Java on Clarity

AsynchronousFileChannel

Sun, 24 May 2026 00:00:00 +0000

异步的文件通道，FileChannel属于"同步非阻塞"，AsynchronousFileChannel才是真正的异步。

从主要方法read/write的返回值为Future可以看出其"异步"的端倪。

open

1public static AsynchronousFileChannel open(Path file,
2                                           Set<? extends OpenOption> options,
3                                           ExecutorService executor,
4                                           FileAttribute<?>... attrs) {
5    FileSystemProvider provider = file.getFileSystem().provider();
6    return provider.newAsynchronousFileChannel(file, options, executor, attrs);
7}

另外一个重载的简化方法声明如下:

1public static AsynchronousFileChannel open(Path file, OpenOption... options) {}

所做的处理便是将可变参数options手动转为Set，executor为null，文件属性为NO_ATTRIBUTES，其实就是一个空的数组。

忽略调用关系，对于Linux来说最终由sun.nio.ch.SimpleAsynchronousFileChannelImpl的open方法实现:

1public static AsynchronousFileChannel open(FileDescriptor fdo,
2                                               boolean reading,
3                                               boolean writing,
4                                               ThreadPool pool) {
5    // Executor is either default or based on pool parameters
6    ExecutorService executor = (pool == null) ? DefaultExecutorHolder.defaultExecutor : pool.executor();
7    return new SimpleAsynchronousFileChannelImpl(fdo, reading, writing, executor);
8}

默认情况下pool参数为null，ThreadPool位于sun.nio.ch包下，其实是对Java线程池ExecutorService的一层包装。DefaultExecutorHolder是SimpleAsynchronousFileChannelImpl的嵌套类，这其实是一个单例模式:

Buffer

Sun, 24 May 2026 00:00:00 +0000

Buffer

说到nio就离不开Buffer体系，类图:

这里以ByteBuffer为例，其实对于布尔类型的其它所有基本类型，都与一种Buffer与之对应，比如还有ShortBuffer。

图中的getXXX指的是获得各种数据类型的便利方法，比如getChar，getInt，putXXX也是一样。asXXX指到其它类型Buffer的转换方法，比如asCharBuffer。

注意，只有ByteBuffer才拥有getXXX, putXXX, asXXX等向其它类型转换的方法，也只有ByteBuffer可以获取direct类型的buffer。

获取

allocate

得到heap buffer，源码:

1public static ByteBuffer allocate(int capacity) {
2    return new HeapByteBuffer(capacity, capacity);
3}

HeapByteBuffer构造器:

1HeapByteBuffer(int cap, int lim) { 	
2    super(-1, 0, lim, cap, new byte[cap], 0);
3}

可以看出，heap buffer的底层其实就是byte数组，构造完成之后各属性的状态如下:

mark: 0
pos: 0
limit: capacity
offset: 0

allocateDirect

获取direct buffer，只有ByteBuffer才可以:

1public static ByteBuffer allocateDirect(int capacity) {
2    return new DirectByteBuffer(capacity);
3}

DirectByteBuffer构造器:

 1DirectByteBuffer(int cap) { 
 2    super(-1, 0, cap, cap);
 3    boolean pa = VM.isDirectMemoryPageAligned();
 4    int ps = Bits.pageSize();
 5    long size = Math.max(1L, (long)cap + (pa ? ps : 0));
 6    Bits.reserveMemory(size, cap);
 7    long base = 0;
 8    try {
 9        base = unsafe.allocateMemory(size);
10    } catch (OutOfMemoryError x) {
11        Bits.unreserveMemory(size, cap);
12        throw x;
13    }
14    unsafe.setMemory(base, size, (byte) 0);
15    if (pa && (base % ps != 0)) {
16        // Round up to page boundary
17        address = base + ps - (base & (ps - 1));
18    } else {
19        address = base;
20    }
21    cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
22    att = null;
23}

内存对齐

VM.isDirectMemoryPageAligned()用以判断JVM是否需要对堆外内存进行对齐，什么是内存页，什么是对齐参考:

BufferedInputStream

Sun, 24 May 2026 00:00:00 +0000

概览

BufferedInputStream的主要方法均为线程安全，其内部的byte数组的最大值为int的最大值减去8，这样做的原因是在Java中数组是一个对象，而一个对象最大拥有8字节的对象头。至于为什么是int的最大值而不是long的最大值，需要同时支持32位和64位虚拟机吧。

字段count的取值范围为[0, buf.length]，意义为[0, count)范围内的字节都是可读的，字段pos的取值范围为[0, count)，即读指针的位置。

read

1public synchronized int read() throws IOException {
2    if (pos >= count) {
3        fill();
4        if (pos >= count)
5            return -1;
6    }
7    return getBufIfOpen()[pos++] & 0xff;
8}

pos >= count说明缓冲区中已没有可读的字节，此时需要调用fill方法从依赖的输入流中真正地读取数据。

 1private void fill() throws IOException {
 2    //如果内部依赖的输入流已经关闭，那么getBufIfOpen会抛出异常
 3    byte[] buffer = getBufIfOpen();
 4    if (markpos < 0)
 5        pos = 0; //markpos为负数，说明我们并未设置标记位置，即不需要再次读取标记处的数据，所以整个缓冲区直接覆盖写入即可
 6    else if (pos >= buffer.length)
 7        if (markpos > 0) {
 8             //markpos为正数，说明缓冲区中尚有可以利用的空间(因为此时pos为buf的长度)，所以这里要做的就是整理缓冲区: 将被标记的数据([markpos, pos))
 9             //拷贝至缓冲区开头
10            int sz = pos - markpos;
11            System.arraycopy(buffer, markpos, buffer, 0, sz);
12            pos = sz;
13            markpos = 0;
14        } else if (buffer.length >= marklimit) {
15            //此时markpos为0，且标记的内容长度超过了marklimit限制，直接丢弃
16            markpos = -1;
17            pos = 0;
18        } else if (buffer.length >= MAX_BUFFER_SIZE) {
19            throw new OutOfMemoryError("Required array size too large");
20        } else {
21             //到达这里的前提是markpos为0，pos已达到缓冲区长度，且缓冲区长度未超过marklimit，即我们已没有可用的空间以供进一步的数据读取
22             //所以需要对缓冲区进行扩容
23            int nsz = (pos <= MAX_BUFFER_SIZE - pos) ?
24                    pos * 2 : MAX_BUFFER_SIZE;
25            //将缓冲区大小降低为marklimit，以减轻内存压力?
26            if (nsz > marklimit)
27                nsz = marklimit;
28            byte nbuf[] = new byte[nsz];
29            System.arraycopy(buffer, 0, nbuf, 0, pos);
30            if (!bufUpdater.compareAndSet(this, buffer, nbuf)) {
31                 //fill方法是在当前线程持有锁的情况下被调用的，所以这里CAS失败的唯一原因就是close方法已经被调用(close方法没有加锁)，这也是对buf的
32                 //操作还需要通过CAS来完成的原因
33                throw new IOException("Stream closed");
34            }
35            buffer = nbuf;
36        }
37    count = pos;
38    //调用底层输入流进行读取
39    int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
40    if (n > 0)
41        count = n + pos;
42}

所以，如果当前底层输入流中没有可读的数据，那么fill方法将会阻塞直到:

ConcurrentHashMap

Sun, 24 May 2026 00:00:00 +0000

我们对JDK1.8版本的ConcurrentHashMap进行说明，1.8版本的ConcurrentHashMap相比之前的版本主要做了两处改进:

使用CAS代替分段锁。
红黑树，这一点和HashMap是一致的。

put

最核心的便是put方法:

1public V put(K key, V value) {
2    return putVal(key, value, false);
3}

最后一个参数为onlyIfAbsent，表示只有在key对应的value不存在时才将value加入，所以putVal是put和putIfAbsent两个方法的真正实现。

 1final V putVal(K key, V value, boolean onlyIfAbsent) {
 2    if (key == null || value == null) throw new NullPointerException();
 3    int hash = spread(key.hashCode());
 4    int binCount = 0;
 5    //volatile读
 6    for (Node<K,V>[] tab = table;;) {
 7        Node<K,V> f; int n, i, fh;
 8        if (tab == null || (n = tab.length) == 0)
 9            //初始化
10            tab = initTable();
11        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
12            if (casTabAt(tab, i, null,
13                         new Node<K,V>(hash, key, value, null)))
14                break;                   // no lock when adding to empty bin
15        }
16        else if ((fh = f.hash) == MOVED)
17            tab = helpTransfer(tab, f);
18        else {
19            //节点添加
20            V oldVal = null;
21            synchronized (f) {
22                if (tabAt(tab, i) == f) {
23                    if (fh >= 0) {
24                        binCount = 1;
25                        for (Node<K,V> e = f;; ++binCount) {
26                            K ek;
27                            if (e.hash == hash &&
28                                ((ek = e.key) == key ||
29                                 (ek != null && key.equals(ek)))) {
30                                oldVal = e.val;
31                                if (!onlyIfAbsent)
32                                    e.val = value;
33                                break;
34                            }
35                            Node<K,V> pred = e;
36                            if ((e = e.next) == null) {
37                                pred.next = new Node<K,V>(hash, key, value, null);
38                                break;
39                            }
40                        }
41                    }
42                    else if (f instanceof TreeBin) {
43                        Node<K,V> p;
44                        binCount = 2;
45                        if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key, value)) != null) {
46                            oldVal = p.val;
47                            if (!onlyIfAbsent)
48                                p.val = value;
49                        }
50                    }
51                }
52            }
53            if (binCount != 0) {
54                if (binCount >= TREEIFY_THRESHOLD)
55                    treeifyBin(tab, i);
56                if (oldVal != null)
57                    return oldVal;
58                break;
59            }
60        }
61    }
62    addCount(1L, binCount);
63    return null;
64}

table便是其数据的存放载体:

ConcurrentLinkedQueue

Sun, 24 May 2026 00:00:00 +0000

内部类Node的类图如下:

算法

此类的实现基于算法Michael & Scott algorithm，论文:

Simple, Fast, and Practical Non-Blocking and Blocking Concurrent Queue Algorithms

offer

 1public boolean offer(E e) {
 2    //如果元素为null，那么抛出NPE
 3    checkNotNull(e);
 4    final Node<E> newNode = new Node<E>(e);
 5    for (Node<E> t = tail, p = t;;) {
 6        //volatile读
 7        Node<E> q = p.next;
 8        if (q == null) {
 9            // p is last node
10            if (p.casNext(null, newNode)) {
11                if (p != t) // hop two nodes at a time
12                    casTail(t, newNode);  // Failure is OK.
13                return true;
14            }
15            //casNext竞争失败，再次读取p.next，此时(即q)不为空
16        }
17        else if (p == q)
18            // We have fallen off list.  If tail is unchanged, it
19            // will also be off-list, in which case we need to
20            // jump to head, from which all live nodes are always
21            // reachable.  Else the new tail is a better bet.
22            p = (t != (t = tail)) ? t : head;
23        else
24            //每插入两个新节点时才会重新设置尾节点
25            p = (p != t && t != (t = tail)) ? t : q;
26    }
27}

注意，由于ConcurrentLinkedQueue为无界队列，所以offer方法永远返回true。为什么说插入两个节点之后才会尝试重新设置尾节点呢?

Condition

Sun, 24 May 2026 00:00:00 +0000

Condition

类图

ConditionObject是AbstractQueuedSynchronizer的内部类。

创建

创建是通过Lock.newCondition()来完成的。

ReentrantLock.newCondition:

1public Condition newCondition() {
2    return sync.newCondition();
3}

Sync.newCondition:

1final ConditionObject newCondition() {
2    return new ConditionObject();
3}

await

ConditionObject.await:

 1public final void await() throws InterruptedException {
 2    if (Thread.interrupted())
 3        throw new InterruptedException();
 4    Node node = addConditionWaiter();
 5    int savedState = fullyRelease(node);
 6    int interruptMode = 0;
 7    while (!isOnSyncQueue(node)) {
 8        LockSupport.park(this);
 9        if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
10            break;
11    }
12    if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
13        interruptMode = REINTERRUPT;
14    if (node.nextWaiter != null) // clean up if cancelled
15        unlinkCancelledWaiters();
16    if (interruptMode != 0)
17        reportInterruptAfterWait(interruptMode);
18}

条件队列

addConditionWaiter用于向Lock的锁队列的条件队列添加新的等待节点，什么是锁队列参见ReentrantLock。

CountDownLatch

Sun, 24 May 2026 00:00:00 +0000

CountDownLatch

类图

CountDownLatch本身没有任何父类或是实现任何接口，只含有一个内部类Sync.

await

CountDownLatch.await:

1public void await() throws InterruptedException {
2    sync.acquireSharedInterruptibly(1);
3}

AbstractQueuedSynchronizer.acquireSharedInterruptibly:

1public final void acquireSharedInterruptibly(int arg) throws InterruptedException {
2    if (Thread.interrupted()) throw new InterruptedException();
3    if (tryAcquireShared(arg) < 0)
4        doAcquireSharedInterruptibly(arg);
5}

这个套路已经见过很多次了，关键的逻辑便是Sync.tryAcquireShared:

1protected int tryAcquireShared(int acquires) {
2    return (getState() == 0) ? 1 : -1;
3}

可以看出，await成功的条件是当前读锁(共享锁)不再被其它线程持有。

countDown

1public void countDown() {
2    sync.releaseShared(1);
3}

AbstractQueuedSynchronizer.releaseShared:

1public final boolean releaseShared(int arg) {
2    if (tryReleaseShared(arg)) {
3        doReleaseShared();
4        return true;
5    }
6    return false;
7}

还是一样的套路，Sync.tryReleaseShared:

CyclicBarrier

Sun, 24 May 2026 00:00:00 +0000

CyclicBarrier

此类可管理一组线程，当所有线程都到达"检查点"时执行特定的动作(Runnable)，示例直接看其源码便好。

类图

和CountDownLatch类似，此类同样没有任何父类(除了Object)或是实现任何接口。

await

整个类的核心便是此方法:

1public int await() {
2    return dowait(false, 0L);
3}

doWait方法简略版源码:

 1private int dowait(boolean timed, long nanos) {
 2    final ReentrantLock lock = this.lock;
 3    lock.lock();
 4    try {
 5        final Generation g = generation;
 6        // 未到达(检查点)数减一
 7        int index = --count;
 8         // 已达到检查点，执行给定的任务
 9        if (index == 0) {
10            boolean ranAction = false;
11            try {
12                final Runnable command = barrierCommand;
13                if (command != null)
14                    command.run();
15                ranAction = true;
16                nextGeneration();
17                return 0;
18            } finally {
19                if (!ranAction)
20                    breakBarrier();
21            }
22        }
23
24        // 尚有线程未到达检查点
25        for (;;) {
26            try {
27                 // 等待
28                if (!timed)
29                    trip.await();
30                else if (nanos > 0L)
31                    nanos = trip.awaitNanos(nanos);
32            } catch (InterruptedException ie) {
33                if (g == generation && ! g.broken) {
34                    breakBarrier();
35                    throw ie;
36                } else {
37                    Thread.currentThread().interrupt();
38                }
39            }
40
41            if (g.broken)
42                throw new BrokenBarrierException();
43
44            if (g != generation)
45                return index;
46
47            if (timed && nanos <= 0L) {
48                breakBarrier();
49                throw new TimeoutException();
50            }
51        }
52    } finally {
53        lock.unlock();
54    }
55}

一目了然，但是有一个疑问，当未到达数减为0时，已经阻塞的线程是在哪里唤醒的呢?

Enum

Sun, 24 May 2026 00:00:00 +0000

说明

对枚举这一看似平常的东西单开一节的目的是要探究一下为什么说枚举是最好的实现单例的方式。

从例子开始

假设有这么一个简单的枚举:

1public enum Test {
2
3    SOMEONE,
4
5    ANOTHER_ONE
6
7}

首先对其进行编译，然后使用命令javap -verbose Test.class对其反编译，得到如下部分:

1public final class Test extends java.lang.Enum<Test> {}

所以，对于Java来说，枚举是一个语法糖。

Why

Enum的类图:

finalize

Enum中将finalize方法直接定义为final，这就从根本上上避免了枚举类对此方法的实现:

1protected final void finalize() { }

序列化

以如下代码示例对枚举类型的序列化:

1File file = new File("C:/Users/xsdwe/Desktop/test");
2ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(file));
3out.writeObject(Person.EVIL);
4out.writeObject(Person.JACK);
5out.flush();
6out.close();

限制其实是在ObjectOutputStream的writeObject0方法中进行控制的，相关源码:

 1private void writeObject0(Object obj, boolean unshared) throws IOException {
 2    //...
 3    if (obj instanceof String) {
 4        writeString((String) obj, unshared);
 5    } else if (cl.isArray()) {
 6        writeArray(obj, desc, unshared);
 7    } else if (obj instanceof Enum) {
 8        writeEnum((Enum<?>) obj, desc, unshared);
 9    }
10    //...
11}

可以看出，对于枚举类型，这里使用了专门的方法writeEnum进行序列化:

FileChannel

Sun, 24 May 2026 00:00:00 +0000

我们以FileOutputStream的getChannel为例:

1public FileChannel getChannel() {
2    synchronized (this) {
3        if (channel == null) {
4            channel = FileChannelImpl.open(fd, path, false, true, append, this);
5        }
6        return channel;
7    }
8}

FileChannel类图:

有几点值得注意:

InputStream和OutputStream不是线程安全的，而通道(Channel)是线程安全的。
Channel根据注释的解释，是一组IO操作的联结。
GatheringByteChannel，顾名思义就是将一组ByteBuffer的数据收集/组合起来，所以它继承自WritableByteChannel。
ScatteringByteChannel，即将一个通道的数据分散到多个ByteBuffer之中。

其实FileChannelImpl便是FileChannel的子类，位于包sun.nio.ch中，其源码可以从openjdk的jdk\src\share\classes\sun\nio\ch目录找到，open方法源码:

1public static FileChannel open(FileDescriptor fd, String path, boolean readable, boolean writable,
2    boolean append, Object parent) {
3    return new FileChannelImpl(fd, path, readable, writable, append, parent);
4}

可以看出，getChannel的原理就是构造了一个FileChannelImpl对象，此对象中保存有对应的流的是否可读、追加、文件描述符等属性。

HashMap

Sun, 24 May 2026 00:00:00 +0000

类图如下:

构造

我们以无参构造器为例:

1public HashMap() {
2    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
3}

其它的参数均取默认。

put

1public V put(K key, V value) {
2    return putVal(hash(key), key, value, false, true);
3}

putVal源码:

 1final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
 2    Node<K,V>[] tab; Node<K,V> p; int n, i;
 3    //1.初始化
 4    if ((tab = table) == null || (n = tab.length) == 0)
 5        n = (tab = resize()).length;
 6    //2.bin为null，初始化第一个节点
 7    if ((p = tab[i = (n - 1) & hash]) == null)
 8        tab[i] = newNode(hash, key, value, null);
 9    else {
10        Node<K,V> e; K k;
11        if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
12            //指定key的值已存在，那么记录下原先的值
13            e = p;
14        else if (p instanceof TreeNode)
15            //红黑树
16            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
17        else {
18            //bin不为空，且与链表头不相同(==或equals)
19            //3.
20            for (int binCount = 0; ; ++binCount) {
21                if ((e = p.next) == null) {
22                    p.next = newNode(hash, key, value, null);
23                    //达到临界值转为红黑树
24                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
25                        treeifyBin(tab, hash);
26                    break;
27                }
28                if (e.hash == hash &&
29                    ((k = e.key) == key || (key != null && key.equals(k))))
30                    break;
31                p = e;
32            }
33        }
34        if (e != null) { // existing mapping for key
35            V oldValue = e.value;
36            if (!onlyIfAbsent || oldValue == null)
37                e.value = value;
38            //空实现，为LinkedHashMap预留
39            afterNodeAccess(e);
40            return oldValue;
41        }
42    }
43    ++modCount;
44    //4.
45    if (++size > threshold)
46        resize();
47    //空实现，为LinkedHashMap预留
48    afterNodeInsertion(evict);
49    return null;
50}

onlyIfAbsent参数如果为true，那么对于已经存在的key，将不替换其值。table即HashMap进行数据存储的核心变量:

IO

Sun, 24 May 2026 00:00:00 +0000

File

类图:

其实观察File里面多数方法的实现，其实是通过委托给属性fs完成的。

FileSystem

在 File中的初始化代码:

1private static final FileSystem fs = DefaultFileSystem.getFileSystem();

在Windows下的类图:

那DefaultFileSystem又是个什么东西呢?这东西是从JDK8加入的，全部的源码如下:

1class DefaultFileSystem {
2    public static FileSystem getFileSystem() {
3        return new WinNTFileSystem();
4    }
5}

可以想象，在Linux上一定是不同的实现。

文件创建

我们来看看创建文件时到底发生了什么，以代码:

1File file = new File("test");
2System.out.println(file.getAbsolutePath());

File构造器:

1public File(String pathname) {
2    this.path = fs.normalize(pathname);
3    this.prefixLength = fs.prefixLength(this.path);
4}

normalize

这一步是将文件分隔符、路径分隔符转换成系统特定的，比如对于windows平台，就将/转为\。转换的过程不再赘述，来看一下系统特定的分隔符是从哪来的，WinNTFileSystem构造器:

1public WinNTFileSystem() {
2    slash = AccessController.doPrivileged(new GetPropertyAction("file.separator")).charAt(0);
3    semicolon = AccessController.doPrivileged(new GetPropertyAction("path.separator")).charAt(0);
4    altSlash = (this.slash == '\\') ? '/' : '\\';
5}

其实就是System.getProperty。

LinkedHashMap

Sun, 24 May 2026 00:00:00 +0000

LinkedHashMap是HashMap的子类，内部使用双链表进行顺序的维护，内部类Entry为HashMap的Node的子类，类图:

构造器

三参数构造器:

1public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) {
2    super(initialCapacity, loadFactor);
3    this.accessOrder = accessOrder;
4}

如果accessOrder为true，那么表示将顺序记录为访问顺序，否则为插入顺序，默认为false。而正是这一参数并对removeEldestEntry方法进行覆盖便可以快速实现一个简单的LRU缓存。

put

put操作其实和父类HashMap采用相同的实现，在HashMap部分也提到了afterNodeAccess和afterNodeInsertion方法其实是空实现，而在LinkedHashMap中对其进行了实现，Linked的特性也是在这里进行了体现。

newNode

LinkedhHashMap对此方法进行了覆盖:

1Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
2    LinkedHashMap.Entry<K,V> p = new LinkedHashMap.Entry<K,V>(hash, key, value, e);
3    linkNodeLast(p);
4    return p;
5}

linkNodeLast方法负责双链表的连接:

 1private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
 2    LinkedHashMap.Entry<K,V> last = tail;
 3    tail = p;
 4    if (last == null)
 5        head = p;
 6    else {
 7        p.before = last;
 8        last.after = p;
 9    }
10}

afterNodeAccess

顾名思义，此方法应该在一次访问之后被调用，那么什么算是一次访问呢?LInkedHashMap对此做出了定义:

NIO

Sun, 24 May 2026 00:00:00 +0000

SelectionKey

SelectionKey的类图如下:

注意，SelectionKey使用AtomicReferenceFieldUpdater进行原子更新attachment，这货就像是Channel和Selector结合的结晶。

兴趣设置

SelectionKeyImpl.interestOps:

1public SelectionKey interestOps(int ops) {
2    ensureValid();
3    return nioInterestOps(ops);
4}

nioInterestOps利用Channel来实现:

1public SelectionKey nioInterestOps(int ops) {
2    channel.translateAndSetInterestOps(ops, this);
3    interestOps = ops;
4    return this;
5}

这里服务器和客户端有不同的实现。

客户端

SocketChannelImpl.translateAndSetInterestOps:

 1public void translateAndSetInterestOps(int ops, SelectionKeyImpl sk) {
 2    int newOps = 0;
 3    if ((ops & SelectionKey.OP_READ) != 0)
 4        newOps |= Net.POLLIN;
 5    if ((ops & SelectionKey.OP_WRITE) != 0)
 6        newOps |= Net.POLLOUT;
 7    if ((ops & SelectionKey.OP_CONNECT) != 0)
 8        newOps |= Net.POLLCONN;
 9    sk.selector.putEventOps(sk, newOps);
10}

服务器

ServerSocketChannelImpl.translateAndSetInterestOps:

Process

Sun, 24 May 2026 00:00:00 +0000

命令执行

我们以以下代码为例:

1Runtime runtime = Runtime.getRuntime();
2String cmd = "ls -l";
3Process process = runtime.exec(cmd);

实际调用了下面的exec方法:

1public Process exec(String command, String[] envp, File dir) {
2    StringTokenizer st = new StringTokenizer(command);
3    String[] cmdarray = new String[st.countTokens()];
4    for (int i = 0; st.hasMoreTokens(); i++)
5        cmdarray[i] = st.nextToken();
6    return exec(cmdarray, envp, dir);
7}

第二个参数为环境变量数组，其格式为key=value，第三个参数为命令的执行路径，如果为null，那么便为当前Java进程的工作路径，即user.dir。

StringTokenizer默认以空格、换行符、制表符，换页符(\f)为分隔单位，所以这里将命令ls -l分割为了ls和-l两部分。

1public Process exec(String[] cmdarray, String[] envp, File dir) {
2    return new ProcessBuilder(cmdarray)
3        .environment(envp)
4        .directory(dir)
5        .start();
6}

其实是用ProcessBuilder实现，此类在JDK1.5时加入。

ReadWriteLock

Sun, 24 May 2026 00:00:00 +0000

类图

ReadWriteLock

Sync

ReentrantReadWriteLock内部的Sync的类图如下:

构造

默认构造器:

1public ReentrantReadWriteLock() {
2	this(false);
3}

含参构造器:

1public ReentrantReadWriteLock(boolean fair) {
2	sync = fair ? new FairSync() : new NonfairSync();
3	readerLock = new ReadLock(this);
4	writerLock = new WriteLock(this);
5}

写锁和读锁的构造器是一个套路，以读锁为例:

1protected ReadLock(ReentrantReadWriteLock lock) {
2	sync = lock.sync;
3}

可以看出，读写锁内部的sync其实就是ReentrantReadWriteLock的sync。

读锁

lock

ReadLock.lock:

1public void lock() {
2	sync.acquireShared(1);
3}

AbstractQueuedSynchronizer.acquireShared:

1public final void acquireShared(int arg) {
2	if (tryAcquireShared(arg) < 0)
3		doAcquireShared(arg);
4}

tryAcquireShared方法的实现位于Sync:

ReentrantLock

Sun, 24 May 2026 00:00:00 +0000

ReentrantLock

类图

如下:

Sync

观察ReentrantLock关键方法的源码可以发现，其实现是委托给内部类Sync实现的，所以逻辑的关键便在于此类。例子:

1public void lock() {
2    sync.lock();
3}

类图

很明显，锁的公平性便是由NonFairSync和FairSync实现的，从ReentrantLock的构造器可以印证这一点:

1public ReentrantLock(boolean fair) {
2    sync = fair ? new FairSync() : new NonfairSync();
3}

锁的公平性指的是等待时间最长的线程最有机会获得锁，但是这样会导致性能的下降，因为此时对于线程的调度和操作系统的调度是矛盾的。参考:

ReentrantLock(重入锁)以及公平性

非公平锁

lock

NonfairSync.lock:

1final void lock() {
2    if (compareAndSetState(0, 1))
3        setExclusiveOwnerThread(Thread.currentThread());
4    else
5        acquire(1);
6}

快速尝试

AbstractQueuedSynchronizer.compareAndSetState:

1protected final boolean compareAndSetState(int expect, int update) {
2    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
3}

AbstractQueuedSynchronizer内部有一个state变量:

Reflection

Sun, 24 May 2026 00:00:00 +0000

核心便是Class类，类图如下:

方法获取

我们以getDeclaredMethods为例:

1@CallerSensitive
2public Method[] getDeclaredMethods() throws SecurityException {
3    return copyMethods(privateGetDeclaredMethods(false));
4}

privateGetDeclaredMethods:

 1private Method[] privateGetDeclaredMethods(boolean publicOnly) {
 2    Method[] res;
 3    ReflectionData<T> rd = reflectionData();
 4    if (rd != null) {
 5        res = publicOnly ? rd.declaredPublicMethods : rd.declaredMethods;
 6        if (res != null) return res;
 7    }
 8    // No cached value available; request value from VM
 9    res = Reflection.filterMethods(this, getDeclaredMethods0(publicOnly));
10    if (rd != null) {
11        if (publicOnly) {
12            rd.declaredPublicMethods = res;
13        } else {
14            rd.declaredMethods = res;
15        }
16    }
17    return res;
18}

publicOnly为false便说明需要获取各种访问级别的方法。

ScheduledThreadPool

Sun, 24 May 2026 00:00:00 +0000

创建

我们一般使用下面的方式进行创建:

1public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
2    return new DelegatedScheduledExecutorService(new ScheduledThreadPoolExecutor(1));
3}

DelegatedScheduledExecutorService实际上是对ScheduledExecutorService接口方法的转发，目的是只将ScheduledExecutorService接口的public方法暴露出来，这其实就是门面模式。

显然这里的核心便是ScheduledThreadPoolExecutor了:

ScheduledThreadPoolExecutor构造器:

1public ScheduledThreadPoolExecutor(int corePoolSize) {
2    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS, new DelayedWorkQueue());
3}

所以，默认情况下创建的是corePoolSize为1的线程池，而maximumPoolSize却为int最大值!

其工作队列DelayedWorkQueue是ScheduledThreadPoolExecutor的嵌套类:

单次调度

1public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) {
2    RunnableScheduledFuture<V> t = decorateTask(callable,
3        new ScheduledFutureTask<V>(callable, triggerTime(delay, unit)));
4    delayedExecute(t);
5    return t;
6}

触发时间计算

1private long triggerTime(long delay, TimeUnit unit) {
2    return triggerTime(unit.toNanos((delay < 0) ? 0 : delay));
3}
4long triggerTime(long delay) {
5     return now() + ((delay < (Long.MAX_VALUE >> 1)) ? delay : overflowFree(delay));
6}

now方法即返回当前纳秒表示的时间，所以触发时间就是当前时间加延时。

Socket

Sun, 24 May 2026 00:00:00 +0000

客户端连接

先来看一下使用socket作为客户端的使用。假设有代码如下:

1public static void main(String[] args) {
2    Socket socket = new Socket();
3    socket.connect(new InetSocketAddress(8080));
4}

构造器

Socket的默认构造器源码如下:

1 public Socket() {
2    setImpl();
3}

setImpl()方法的目的在于设置系统采用的Socket实现，采用SocksSocketImpl。其类图:

SocksSocketImpl.jpg的父类会在静态代码块中进行初始化工作，下面分部分说明。

网络库加载

AbstractPlainSocketImpl静态代码块源码:

1static {
2    java.security.AccessController.doPrivileged(
3        new java.security.PrivilegedAction<Void>() {
4            public Void run() {
5                System.loadLibrary("net");
6                return null;
7            }
8        });
9    }

通过debug可以发现，对于Windows来说，这加载的实际上是位于jre下的bin/net.dll。

启动参数获取

PlainSocketImpl静态代码块源码:

 1static {
 2    java.security.AccessController.doPrivileged( new PrivilegedAction<Object>() {
 3            public Object run() {
 4                version = 0;
 5                try {
 6                    version = Float.parseFloat(System.getProperties().getProperty("os.version"));
 7                    preferIPv4Stack = Boolean.parseBoolean(
 8                                      System.getProperties().getProperty("java.net.preferIPv4Stack"));
 9                    exclBindProp = System.getProperty("sun.net.useExclusiveBind");
10                } catch (NumberFormatException e ) {
11                    assert false : e;
12                }
13                return null; // nothing to return
14            } });
15
16    // (version >= 6.0) implies Vista or greater.
17    if (version >= 6.0 && !preferIPv4Stack) {
18            useDualStackImpl = true;
19    }
20    if (exclBindProp != null) {
21        // sun.net.useExclusiveBind is true
22        exclusiveBind = exclBindProp.length() == 0 ? true
23                : Boolean.parseBoolean(exclBindProp);
24    } else if (version < 6.0) {
25        exclusiveBind = false;
26    }
27}

java.net.preferIPv4Stack参数默认为false，表示如果系统支持IPV6，那么即使用IPV6 socket，如果设置为true，那么将只使用V4.

Thread

Sun, 24 May 2026 00:00:00 +0000

构造器

我们以喜闻乐见的为例:

1public Thread(Runnable target) {
2    init(null, target, "Thread-" + nextThreadNum(), 0);
3}

第一个参数为线程组，最后一个为栈大小。init方法就是一些内部属性的赋值操作。

启动

1public synchronized void start() {
2    if (threadStatus != 0)
3        throw new IllegalThreadStateException();
4    boolean started = false;
5    start0();
6    started = true;
7}

核心便在于native方法start0.

ThreadLocal

Sun, 24 May 2026 00:00:00 +0000

get

 1public T get() {
 2    Thread t = Thread.currentThread();
 3    ThreadLocalMap map = getMap(t);
 4    if (map != null) {
 5        ThreadLocalMap.Entry e = map.getEntry(this);
 6        if (e != null) {
 7            @SuppressWarnings("unchecked")
 8            T result = (T)e.value;
 9            return result;
10        }
11    }
12    return setInitialValue();
13}

getMap实现:

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

可以看出，其实ThreadLocalMap作为线程Thread的属性而存在:

ThreadPool

Sun, 24 May 2026 00:00:00 +0000

创建

我们以下列代码为例:

1public static ExecutorService newFixedThreadPool(int nThreads) {
2    return new ThreadPoolExecutor(nThreads, nThreads,
3        0L, TimeUnit.MILLISECONDS,
4        new LinkedBlockingQueue<Runnable>());
5}

可见默认使用LinkedBlockingQueue作为工作队列，其构造器:

1public LinkedBlockingQueue() {
2    this(Integer.MAX_VALUE);
3}

可见，这其实是一个有界队列，虽然大小为int最大值。

ThreadPoolExecutor便是JDK线程池的核心了，类图:

ThreadPoolExecutor构造器:

1public ThreadPoolExecutor(int corePoolSize,
2                          int maximumPoolSize,
3                          long keepAliveTime,
4                          TimeUnit unit,
5                          BlockingQueue<Runnable> workQueue) {
6    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
7         Executors.defaultThreadFactory(), defaultHandler);
8}

线程工厂

默认的线程工厂是Executors的内部类，核心的newThread方法:

1public Thread newThread(Runnable r) {
2    Thread t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement(), 0);
3    if (t.isDaemon())
4        t.setDaemon(false);
5    if (t.getPriority() != Thread.NORM_PRIORITY)
6        t.setPriority(Thread.NORM_PRIORITY);
7    return t;
8}

namePrefix定义:

TreeMap

Sun, 24 May 2026 00:00:00 +0000

类图:

TreeMap的构造器可以接受一个Comparator参数用以决定key的顺序，如果没有指定，那么尝试将key强转为Comparable，如果转换失败那就抛出异常了。

put

 1public V put(K key, V value) {
 2    Entry<K,V> t = root;
 3    if (t == null) {
 4        compare(key, key); // type (and possibly null) check
 5        root = new Entry<>(key, value, null);
 6        size = 1;
 7        modCount++;
 8        return null;
 9    }
10    int cmp;
11    Entry<K,V> parent;
12    // split comparator and comparable paths
13    Comparator<? super K> cpr = comparator;
14    //按Comparator查找
15    if (cpr != null) {
16        do {
17            parent = t;
18            cmp = cpr.compare(key, t.key);
19            if (cmp < 0)
20                t = t.left;
21            else if (cmp > 0)
22                t = t.right;
23            else
24                return t.setValue(value);
25        } while (t != null);
26    }
27    else {
28        if (key == null)
29            throw new NullPointerException();
30            //强转为Comparable
31            Comparable<? super K> k = (Comparable<? super K>) key;
32        do {
33            parent = t;
34            cmp = k.compareTo(t.key);
35            if (cmp < 0)
36                t = t.left;
37            else if (cmp > 0)
38                t = t.right;
39            else
40                return t.setValue(value);
41        } while (t != null);
42    }
43    Entry<K,V> e = new Entry<>(key, value, parent);
44    if (cmp < 0)
45        parent.left = e;
46    else
47        parent.right = e;
48    //修复红黑树
49    fixAfterInsertion(e);
50    size++;
51    modCount++;
52    return null;
53}

红黑树首先是一棵二叉查找树，put方法首先便是在树中进行搜索寻找合适的插入位置，然后修复红黑树。

UDP

Sun, 24 May 2026 00:00:00 +0000

一个简单的Server/Client交互过程参见udp包。从中可以看出其实对于UDP来说，服务器和客户端代码其实是一样的。在此我们将"服务器"简单的理解为数据的接收方。

类图

DatagramSocket

DatagramSocketImpl

数据接收

示例代码:

1DatagramSocket server = new DatagramSocket(8080);
2byte[] buffer = new byte[1024];
3DatagramPacket packet = new DatagramPacket(buffer, 1024);
4server.receive(packet);
5System.out.println("Server接收到: " + new String(buffer, 0, packet.getLength()));

Socket创建

创建和TCP相似，真正的实现位于DualStackPlainDatagramSocketImpl.datagramSocketCreate，简略版源码:

1protected void datagramSocketCreate() {
2    int newfd = socketCreate(false /* v6Only */);
3    fdAccess.set(fd, newfd);
4}

socketCreate为native方法，Windows实现位于DualStackPlainDatagramSocketImpl.c的Java_java_net_DualStackPlainDatagramSocketImpl_socketCreate方法，简略版源码:

1fd = (int) socket(AF_INET6, SOCK_DGRAM, 0);
2rv = setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, (char *) &opt, sizeof(opt));

结合TCP的创建过程可以发现，两者的创建都是通过Windows API socket方法完成，区别在于第二个参数，TCP是SOCK_STREAM而UDP是SOCK_DGRAM。

URLConnection

Sun, 24 May 2026 00:00:00 +0000

类图:

我们以urlconnection包的简单对百度首页的读取来开启我们的源码阅读旅程。

连接建立

URL构建

URL负责协议的解析以及相应的协议处理器的创建，协议解析的过程其实就是一个字符串的处理过程。协议处理器即URLStreamHandler，类图:

其子类如下图所示:

每种协议的处理器便在sun.net.www.protocol.xxx中，URL获取处理器就是一个手动拼接类名，用反射生成实例的过程。

创建连接对象

URL.openConnection:

1public URLConnection openConnection() {
2    return handler.openConnection(this);
3}

注意此处并未执行真正的连接操作，从上一节可以看出，这里的Handler应该是sun.net.www.protocol.http.Handler:

1protected java.net.URLConnection openConnection(URL u, Proxy p) {
2    //p为空
3    return new HttpURLConnection(u, p, this);
4}

这里的HttpURLConnection同样位于sun.net.www.protocol.http包下，构造器源码: