精华内容
下载资源
问答
  • JDK源码阅读顺序

    万次阅读 多人点赞 2018-03-15 17:42:23
    很多java开发的小伙伴都会阅读jdk源码,然而确不知道应该从哪读起。以下为小编整理的通常所需阅读源码范围。 标题为包名,后面序号为优先级1-4,优先级递减 1、java.lang 1) Object 1 2) String 1 3) ...

    很多java开发的小伙伴都会阅读jdk源码,然而确不知道应该从哪读起。以下为小编整理的通常所需阅读的源码范围。
    标题为包名,后面序号为优先级1-4,优先级递减
    1、java.lang

    1) Object 1
    2) String 1
    3) AbstractStringBuilder 1
    4) StringBuffer 1
    5) StringBuilder 1
    6) Boolean 2
    7) Byte 2
    8) Double 2
    9) Float 2
    10) Integer 2
    11) Long 2
    12) Short 2
    13) Thread 2
    14) ThreadLocal 2
    15) Enum 3
    16) Throwable 3
    17) Error 3
    18) Exception 3
    19) Class 4
    20) ClassLoader 4
    21) Compiler 4
    22) System 4
    23) Package 4
    24) Void 4
    

    2、java.util

    1) AbstractList 1
    2) AbstractMap 1
    3) AbstractSet 1
    4) ArrayList 1
    5) LinkedList 1
    6) HashMap 1
    7) Hashtable 1
    8) HashSet 1
    9) LinkedHashMap 1
    10) LinkedHashSet 1
    11) TreeMap 1
    12) TreeSet 1
    13) Vector 2
    14) Queue 2
    15) Stack 2
    16) SortedMap 2
    17) SortedSet 2
    18) Collections 3
    19) Arrays 3
    20) Comparator 3
    21) Iterator 3
    22) Base64 4
    23) Date 4
    24) EventListener 4
    25) Random 4
    26) SubList 4
    27) Timer 4
    28) UUID 4
    29) WeakHashMap 4
    

    3、java.util.concurrent

    1) ConcurrentHashMap 1
    2) Executor 2
    3) AbstractExecutorService 2
    4) ExecutorService 2
    5) ThreadPoolExecutor 2
    6) BlockingQueue 2
    7)AbstractQueuedSynchronizer 2
    8)CountDownLatch 2
    9) FutureTask 2
    10)Semaphore 2
    11)CyclicBarrier 2
    13)CopyOnWriteArrayList 3
    14)SynchronousQueue 3
    15)BlockingDeque 3
    16) Callable 4
    

    4、java.util.concurrent.atomic

    1) AtomicBoolean 2
    2) AtomicInteger 2
    3) AtomicLong 2
    4) AtomicReference 3
    

    5、java.lang.reflect

    1) Field 2
    2) Method 2
    

    6、java.lang.annotation

    1) Annotation 3
    2) Target 3
    3) Inherited 3
    4) Retention 3
    5) Documented 4
    6) ElementType 4
    7) Native 4
    8) Repeatable 4
    

    7、java.util.concurrent.locks

    1) Lock 2
    2) Condition 2
    3) ReentrantLock 2
    4) ReentrantReadWriteLock 2
    

    8、java.io

    1) File 3
    2) InputStream   3
    3) OutputStream  3
    4) Reader  4
    5) Writer  4
    

    9、java.nio

    1) Buffer 3
    2) ByteBuffer 4
    3) CharBuffer 4
    4) DoubleBuffer 4
    5) FloatBuffer 4
    6) IntBuffer 4
    7) LongBuffer 4
    8) ShortBuffer 4
    

    10、java.sql

    1) Connection 3
    2) Driver 3
    3) DriverManager 3
    4) JDBCType 3
    5) ResultSet 4
    6) Statement 4
    

    11、java.net

    1) Socket 3
    2) ServerSocket 3
    3) URI 4
    4) URL 4
    5) URLEncoder 4
    

    阅读笔记简版

    1、ArrayList

    1)Object[] elementData:数据存储
    2)int size:使用数量
    3)int modCount:操作次数
    4)初始化:
      a、指定容量初始化数组;
      b、不指定容量第一次add数据时初始化数组容量10
    5)扩容:
      a、1.5倍;
      b、不够取所需最小;
      c、新容量大于MAX_ARRAY_SIZE(Integer.MAX_VALUE-8),按所需容量取MAX_ARRAY_SIZE和Integer.MAX_VALUE较小值
    

    2、LinkedList

    1) Node {E item, Node prev, Node next}
    2) int size
    3) Node first
    4) Node last
    5) linkFirst(), linkLast(), linkBefore(), unLinkFirst(), unLinkLast(), unLink(), indexOf()
    6)int modCount
    

    3、HashMap

    1) Node{int hash, K key, V value, Node next}
    注:hash是根据key算的
    2) Node[] table:数据存储,默认大小16
    3) Set<Map.Entry> entrySet:用于Map遍历的集合
    4) int size:当前数量
    5) int threshold:size超过多少时需要扩容,默认16
    6) float loadFactor:负载因子,默认0.75f
    7)int modCount:操作次数
    8) put():根据key算hash,根据容量和hash算index,table[index]没有直接添加到数组中,table[index]有,若index位置同一个key则更新,否则遍历next是否有,有则更新,无则新增
    注:判断key是否相等,先比较hash,若相等在比较equals
    9)扩容:put后,当size>threshold时需要扩容,扩容时容量翻倍,重新算hash复制到新数组
    10)哈希冲突:1.7以前数组+链表,1.8开始数组+红黑树
    11)get()类似
    

    4、ConcurrentHashMap

    1) JDK1.7及以前:
    	a、Segment[] ,HashEntry[] , HashEntry{hash, k, v, next}
    	b、根据key算hash,根据hash和Segment的大小算位置,每个segment拥有一个自己的HashEntry[]
    	c、get():不加锁,volatile类型
    	d、put(): 对相应segment加锁
    	e、size():各HashEntry[] 之和,先不加锁算两遍,若一致则返回,若不一致则加锁重新计算
    2)JDK1.8
    	a、Node{hash, key, value, next}
    	b、Node[] table
    	c、大多数操作类似于HashMap,根据key算hash,在根据hash和容量算index,对table[index]加锁,从而达到更大的并发量
    	d、get(): 同HashMap
    	e、put(): 对table[index]加锁,如果table[index]为null则使用CAS操作,如果不为null对table[index]加synchronized
    

    5、Hashtable

    1) 结构实现与HashMap基本一致
    2)通过synchronized方法保证线程安全
    

    6、LinkedHashMap

    1)继承HashMap
    2) Entry{HashMap.Node, Entry before, after}
    3) Entry head, tail
    4) 重写newNode()添加节点时,除像HashMap中添加外,保存before、after信息
    

    7、TreeMap

    1)红黑树,即自平衡二叉查找树,时间复杂度O(logn)
    2)Entry{K k, V v, Entry parent, left, right, boolean color}
    3)Entry root,int size, int modeCount
    

    8、Object

    1) wait(), notify(), notifyAll(), wait(timeout)
    2) hashCode(), equals()
    3) clone()
    

    9、String

    1) final char[] value
    2) int hash
    3) equals(), startWith(), endWith(), replace
    

    10、AbstractStringBuilder

    1) char[] value
    2) int count
    3) 扩容:翻倍,不够取所需最小
    

    11、StringBuilder:继承AbstractStringBuilder
    12、StringBuffer

    1) 继承AbstractStringBuilder
    2) synchronized方法保证线程安全
    3) char[] toStringCache
    

    13、Set一般都是使用委托模式到Map
    14、AbstractMap维护EntrySet,AbstractSet维护Iterator,AbstractList维护Iterator

    展开全文
  • LinkedList源码阅读

    千次阅读 2018-09-27 15:02:49
    LinkedList源码阅读

    主要内容:

    1.  LinkedList是双向还是单向?
    2. 为什么说LinkedList不支持高效的随机元素访问?
        /**
         * 创建一个空列表
         */
        public LinkedList() {
        }
    
        // LinkedList内部会维护头尾节点,所以getFirst()、getLast()都是很快的。
        transient int size = 0;
        transient Node<E> first;
        transient Node<E> last;

    底层是一个Node内部类构成的链表:

        private static class Node<E> {
            E item;
            Node<E> next;
            Node<E> prev;
    
            Node(Node<E> prev, E element, Node<E> next) {
                this.item = element;
                this.next = next;
                this.prev = prev;
            }
        }

    linkFirst

        /**
         * 链接e作为第一个元素。
         */
        private void linkFirst(E e) {
            // 如果当前链表刚刚初始化即为空,则f为null
            final Node<E> f = first;
            // 创建一个新节点,排列顺序为null,e,f
            final Node<E> newNode = new Node<>(null, e, f);
            // 将新节点赋值给首节点
            first = newNode;
            // 如果链表为空
            if (f == null)
                last = newNode;
            else
                // 此时f已经不再是首节点
                f.prev = newNode;
            // 增加一个元素后,size+1
            size++;
            modCount++;
        }

     

    linkLast

        /**
         * 链接e作为最后一个元素。
         */
        void linkLast(E e) {
            // 如果当前链表刚刚初始化即为空,则l为null
            final Node<E> l = last;
            // 创建一个新节点,排列顺序为l,e,null
            final Node<E> newNode = new Node<>(l, e, null);
            // 将新节点赋值给尾节点
            last = newNode;
            // 如果尾节点为空,即链表为空
            if (l == null)
                first = newNode;
            else
                l.next = newNode;
            size++;
            modCount++;
        }

    get

        public E get(int index) {
            checkElementIndex(index);
            return node(index).item;
        }
    
        /**
         * 返回指定元素索引处的(非空)节点。
         * LinkedList#get(index)(较慢,因为要通过node(index)方法遍历到i元素再取出,
         * 而链表是不连续的)
         */
        Node<E> node(int index) {
            // 比较索引值和链表长度的1/2
            if (index < (size >> 1)) {
            // 如果后者大,就从首节点一个个往后找
                Node<E> x = first;
                for (int i = 0; i < index; i++)
                    // 一个个的next本质是顺序访问
                    x = x.next;
                return x;
            } else {
                // 如果前者大,就从尾结点一个个往前找
                Node<E> x = last;
                for (int i = size - 1; i > index; i--)
                    x = x.prev;
                return x;
            }
        }

    linkBefore

        /**
         * 在指定索引处插入元素e
         */
        public void add(int index, E element) {
            checkPositionIndex(index);
    
            if (index == size)
                linkLast(element);
            else
                linkBefore(element, node(index));
        }
        /**
         * 在非空的节点succ前插入e节点
         */
        void linkBefore(E e, Node<E> succ) {
            // assert succ != null;
            final Node<E> pred = succ.prev;
            final Node<E> newNode = new Node<>(pred, e, succ);
            succ.prev = newNode;
            if (pred == null)
                first = newNode;
            else
                pred.next = newNode;
            size++;
            modCount++;
        }

    最后说一点:虽然我们分析问题时都是强调链表结构插入和删除比数组结构快,但理想化的链表节点插入和删除是不存在的,任何基于线性结构的容器,插入和删除的实现必然伴随着遍历。虽然链表对于某个节点的插入和删除确实比数组快,但是遍历相对较吃力,所以实际增删的效率并不能一概而论。

    展开全文
  • MyBatis源码阅读

    2018-09-30 08:21:09
  • 再谈源码阅读

    2019-07-21 09:36:59
    再谈源码阅读

    source code

    在软件开发中遇到问题的时候,我倾向于在不需要阅读源码的情况下解决问题,我会优先去查官方文档、FAQ、google或stackoverflow等网站,去看下有没有前人已经遇到过同类问题。阅读源码来解决问题,算是杀手锏。当然,还有另一种需求,就是希望通过阅读源码了解软件的设计细节,来达到学习的目的,例如,通过阅读Dubbo的源码,我可以了解一个RPC框架的设计细节。

    前提

    阅读源码之前要做一定的准备工作。

    首先,确保自己掌握了相关的基础知识,例如,如果你要阅读Linux内核源码,要掌握C语言的语法、操作系统的基本概念和原理,如果你要阅读Spring的源码,要掌握Java语言基础、Maven的使用、一些设计模式等等;

    第二,要学会使用这个软件或框架,了解这个软件或框架的使用场景,有什么功能,同类竞品有哪些,在学习使用软件或框架的过程中,最重要的参考资料是官方文档,一款优质的软件或框架,官方文档一般包括三块:快速开始,即一些demo;参考文档,最详细的文档,包括概念、特性的解读;FAQ:对于使用者来说常见的问题的解答;

    第三,初步了解代码的整体组织结构,每个文件夹是做什么用的。

    调试环境

    调试环境非常重要,有了调试环境,就可以根据需要进行断点,对阅读源码非常有帮助。至于说如何搭建调试环境,不同的情况有不同的处理办法,例如MAT的源码,我是先将它的核心逻辑剥离出来,然后自己用单元测试进行调试;对于Dubbo源码,我则是写了一个Dubbo服务提供者、一个Dubbo服务消费者,以及安装了ZK之后才搭建起来的;对于Spring最简单了,利用Spring Boot启动一个hello word的demo就可以。

    场景阅读

    在做完上述准备工作后,我会按照使用功能或场景来阅读源码,例如,在阅读MAT(内存分析工具)的源码的时候,我是按照以下几个步骤来阅读:文件解析、索引创建、类直方图查询、支配树查询、线程视图查询等等;在阅读Spring源码的时候,我会按照Spring容器的启动、IoC的工作过程、AOP的工作过程、静态属性的引入等功能来阅读;在阅读Dubbo源码的时候,我会按照服务发布、服务订阅、服务调用三个主要场景进行源码阅读。按照功能或场景阅读,可以让我们从整体上对代码有所理解,然后就可以进入自己关注的一些细节了,例如:在MAT中,索引文件是如何创建的,在Dubbo中,请求的超时机制和心跳机制是如何实现的。

    总结

    阅读源码的过程中,我总结出了一些需要注意的点:

    1. 自顶向下阅读,先把握整体的、大的流程,然后再根据需要切入到对应的分支
    2. 忽略一些细节,例如参数的检查、错误的处理、数据形式的转换和存储
    3. 尽量准备好调试环境
    4. 要关注核心的业务逻辑或算法
    5. 最好能在阅读的过程中输出一些笔记或文档,例如模块划分图、函数的流程图、针对某个业务场景,在几个模块之间的时序图等等,这些文档可以先手写,然后再形成电子版存档。

    上述就是我自己针对源码阅读的一些经验,如果你有好的经验或想法,欢迎在留言区与我交流

    ***本号专注于后端技术、JVM问题排查和优化、Java面试题、个人成长和自我管理等主题,为读者提供一线开发者的工作和成长经验,期待你能在这里有所收获。javaadu

    展开全文
  • Redis源码阅读

    千次阅读 2019-03-18 16:00:04
    Redis源码阅读 文章目录Redis源码阅读1 数据结构1.1 动态字符串SDS1.2 双向链表ADLIST1.3 字典 DICT1.4 跳跃表1.5 hyperloglog2 内存编码2.1 整数集合intset2.2 压缩列表ziplist3 数据类型的实现3.1 Object4 数据库...
  • afl源码阅读

    2020-04-09 18:40:22
    afl源码阅读(原始策略): https://blog.csdn.net/weixin_30500105/article/details/97935796
  • tensorflow源码阅读

    2018-07-03 19:52:33
    title: tensorflow源码阅读 categories: tensorflow tags: 源码 http://www.cnblogs.com/yao62995/p/5773578.html
  • 源码阅读工具 UnderStand

    千次阅读 2019-12-18 19:16:29
    源码阅读工具 UnderStand 特色: 1、支持多语言:Ada, C, C++, C#, Java, FORTRAN, Delphi, Jovial, and PL/M ,混合语言的project也支持 2、多平台:Windows/Linux/Solaris/HP-UX/IRIX/MAC OS X 3、代码语法高亮、...
  • Linux内核源码阅读以及工具(转)

    万次阅读 2018-09-21 01:04:33
    Linux内核源码阅读以及工具(转) 转载地址:Linux内核源码阅读以及工具(转)
  • kafka源码阅读环境搭建

    千次阅读 2019-08-22 00:47:33
    源码阅读环境搭建
  • 源码阅读系列:源码阅读方法

    万次阅读 2016-07-21 17:54:16
    2.UML能力在软件工程中,UML在软件的不同生命周期阶段扮演着非常重要的角色,没有好的UML水平,面对大型的项目源码会束手无策。3.对业务的理解如果你要阅读的项目业务性比较强,事先对业务有一定的了解是必须的。4....
  • Hive源码阅读之路

    千次阅读 2020-11-08 14:12:43
    Hive源码阅读(1)阅读环境搭建前言:让学习成为一种习惯环境准备Hive源码下载Hive源码目录hive三个最重要的组件:其他组件hive辅助组件编译源码配置Hive本地调试配置IDEA-DEBUG(注意端口和Host)开始Debug,配置...
  • 集合(一) AbstractList 源码阅读

    万次阅读 2020-11-26 09:20:17
    第一次仔细的看源码,我是直接将AbstractList的源码复制一份,放在自己建立的AbstractList上面,对英文注释去掉,改成中文注释,并且加入自己的理解. package com.lin; import java.util.*; /** * AbstractList 源码...
  • 源码阅读的方法、误区以及三种境界

    万次阅读 多人点赞 2020-12-23 22:15:57
    摘要:笔者出品12个免费的源码分析专栏,覆盖RocketMQ、Kafka、Dubbo、Sentinel 等JAVA主流中间件,并借此实现年薪翻倍等成绩,对源码阅读有着深刻的理解。
  • Enterprise Architect https://blog.csdn.net/WHHGARSKY/article/details/70164180 Source Insight https://blog.csdn.net/tao546377318/article/details/51611273 Understand(mac下面) ...
  • 源码阅读步骤

    千次阅读 2017-02-22 11:40:22
    源码阅读,我觉得最核心有三点:技术基础+强烈的求知欲+耐心。  说到技术基础,我打个比方吧,如果你从来没有学过Java,或是任何一门编程语言如C++,一开始去啃《Core Java》,你是很难从中吸收到营养的,特别是...
  • 学习任务近期想增加部分源码阅读经验,提高自己在造轮子方面的实力,增长些在设计模式应用方面的编码能力,以及怀着向大佬们膜拜的心情,开始有计划地阅读Spring源码前期准备 以下几项准备事项,算是基本的日常...
  • 下载源码3.1 源码地址3.2 通过gitee中转3.2.1 进去github源码地址,复制URL3.2.2 进入gitee,选择右上角加号,选择从GitHub/GitLab导入仓库3.2.3 粘贴复制的github地址到第一栏,然后为自己的仓库命名3.2.4 下载...
  • kubernetes源码阅读之kubelet启动

    万次阅读 2016-08-19 16:30:13
    kubernetes源码阅读之kubelet启动
  • springFramework源码阅读入门准备源码下载idea导入项目 准备 装好git工具 装好gradle工具 装好idea(我这里是用idea阅读的源码) 源码下载 github地址:https://github.com/spring-projects/spring-framework ...
  • spring5.3.x源码阅读环境搭建

    千次阅读 2020-07-08 10:31:30
    spring5.3.x源码阅读环境搭建-gradle构建编译 文章目录spring5.3.x源码阅读环境搭建-gradle构建编译一、依赖工具二、下载源码三、开始构建四、编译源码五、源码测试六、问题及解决方案附:spring源代码各个模块作用...
  • 源码阅读工具UnderStand完整破解版

    热门讨论 2013-06-14 14:34:17
    一款很有用但却不出名的源码阅读工具,它的图表分析功能可以秒杀source insight,里面附带破解工具
  • Spring源码阅读(一):获取源码

    千次阅读 2018-05-07 17:31:35
    Spring源码阅读(一):获取源码Spring是2003年开始兴起的一个框架,发展到今天已是非常的强大。对于工作2、3年的人在面试的时候,可能都会被问到是否看过开源框架的源码,以及谈谈你看过源码之后的心得或者见解之类...
  • 刚才在论坛不经意间,看到有关源码阅读的帖子。回想自己前几年,阅读源码那种兴奋和成就感(1),不禁又有一种激动。源码阅读,我觉得最核心有三点:技术基础+强烈的求知欲+耐心。说到技术基础,我打个比方吧,如果你...
  • Kafka2.0 源码阅读环境搭建 工欲善其事必先利其器,在阅读Kafka源码之前,首先第一步得搭建源码阅读环境,选择合适的工具可以使我们的学习效率更好,在这里我选用Intellij Idea 作为源码阅读环境的IDEA环境。其次...
  • spring源码阅读环境(几分钟下载包)

    万次阅读 多人点赞 2019-11-09 17:42:26
    下载spring源码:2.安装gradle:3.构建源码:导入idea: 简述: 不能忍受慢(看到这里你就准备笑吧!!) 其他大神的博客实在让我难受 自己动手,下载spring,编译spring源码,导入idea,开启学习模式!! 笔者环境:...
  • Laravel 5.1 源码阅读笔记

    万次阅读 2015-11-05 18:04:42
    Laravel 5.1 源码阅读笔记,主要涉及入口文件、Kernel、Application、Pipeline、Middleware、Router、Request、Response、Bootstrap等等。
  • MyBatis 源码阅读之旅一

    万次阅读 2016-07-30 22:07:19
    MyBatis 源码阅读
  • java源码阅读的思路 JDK源码阅读顺序 Java源码之Object Java源码之String

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 54,799
精华内容 21,919
关键字:

源码阅读