核心

在rt.jar包

参考

ClassLoader

public static final Boolean FALSE = new Boolean(false);

public static Boolean valueOf(String s) { return parseBoolean(s) ? TRUE : FALSE; }

  2. - parseBoolean
  3. - getBoolean //    和系统属性有关
  4. - 实现了Comparable 接口，所以 compareTo， 静态方法 compare
  5. - 逻辑运算
  6.    - logicalAnd
  7.    - logicalOr
  8.    - logicalXor
  10. <a name="NbEFA"></a>
  11. #### Charactor
  13. - valueOf,  注意部分会用到缓存，
  14. ```java
  15. static final Character cache[] = new Character[127 + 1];
  17. static {
  18.     for (int i = 0; i < cache.length; i++)
  19.         cache[i] = new Character((char)i);
  20. }
  21. //.....
  22. if (c <= 127) { // must cache
  23.             return CharacterCache.cache[(int)c];
  24.         }
  25. return new Character(c);
  • hashCode, equals,toString
  • isValidCodePoint
  • isBmpCodePoint
  • isSupplementaryCodePoint
  • isHighSurrogate
  • isLowSurrogate
  • isSurrogate
  • isSurrogatePair
  • charCount
  • toCodePoint
  • codePointAt
  • codePointAtImpl
  • codePointBefore
  • highSurrogate
  • lowSurrogate
  • toChars
  • codePointCount
  • offsetByCodePoints
  • isLowerCase
  • isUpperCase
  • isTitleCase
  • isDigit
  • isDefined
  • isLetter
  • isLetterOrDigit
  • isAlphabetic
  • isIdeographic
  • isJavaIdentifierStart
  • isJavaIdentifierPart
  • isUnicodeIdentifierStart
  • isUnicodeIdentifierPart
  • isIdentifierIgnorable
  • toLowerCase
  • toUpperCase
  • toTitleCase
  • digit
  • getNumericValue
  • isSpaceChar
  • isWhitespace // 空白符包含:空格、tab键、换行符
  • isISOControl ？？
  • getType
  • forDigit
  • getDirectionality ？？
  • isMirrored //类似各种括号，需要一对一对的
  • compareTo
  • compare
  • reverseBytes
  • getName

Number

  • 定义了xxxValue方法，用于类型转换

    Byte ,

  • Byte用 ByteCache做了缓存 所以用valueOf 返回的同值的都是同一个地址对象

    1. static final Byte cache[] = new Byte[-(-128) + 127 + 1];
    2. static {
    3.           for(int i = 0; i < cache.length; i++)
    4.               cache[i] = new Byte((byte)(i - 128));
    5.       }

  • parseByte 从String 转Byte

  • 实现 Number定义的方法，实现都是强转，不会有精度丢失
  • 实现了Comparable 接口

  • toUnsignedInt 与 toUnsignedLong

    Short,

  • 表示范围 从 jdk概览（挖坑） - 图3 ~ jdk概览（挖坑） - 图4

  • valueOf 同样用了缓存

    1. if (sAsInt >= -128 && sAsInt <= 127) { // must cache
    2.   return ShortCache.cache[sAsInt + offset];
    3. }
    4. return new Short(s);

  • decode 转0x 0X 这样开头的字符串

  • 实现 Number定义的方法，实现都是强转，
  • 实现了Comparable 接口
  • reverseBytes 静态方法

  • toUnsignedInt， toUnsignedLong 实现都是位运算

    Integer,

  • 构造方法支持 int String

  • toXXXString 转各种进制的String
  • parseInt parseUnsignedInt 静态方法，String转int
  • vlaueOf 支持String ，int 有缓存实现,缓存大小可以配置 ```java if (i >= IntegerCache.low && i <= IntegerCache.high) return IntegerCache.cache[i + (-IntegerCache.low)]; return new Integer(i);

//……… static final int low = -128; static final int high; static final Integer cache[];

static { // high value may be configured by property int h = 127; String integerCacheHighPropValue = sun.misc.VM.getSavedProperty(“java.lang.Integer.IntegerCache.high”); if (integerCacheHighPropValue != null) { try { int i = parseInt(integerCacheHighPropValue); i = Math.max(i, 127); // Maximum array size is Integer.MAX_VALUE h = Math.min(i, Integer.MAX_VALUE - (-low) -1); } catch( NumberFormatException nfe) { // If the property cannot be parsed into an int, ignore it. } } high = h;

  1. cache = new Integer[(high - low) + 1];
  2. int j = low;
  3. for(int k = 0; k < cache.length; k++)
  4.     cache[k] = new Integer(j++);
  6. // range [-128, 127] must be interned (JLS7 5.1.7)
  7. assert IntegerCache.high >= 127;

}

  2. - 实现 Number接口，都是强转
  3. - getInteger，获取系统变量值  System.getProperty(nm);
  4. - decode
  5. - 实现Compareble接口
  6. - divideUnsigned 应该是除
  7. - remainderUnsigned 求余
  8. - highestOneBit 与lowestOneBit  [参考](https://blog.csdn.net/cnds123321/article/details/117399430)
  9. - numberOfLeadingZeros与numberOfTrailingZeros 二进制串中从最左/右边算起连续的“0”的总数量
  10. - bitCount 在二进制下“1”的数量。//位运算 TODO
  11. - rotateLeft 与rotateRight // 补码相关
  12. - reverse
  13. - signum  判断正负数
  14. - reverseBytes
  15. - 比较 求和 max min sum 用Math函数实现
  16. <a name="ODPop"></a>
  17. ####  Long, 
  19. - 类型转换 toXXXString， parseXXXLong
  20. - valueOf 也可转String到Long，有缓存 -128~127
  21. - 实现 Number接口，都是强转
  22. - getLong 和系统变量有关
  23. - Compareble接口实现
  24. - 后面和Integer类似
  26. <a name="SZGzK"></a>
  27. #### Float 
  29. - 与Integer 有区别的
  30. - isNaN  实现有点奇怪 return (v != v);
  31.    - NaN是一个Float对象；
  32.    - NaN对象的内存地址尽不相同
  33. - isInfinite
  34. - hashCode 与 equals
  35.    - floatToIntBits  floatToRawIntBits //非java代码
  37. <a name="bAKBv"></a>
  38. #### Double
  40. - 与Float基本类似
  42. <a name="Z8fHh"></a>
  43. ### 字符处理
  44. <a name="SkYcb"></a>
  45. #### String
  47. - final class
  48. - 构造函数 byte[] int[]  char[] StringBuffer , 一般有偏移量和 个数
  49. - codePoint相关
  50. - getChars getBytes
  51. - CharSequence    的方法实现
  52. - valueOf 相关 copyValueOf 实现看上去都是一样的
  53. - format相关
  54. - 各种equals
  55.    - contentEquals  支持CharSequence  StringBuffer
  56.    - nonSyncContentEquals
  57.    - equalsIgnoreCase
  58. - Comparable接口实现
  59. - regionMatches , 一个区间内的子字符串是否相等
  60. - startWith endWith
  61. - hashCode  h = 31 * h + val[i];
  62. - xxxIndexOfxxx 检索  match contians 匹配
  63. - subxxx 子串
  64. - replacexxx
  65. - concat   split   join  trim，split是在Pattern类中实现，join与split是相反的过程
  66. - 大小写转
  67. <a name="V2qQ8"></a>
  68. #### String Builder
  70. - 有个初始容量 容量可设置
  71. ```java
  72.     public StringBuffer() {
  73.         super(16);
  74.     }
  76.     public StringBuffer(int capacity) {
  77.         super(capacity);
  78.     }
  79.     public StringBuffer(String str) {
  80.         super(str.length() + 16);
  81.         append(str);
  82.     }

  • 最多常用的是append 有15个左右重载，主要逻辑如下, 在父类中实现

    1. public AbstractStringBuilder append(String str) {
    2.       if (str == null)
    3.           return appendNull();
    4.       int len = str.length();
    5.       ensureCapacityInternal(count + len);
    6.       str.getChars(0, len, value, count);
    7.       count += len;
    8.       return this;
    9. }
    • insert方法 类似方法都用System.arraycopy 和String getChars，都是数组操作
      1. public AbstractStringBuilder insert(int offset, String str) {
      2.    if ((offset < 0) || (offset > length()))
      3.        throw new StringIndexOutOfBoundsException(offset);
      4.    if (str == null)
      5.        str = "null";
      6.    int len = str.length();
      7.    ensureCapacityInternal(count + len);
      8.    System.arraycopy(value, offset, value, offset + len, count - offset);
      9.    str.getChars(value, offset);
      10.    count += len;
      11.    return this;
      12. }

      运行相关

      Thead //TODO 在多线程专题

      image.png

      Process

      //略

      System

  • 输入输出相关

    1. public final static InputStream in = null;
    2. public final static PrintStream out = null;
    3. public final static PrintStream err = null;
    • setIn setOut setErr
    • console
    • Channel inheritedChannel
  • getSecurityManager / setSecurityManager
  • 时间相关
    • nanoTime
    • currentTimeMillis
  • 内存操作
    • arraycopy //非java实现
    • gc
    • runFinalization
  • 环境相关
    • xxxProperties
    • xxxenv
  • 库加载 实现是RumTime类里实现
    • load
    • loadLibray
    • mapLibraryName

RunTime

  • exec // ProcessBuilder 调用 UNIXProcess 的方法实现

  • xxxShutDownHook
  • halt
  • 运行资源信息
    • availableProcessors
    • freeMemory
    • totalMemory
    • maxMemory
  • 加载lib方法
  • 内存回收
    • gc
    • runFinalization

  • 追踪开关

    • traceInstructions
    • traceMethodCalls

      ProcessBuilder

      工具

      Math

      java.lang.annotation

      //注解相关类， TODO

      java.lang.instrument

      //TODO，初步看和字节码编程有类似的作用，可以查看加载的类和改造， 找些文章实例看看

      java.lang.invoke

      参考

  • https://blog.csdn.net/u014285884/article/details/78740281

java.lang.management

参考

  • https://blog.csdn.net/weixin_33716154/article/details/92275908

    java.lang.ref

    参考

  • https://www.iteye.com/blog/seanzhou-2021773 | 引用类型 | 取得目标对象的方式 | 垃圾回收条件 | 是否可能内在泄漏 | | —- | —- | —- | —- | | 强引用 | 直接引用 | 不回收 | 可能 | | 软引用 | 通过get()方法 | 无强引用时，视内存情况及get()调用情况回收 | 不可能 | | 弱引用 | 通过get()方法 | 无强引用时，永远回收 | 不可能 | | 虚引用 （跟踪回收用） | 无法取得 | 无强引用时，永远回收 | 不可能 |

java.lang.reflect

参考

  • https://blog.csdn.net/muddledape/article/details/81091174

    java.util

    参考

  • https://blog.csdn.net/z55887/article/details/57587632

  • https://blog.csdn.net/weixin_46482482/article/details/115731362

    容器接口

    Collection

  • 接口 ，子接口有 Set，List，Queue

  • 通用的方法
    • add addAll
    • remove removeAll removeIf clear
    • contains containsAll retainAll
    • size isEmpty
    • toArray
  • Steam //TODO
    • stream parallelStream

  • iterator

    List

  • 新增实现的方法 接口中实现方法 用 default

    • sort
    • repalceAll

  • 新增的接口方法

    • get set
    • indexOf lastIndexOf
    • listIterator
    • subList
    • Spliterator

      Set

  • 相较Collection没有新增方法，不能按索引获取值

  • 特性是没有重复元素，无序

    Queue

  • 侧重操作

    • offer 与 add ，add方法在队列满的情况下将选择抛异常的方法来表示队列已经满了，而offer方法通过返回false表示队列已经满了；在有限队列的情况，使用offer方法优于add方法；
    • remove方法和poll方法都是删除队列的头元素，remove方法在队列为空的情况下将抛异常，而poll方法将返回null；
    • element和peek方法都是返回队列的头元素，但是不删除头元素，区别在与element方法在队列为空的情况下，将抛异常，而peek方法将返回null

      Map

  • size , isEmpty containsKey containsValue

  • keySet entrySet //??
  • put putAll putIfAbsent
  • remove clear
  • replaceAll replace merge
  • get values getOrDefaut
  • computeIfAbsent computeIfPresent compute //??

  • forEach //TODO

    模板类

    AbstractXXX

  • 很多公共方法在抽象类里实现

    常用实现类

    ArrayList

  • 构造函数

    • 数组实现，初始容量为10，可以指定容量
    • 实现Collection接口的可以转

  • 实现技巧

    • 数组实现
    • 新增插入，或删除时都会设计到 数组批量操作，主要用arraycopy，
    • 新增涉及扩容，删除注意设置为null进行垃圾回收，
    • 扩容成功一次 1.5倍容量

      LinkedList

  • 实现 了 ist, Deque, 等接口

  • 是个双向链表
  • 构造函数
    • 可以直接把实现了Collection接口的类转过来
  • getFirst getLast addFirst addlast removeFirst removeLast
  • add addAll
  • clear remove
  • get set
  • indexOf lastIndexOf
  • Deque的方法实现
    • offer offerFirst offerLast
    • peek peekFirst peekLast element
    • poll pollFist polllast remove
    • push pop
    • removeFirstOccurrence removeLastOccurrence
    • descendingIterator

  • toArray

    Vector

  • 与ArrayList最大的区别应该就是线程安全的

  • 扩容有点不一样，默认arrayList是1.5倍 vector是2倍

    Stack

  • 继承Vector

  • push pop peek

  • empty search

    HashSet

  • 构造函数

    • 底层是HashMap，初始化时可以设置一些hashmap初始化的参数，来提升性能
    • 看一个默认的初始化 集合实例, 应该是用0.75的负载因子比较合适 ```java public HashSet(Collection<? extends E> c) { map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16)); addAll(c); }
  2. - set 较List 少一些查找的方法
  3. <a name="WCpRm"></a>
  4. #### TreeSet
  6. - 实现了 NavigableSet 与 SortedSet 接口，主要是有序的特性
  7. - 构造函数
  8.    - 可以用 NavigableMap接口实现的类来初始化
  9.    - 默认用TreeMap 来存，
  10.    - 也可以转其他Collection的实例
  11. - descendingIterator
  12. - descendingSet
  13. - subSet  headSet  返回比参数小的 集合 tailSet  返回比参数大的集合
  14. - comparator 
  15. - first last lower floor  ceiling higher
  16. - pollFirt pollLast
  18. <a name="J8IxS"></a>
  19. #### HashMap
  21. - 重要实现
  22.    - TREEIFY_THRESHOLD 是 8 ，每个“筒” 下面超过这个，就变成了TreeNode
  23. ```java
  24. final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
  25.                    boolean evict) {
  26.         Node<K,V>[] tab; Node<K,V> p; int n, i;
  27.         if ((tab = table) == null || (n = tab.length) == 0)
  28.             n = (tab = resize()).length;
  29.         if ((p = tab[i = (n - 1) & hash]) == null)
  30.             tab[i] = newNode(hash, key, value, null);
  31.         else {
  32.             Node<K,V> e; K k;
  33.             if (p.hash == hash &&
  34.                 ((k = p.key) == key || (key != null && key.equals(k))))
  35.                 e = p;
  36.             else if (p instanceof TreeNode)
  37.                 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
  38.             else {
  39.                 for (int binCount = 0; ; ++binCount) {
  40.                     if ((e = p.next) == null) {
  41.                         p.next = newNode(hash, key, value, null);
  42.                         if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
  43.                             treeifyBin(tab, hash);
  44.                         break;
  45.                     }
  46.                     if (e.hash == hash &&
  47.                         ((k = e.key) == key || (key != null && key.equals(k))))
  48.                         break;
  49.                     p = e;
  50.                 }
  51.             }
  52.             if (e != null) { // existing mapping for key
  53.                 V oldValue = e.value;
  54.                 if (!onlyIfAbsent || oldValue == null)
  55.                     e.value = value;
  56.                 afterNodeAccess(e);
  57.                 return oldValue;
  58.             }
  59.         }
  60.         ++modCount;
  61.         if (++size > threshold)
  62.             resize();
  63.         afterNodeInsertion(evict);
  64.         return null;
  65.     }
  • get containsKey getOrDefault values keySet entrySet
  • size isEmpty
  • put putAll putIfAbsent remove clear

  • computeIfAbsent computIfPresent compute

    HashTable

  • 参考

  • 红黑树 //TODO

  • 有序

  • 核心代码 ```java public V put(K key, V value) {

    1.   Entry<K,V> t = root;
    2.   if (t == null) {
    3.       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.   if (cpr != null) {
    15.       do {
    16.           parent = t;
    17.           cmp = cpr.compare(key, t.key);
    18.           if (cmp < 0)
    19.               t = t.left;
    20.           else if (cmp > 0)
    21.               t = t.right;
    22.           else
    23.               return t.setValue(value);
    24.       } while (t != null);
    25.   }
    26.   else {
    27.       if (key == null)
    28.           throw new NullPointerException();
    29.       @SuppressWarnings("unchecked")
    30.           Comparable<? super K> k = (Comparable<? super K>) key;
    31.       do {
    32.           parent = t;
    33.           cmp = k.compareTo(t.key);
    34.           if (cmp < 0)
    35.               t = t.left;
    36.           else if (cmp > 0)
    37.               t = t.right;
    38.           else
    39.               return t.setValue(value);
    40.       } while (t != null);
    41.   }
    42.   Entry<K,V> e = new Entry<>(key, value, parent);
    43.   if (cmp < 0)
    44.       parent.left = e;
    45.   else
    46.       parent.right = e;
    47.   fixAfterInsertion(e);
    48.   size++;
    49.   modCount++;
    50.   return null;

    }

private void fixAfterInsertion(Entry x) { x.color = RED;

  1.     while (x != null && x != root && x.parent.color == RED) {
  2.         if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {
  3.             Entry<K,V> y = rightOf(parentOf(parentOf(x)));
  4.             if (colorOf(y) == RED) {
  5.                 setColor(parentOf(x), BLACK);
  6.                 setColor(y, BLACK);
  7.                 setColor(parentOf(parentOf(x)), RED);
  8.                 x = parentOf(parentOf(x));
  9.             } else {
  10.                 if (x == rightOf(parentOf(x))) {
  11.                     x = parentOf(x);
  12.                     rotateLeft(x);
  13.                 }
  14.                 setColor(parentOf(x), BLACK);
  15.                 setColor(parentOf(parentOf(x)), RED);
  16.                 rotateRight(parentOf(parentOf(x)));
  17.             }
  18.         } else {
  19.             Entry<K,V> y = leftOf(parentOf(parentOf(x)));
  20.             if (colorOf(y) == RED) {
  21.                 setColor(parentOf(x), BLACK);
  22.                 setColor(y, BLACK);
  23.                 setColor(parentOf(parentOf(x)), RED);
  24.                 x = parentOf(parentOf(x));
  25.             } else {
  26.                 if (x == leftOf(parentOf(x))) {
  27.                     x = parentOf(x);
  28.                     rotateRight(x);
  29.                 }
  30.                 setColor(parentOf(x), BLACK);
  31.                 setColor(parentOf(parentOf(x)), RED);
  32.                 rotateLeft(parentOf(parentOf(x)));
  33.             }
  34.         }
  35.     }
  36.     root.color = BLACK;
  37. }
  1. <a name="ywPUR"></a>
  2. ### 常用工具类
  3. <a name="IgqF4"></a>
  4. #### Arrays
  6. - sort
  7.    - 底层DualPivotQuicksort ，ComparableTimSort这里实现 //TODO
  8.    - [https://zhuanlan.zhihu.com/p/374041792](https://zhuanlan.zhihu.com/p/374041792)
  9. - parallelSort
  10. - parallelPrefix
  11. - binarySearch
  12. - equals
  13. - fill
  14. - copyOf copyOfRange
  15. - asList
  16. - hascode
  17. - deepHashCode
  18. - deepEquals
  19. - toString
  20. - deepToString
  21. - parallelSetAll  setAll //TODO   lambada
  22.    - [https://www.cnblogs.com/sweetorangezzz/p/12918962.html](https://www.cnblogs.com/sweetorangezzz/p/12918962.html)
  23. - spliterator 
  24.    - [https://blog.csdn.net/sl1992/article/details/100149187](https://blog.csdn.net/sl1992/article/details/100149187)
  25. - stream //TODO
  26.    - 参考 [https://blog.csdn.net/a13662080711/article/details/84928181](https://blog.csdn.net/a13662080711/article/details/84928181)
  29. <a name="YFV0S"></a>
  30. ## java.util.concurrent
  31. <a name="dZ5FY"></a>
  32. ### 参考
  34. - [https://www.cnblogs.com/sarafill/archive/2011/05/18/2049461.html](https://www.cnblogs.com/sarafill/archive/2011/05/18/2049461.html)
  35. - [https://blog.csdn.net/qq_27378875/article/details/81610696](https://blog.csdn.net/qq_27378875/article/details/81610696)
  36. <a name="ZMYdd"></a>
  37. ### 线程安全容器接口及其实现
  39. - BlockingDeque， BlockingQueue
  40. - ConcurrentMap，ConcurrentNavigableMap
  42. <a name="M9aNk"></a>
  43. ## java.util.concurrent.atomic
  44. <a name="NKPIQ"></a>
  45. #### Atomicxxxx
  47. - 有 AtomicBoolean，AtomicInteger，AtomicIntegerArray，AtomicReference等
  48. - [volatile关键字了解下](https://www.cnblogs.com/dolphin0520/p/3920373.html)
  49. - 使用了 [Unsafe](https://www.jianshu.com/p/db8dce09232d) 主要使用了CAS 能力
  50. - [atomicStampReference](https://blog.csdn.net/zxl1148377834/article/details/90079882)
  51. - [其它类](https://blog.csdn.net/panweiwei1994/article/details/78739264)
  53. <a name="Ej4Fs"></a>
  54. ## java.util.concurrent.locks
  55. <a name="ODJDP"></a>
  56. ### 参考
  58. - [https://www.cnblogs.com/Jason-Xiang/p/8446554.html](https://www.cnblogs.com/Jason-Xiang/p/8446554.html)
  59. - <br />
  61. <a name="KdUM4"></a>
  62. #### AbstractQueuedSynchronizer 
  64. - 参考
  65.    - [https://blog.csdn.net/qq_39241239/article/details/86934059](https://blog.csdn.net/qq_39241239/article/details/86934059)
  66. <a name="us0Lk"></a>
  67. #### Lock
  68. <a name="mAe4g"></a>
  69. #### Condition
  71. - 参考
  72.    - [https://blog.csdn.net/a1439775520/article/details/98471610](https://blog.csdn.net/a1439775520/article/details/98471610)        
  74. <a name="piSwY"></a>
  75. #### ReentrantLock
  77. - 内部类  主要实现了锁的逻辑
  78.    - Sync
  79.    - NonfairSync
  80.    - FairSync
  81. ```java
  82. final boolean nonfairTryAcquire(int acquires) {
  83.             final Thread current = Thread.currentThread();
  84.             int c = getState();
  85.             if (c == 0) {
  86.                 if (compareAndSetState(0, acquires)) {
  87.                     setExclusiveOwnerThread(current);
  88.                     return true;
  89.                 }
  90.             }
  91.             else if (current == getExclusiveOwnerThread()) {
  92.                 int nextc = c + acquires;
  93.                 if (nextc < 0) // overflow
  94.                     throw new Error("Maximum lock count exceeded");
  95.                 setState(nextc);
  96.                 return true;
  97.             }
  98.             return false;
  99.         }
  103. protected final boolean tryAcquire(int acquires) {
  104.             final Thread current = Thread.currentThread();
  105.             int c = getState();
  106.             if (c == 0) {
  107.                 if (!hasQueuedPredecessors() &&
  108.                     compareAndSetState(0, acquires)) {
  109.                     setExclusiveOwnerThread(current);
  110.                     return true;
  111.                 }
  112.             }
  113.             else if (current == getExclusiveOwnerThread()) {
  114.                 int nextc = c + acquires;
  115.                 if (nextc < 0)
  116.                     throw new Error("Maximum lock count exceeded");
  117.                 setState(nextc);
  118.                 return true;
  119.             }
  120.             return false;
  121.         }

  • 构造函数

    1.   public ReentrantLock() {
    2.       sync = new NonfairSync();
    3.   }
    5.   public ReentrantLock(boolean fair) {
    6.       sync = fair ? new FairSync() : new NonfairSync();
    7.   }
    • 默认不公平锁
  • Lock 接口实现
    • lock
      • 主要通过 Sync及子类NonfairSync FairSync实现 lock，代码在AbstractQueuedSynchronizer里实现
    • lockInterruptibly
    • tryLock
    • unLock
    • newCondition

java.io