K'illCode
K'illCode

Java引用类型原理剖析

Java中一共有4种引用类型(其实还有一些其他的引用类型比如FinalReference)：强引用、软引用、弱引用、虚引用。其中强引用就是我们经常使用的 Objecta=newObject(); 这样的形式，在Java中并没有对应的Reference类。

本篇文章主要是分析软引用、弱引用、虚引用的实现，这三种引用类型都是继承于Reference这个类，主要逻辑也在Reference中。

问题

在分析前，先抛几个问题？

1.网上大多数文章对于软引用的介绍是：在内存不足的时候才会被回收，那内存不足是怎么定义的？什么才叫内存不足？

2.网上大多数文章对于虚引用的介绍是：形同虚设，虚引用并不会决定对象的生命周期。主要用来跟踪对象被垃圾回收器回收的活动。真的是这样吗？

3.虚引用在Jdk中有哪些场景下用到了呢？

Reference

我们先看下 Reference.java中的几个字段

 

  1. public abstract class Reference {

  2.    //引用的对象

  3.    private T referent;        

  4.    //回收队列，由使用者在Reference的构造函数中指定

  5.    volatile ReferenceQueue queue;

  6.     //当该引用被加入到queue中的时候，该字段被设置为queue中的下一个元素，以形成链表结构

  7.    volatile Reference next;

  8.    //在GC时，JVM底层会维护一个叫DiscoveredList的链表，存放的是Reference对象，discovered字段指向的就是链表中的下一个元素，由JVM设置

  9.    transient private Reference discovered;  

  10.    //进行线程同步的锁对象

  11.    static private class Lock { }

  12.    private static Lock lock = new Lock();

  13.    //等待加入queue的Reference对象，在GC时由JVM设置，会有一个java层的线程(ReferenceHandler)源源不断的从pending中提取元素加入到queue

  14.    private static Reference pending = null;

  15. }

    16. 一个Reference对象的生命周期如下：

    Java引用类型原理剖析_第1张图片

    主要分为Native层和Java层两个部分。

    Native层在GC时将需要被回收的Reference对象加入到DiscoveredList中（代码在 referenceProcessor.cpp中 process_discovered_references方法），然后将DiscoveredList的元素移动到PendingList中（代码在 referenceProcessor.cpp中 enqueue_discovered_ref_helper方法）,PendingList的队首就是Reference类中的pending对象。 具体代码就不分析了，有兴趣的同学可以看看这篇文章。

    http://www.importnew.com/21628.html

    看看Java层的代码

     

    1. private static class ReferenceHandler extends Thread {

    2.         ...

    3.        public void run() {

    4.            while (true) {

    5.                tryHandlePending(true);

    6.            }

    7.        }

    8.  }

    9. static boolean tryHandlePending(boolean waitForNotify) {

    10.        Reference r;

    11.        Cleaner c;

    12.        try {

    13.            synchronized (lock) {

    14.                if (pending != null) {

    15.                    r = pending;

    16.                     //如果是Cleaner对象，则记录下来，下面做特殊处理

    17.                    c = r instanceof Cleaner ? (Cleaner) r : null;

    18.                    //指向PendingList的下一个对象

    19.                    pending = r.discovered;

    20.                    r.discovered = null;

    21.                } else {

    22.                   //如果pending为null就先等待，当有对象加入到PendingList中时，jvm会执行notify

    23.                    if (waitForNotify) {

    24.                        lock.wait();

    25.                    }

    26.                    // retry if waited

    27.                    return waitForNotify;

    28.                }

    29.            }

    30.        }

    31.        ...

    32.  

    33.        // 如果时CLeaner对象，则调用clean方法进行资源回收

    34.        if (c != null) {

    35.            c.clean();

    36.            return true;

    37.        }

    38.        //将Reference加入到ReferenceQueue，开发者可以通过从ReferenceQueue中poll元素感知到对象被回收的事件。

    39.        ReferenceQueue q = r.queue;

    40.        if (q != ReferenceQueue.NULL) q.enqueue(r);

    41.        return true;

    42. }

      43. 流程比较简单：就是源源不断的从PendingList中提取出元素，然后将其加入到ReferenceQueue中去，开发者可以通过从ReferenceQueue中poll元素感知到对象被回收的事件。

      另外需要注意的是，对于Cleaner类型（继承自虚引用）的对象会有额外的处理：在其指向的对象被回收时，会调用clean方法，该方法主要是用来做对应的资源回收，在堆外内存DirectByteBuffer中就是用Cleaner进行堆外内存的回收，这也是虚引用在java中的典型应用。

      看完了Reference的实现，再看看几个实现类里，各自有什么不同。

      SoftReference

       

      1. public class SoftReference extends Reference {

      2.  

      3.    static private long clock;

      4.  

      5.    private long timestamp;

      6.  

      7.    public SoftReference(T referent) {

      8.        super(referent);

      9.        this.timestamp = clock;

      10.    }

      11.  

      12.    public SoftReference(T referent, ReferenceQueue q) {

      13.        super(referent, q);

      14.        this.timestamp = clock;

      15.    }

      16.  

      17.    public T get() {

      18.        T o = super.get();

      19.        if (o != null && this.timestamp != clock)

      20.            this.timestamp = clock;

      21.        return o;

      22.    }

      23.  

      24. }

      软引用的实现很简单，就多了两个字段： clock和 timestamp。 clock是个静态变量，每次GC时都会将该字段设置成当前时间。 timestamp字段则会在每次调用get方法时将其赋值为 clock（如果不相等且对象没被回收）。

      那这两个字段的作用是什么呢？这和软引用在内存不够的时候才被回收，又有什么关系呢？

      这些还得看JVM的源码才行，因为决定对象是否需要被回收都是在GC中实现的。

       

      1. size_t

      2. ReferenceProcessor::process_discovered_reflist(

      3.  DiscoveredList               refs_lists[],

      4.  ReferencePolicy*             policy,

      5.  bool                         clear_referent,

      6.  BoolObjectClosure*           is_alive,

      7.  OopClosure*                  keep_alive,

      8.  VoidClosure*                 complete_gc,

      9.  AbstractRefProcTaskExecutor* task_executor)

      10. {

      11. ...

      12.   //还记得上文提到过的DiscoveredList吗?refs_lists就是DiscoveredList。

      13.   //对于DiscoveredList的处理分为几个阶段，SoftReference的处理就在第一阶段

      14. ...

      15.      for (uint i = 0; i < _max_num_q; i++) {

      16.        process_phase1(refs_lists[i], policy,

      17.                       is_alive, keep_alive, complete_gc);

      18.      }

      19. ...

      20. }

      21.  

      22. //该阶段的主要目的就是当内存足够时，将对应的SoftReference从refs_list中移除。

      23. void

      24. ReferenceProcessor::process_phase1(DiscoveredList&    refs_list,

      25.                                   ReferencePolicy*   policy,

      26.                                   BoolObjectClosure* is_alive,

      27.                                   OopClosure*        keep_alive,

      28.                                   VoidClosure*       complete_gc) {

      29.  

      30.  DiscoveredListIterator iter(refs_list, keep_alive, is_alive);

      31.  // Decide which softly reachable refs should be kept alive.

      32.  while (iter.has_next()) {

      33.    iter.load_ptrs(DEBUG_ONLY(!discovery_is_atomic() /* allow_null_referent */));

      34.    //判断引用的对象是否存活

      35.    bool referent_is_dead = (iter.referent() != NULL) && !iter.is_referent_alive();

      36.    //如果引用的对象已经不存活了，则会去调用对应的ReferencePolicy判断该对象是不时要被回收

      37.    if (referent_is_dead &&

      38.        !policy->should_clear_reference(iter.obj(), _soft_ref_timestamp_clock)) {

      39.      if (TraceReferenceGC) {

      40.        gclog_or_tty->print_cr("Dropping reference (" INTPTR_FORMAT ": %s"  ") by policy",

      41.                               (void *)iter.obj(), iter.obj()->klass()->internal_name());

      42.      }

      43.      // Remove Reference object from list

      44.      iter.remove();

      45.      // Make the Reference object active again

      46.      iter.make_active();

      47.      // keep the referent around

      48.      iter.make_referent_alive();

      49.      iter.move_to_next();

      50.    } else {

      51.      iter.next();

      52.    }

      53.  }

      54. ...

      55. }

      refs_lists中存放了本次GC发现的某种引用类型（虚引用、软引用、弱引用等），而 process_discovered_reflist方法的作用就是将不需要被回收的对象从 refs_lists移除掉， refs_lists最后剩下的元素全是需要被回收的元素，最后会将其第一个元素赋值给上文提到过的 Reference.java#pending字段。

      ReferencePolicy一共有4种实现：NeverClearPolicy，AlwaysClearPolicy，LRUCurrentHeapPolicy，LRUMaxHeapPolicy。其中NeverClearPolicy永远返回false，代表永远不回收SoftReference，在JVM中该类没有被使用，AlwaysClearPolicy则永远返回true，在 referenceProcessor.hpp#setup方法中中可以设置policy为AlwaysClearPolicy，至于什么时候会用到AlwaysClearPolicy，大家有兴趣可以自行研究。

      LRUCurrentHeapPolicy和LRUMaxHeapPolicy的shouldclearreference方法则是完全相同：

       

      1. bool LRUMaxHeapPolicy::should_clear_reference(oop p,

      2.                                             jlong timestamp_clock) {

      3.  jlong interval = timestamp_clock - java_lang_ref_SoftReference::timestamp(p);

      4.  assert(interval >= 0, "Sanity check");

      5.  

      6.  // The interval will be zero if the ref was accessed since the last scavenge/gc.

      7.  if(interval <= _max_interval) {

      8.    return false;

      9.  }

      10.  

      11.  return true;

      12. }

      timestamp_clock就是SoftReference的静态字段 clock， java_lang_ref_SoftReference::timestamp(p)对应是字段 timestamp。如果上次GC后有调用 SoftReference#get， interval值为0，否则为若干次GC之间的时间差。

      _max_interval则代表了一个临界值，它的值在LRUCurrentHeapPolicy和LRUMaxHeapPolicy两种策略中有差异。

       

      1. void LRUCurrentHeapPolicy::setup() {

      2.  _max_interval = (Universe::get_heap_free_at_last_gc() / M) * SoftRefLRUPolicyMSPerMB;

      3.  assert(_max_interval >= 0,"Sanity check");

      4. }

      5.  

      6. void LRUMaxHeapPolicy::setup() {

      7.  size_t max_heap = MaxHeapSize;

      8.  max_heap -= Universe::get_heap_used_at_last_gc();

      9.  max_heap /= M;

      10.  

      11.  _max_interval = max_heap * SoftRefLRUPolicyMSPerMB;

      12.  assert(_max_interval >= 0,"Sanity check");

      13. }

      其中 SoftRefLRUPolicyMSPerMB默认为1000，前者的计算方法和上次GC后可用堆大小有关，后者计算方法和（堆大小-上次gc时堆使用大小）有关。

      看到这里你就知道SoftReference到底什么时候被被回收了，它和使用的策略（默认应该是LRUCurrentHeapPolicy），堆可用大小，该SoftReference上一次调用get方法的时间都有关系。

      WeakReference

       

      1. public class WeakReference extends Reference {

      2.  

      3.    public WeakReference(T referent) {

      4.        super(referent);

      5.    }

      6.  

      7.    public WeakReference(T referent, ReferenceQueue q) {

      8.        super(referent, q);

      9.    }

      10.  

      11. }

      可以看到WeakReference在Java层只是继承了Reference，没有做任何的改动。那referent字段是什么时候被置为null的呢？要搞清楚这个问题我们再看下上文提到过的 process_discovered_reflist方法：

       

      1. size_t

      2. ReferenceProcessor::process_discovered_reflist(

      3.  DiscoveredList               refs_lists[],

      4.  ReferencePolicy*             policy,

      5.  bool                         clear_referent,

      6.  BoolObjectClosure*           is_alive,

      7.  OopClosure*                  keep_alive,

      8.  VoidClosure*                 complete_gc,

      9.  AbstractRefProcTaskExecutor* task_executor)

      10. {

      11. ...

      12.  

      13.  //Phase 1:将所有不存活但是还不能被回收的软引用从refs_lists中移除（只有refs_lists为软引用的时候，这里policy才不为null）

      14.  if (policy != NULL) {

      15.    if (mt_processing) {

      16.      RefProcPhase1Task phase1(*this, refs_lists, policy, true /*marks_oops_alive*/);

      17.      task_executor->execute(phase1);

      18.    } else {

      19.      for (uint i = 0; i < _max_num_q; i++) {

      20.        process_phase1(refs_lists[i], policy,

      21.                       is_alive, keep_alive, complete_gc);

      22.      }

      23.    }

      24.  } else { // policy == NULL

      25.    assert(refs_lists != _discoveredSoftRefs,

      26.           "Policy must be specified for soft references.");

      27.  }

      28.  

      29.  // Phase 2:

      30.  // 移除所有指向对象还存活的引用

      31.  if (mt_processing) {

      32.    RefProcPhase2Task phase2(*this, refs_lists, !discovery_is_atomic() /*marks_oops_alive*/);

      33.    task_executor->execute(phase2);

      34.  } else {

      35.    for (uint i = 0; i < _max_num_q; i++) {

      36.      process_phase2(refs_lists[i], is_alive, keep_alive, complete_gc);

      37.    }

      38.  }

      39.  

      40.  // Phase 3:

      41.  // 根据clear_referent的值决定是否将不存活对象回收

      42.  if (mt_processing) {

      43.    RefProcPhase3Task phase3(*this, refs_lists, clear_referent, true /*marks_oops_alive*/);

      44.    task_executor->execute(phase3);

      45.  } else {

      46.    for (uint i = 0; i < _max_num_q; i++) {

      47.      process_phase3(refs_lists[i], clear_referent,

      48.                     is_alive, keep_alive, complete_gc);

      49.    }

      50.  }

      51.  

      52.  return total_list_count;

      53. }

      54.  

      55. void

      56. ReferenceProcessor::process_phase3(DiscoveredList&    refs_list,

      57.                                   bool               clear_referent,

      58.                                   BoolObjectClosure* is_alive,

      59.                                   OopClosure*        keep_alive,

      60.                                   VoidClosure*       complete_gc) {

      61.  ResourceMark rm;

      62.  DiscoveredListIterator iter(refs_list, keep_alive, is_alive);

      63.  while (iter.has_next()) {

      64.    iter.update_discovered();

      65.    iter.load_ptrs(DEBUG_ONLY(false /* allow_null_referent */));

      66.    if (clear_referent) {

      67.      // NULL out referent pointer

      68.      //将Reference的referent字段置为null，之后会被GC回收

      69.      iter.clear_referent();

      70.    } else {

      71.      // keep the referent around

      72.      //标记引用的对象为存活，该对象在这次GC将不会被回收

      73.      iter.make_referent_alive();

      74.    }

      75.    ...

      76.  }

      77.    ...

      78. }

      不管是弱引用还是其他引用类型，将字段referent置null的操作都发生在 process_phase3中，而具体行为是由 clear_referent的值决定的。而 clear_referent的值则和引用类型相关。

       

      1. ReferenceProcessorStats ReferenceProcessor::process_discovered_references(

      2.  BoolObjectClosure*           is_alive,

      3.  OopClosure*                  keep_alive,

      4.  VoidClosure*                 complete_gc,

      5.  AbstractRefProcTaskExecutor* task_executor,

      6.  GCTimer*                     gc_timer) {

      7.  NOT_PRODUCT(verify_ok_to_handle_reflists());

      8.    ...

      9.  //process_discovered_reflist方法的第3个字段就是clear_referent

      10.  // Soft references

      11.  size_t soft_count = 0;

      12.  {

      13.    GCTraceTime tt("SoftReference", trace_time, false, gc_timer);

      14.    soft_count =

      15.      process_discovered_reflist(_discoveredSoftRefs, _current_soft_ref_policy, true,

      16.                                 is_alive, keep_alive, complete_gc, task_executor);

      17.  }

      18.  

      19.  update_soft_ref_master_clock();

      20.  

      21.  // Weak references

      22.  size_t weak_count = 0;

      23.  {

      24.    GCTraceTime tt("WeakReference", trace_time, false, gc_timer);

      25.    weak_count =

      26.      process_discovered_reflist(_discoveredWeakRefs, NULL, true,

      27.                                 is_alive, keep_alive, complete_gc, task_executor);

      28.  }

      29.  

      30.  // Final references

      31.  size_t final_count = 0;

      32.  {

      33.    GCTraceTime tt("FinalReference", trace_time, false, gc_timer);

      34.    final_count =

      35.      process_discovered_reflist(_discoveredFinalRefs, NULL, false,

      36.                                 is_alive, keep_alive, complete_gc, task_executor);

      37.  }

      38.  

      39.  // Phantom references

      40.  size_t phantom_count = 0;

      41.  {

      42.    GCTraceTime tt("PhantomReference", trace_time, false, gc_timer);

      43.    phantom_count =

      44.      process_discovered_reflist(_discoveredPhantomRefs, NULL, false,

      45.                                 is_alive, keep_alive, complete_gc, task_executor);

      46.  }

      47.    ...

      48. }

      可以看到，对于Soft references和Weak references clear_referent字段传入的都是true，这也符合我们的预期：对象不可达后，引用字段就会被置为null，然后对象就会被回收（对于软引用来说，如果内存足够的话，在Phase 1，相关的引用就会从refslist中被移除，到Phase 3时refslist为空集合）。

      但对于Final references和 Phantom references， clear_referent字段传入的是false，也就意味着被这两种引用类型引用的对象，如果没有其他额外处理，只要Reference对象还存活，那引用的对象是不会被回收的。Final references和对象是否重写了finalize方法有关，不在本文分析范围之内，我们接下来看看Phantom references。

      PhantomReference

       

      1. public class PhantomReference extends Reference {

      2.  

      3.    public T get() {

      4.        return null;

      5.    }

      6.  

      7.    public PhantomReference(T referent, ReferenceQueue q) {

      8.        super(referent, q);

      9.    }

      10.  

      11. }

      可以看到虚引用的get方法永远返回null，我们看个demo。

       

      1. public static void demo() throws InterruptedException {

      2.        Object obj = new Object();

      3.        ReferenceQueue refQueue =new ReferenceQueue<>();

      4.        PhantomReference phanRef =new PhantomReference<>(obj, refQueue);

      5.  

      6.        Object objg = phanRef.get();

      7.        //这里拿到的是null

      8.        System.out.println(objg);

      9.        //让obj变成垃圾

      10.        obj=null;

      11.        System.gc();

      12.        Thread.sleep(3000);

      13.        //gc后会将phanRef加入到refQueue中

      14.        Reference phanRefP = refQueue.remove();

      15.         //这里输出true

      16.        System.out.println(phanRefP==phanRef);

      17.    }

        18. 从以上代码中可以看到，虚引用能够在指向对象不可达时得到一个'通知'（其实所有继承References的类都有这个功能），需要注意的是GC完成后，phanRef.referent依然指向之前创建Object，也就是说Object对象一直没被回收！

        而造成这一现象的原因在上一小节末尾已经说了： 对于Finalreferences和Phantomreferences，clear_referent 字段传入的时false，也就意味着被这两种引用类型引用的对象，如果没有其他额外处理，在GC中是不会被回收的。

        对于虚引用来说，从 refQueue.remove();得到引用对象后，可以调用 clear方法强行解除引用和对象之间的关系，使得对象下次可以GC时可以被回收掉。

        End

        针对文章开头提出的几个问题，看完分析，我们已经能给出回答：

        1.我们经常在网上看到软引用的介绍是：在内存不足的时候才会回收，那内存不足是怎么定义的？为什么才叫内存不足？

        软引用会在内存不足时被回收，内存不足的定义和该引用对象get的时间以及当前堆可用内存大小都有关系，计算公式在上文中也已经给出。

        2.网上对于虚引用的介绍是：形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。主要用来跟踪对象被垃圾回收器回收的活动。真的是这样吗？

        严格的说，虚引用是会影响对象生命周期的，如果不做任何处理，只要虚引用不被回收，那其引用的对象永远不会被回收。所以一般来说，从ReferenceQueue中获得PhantomReference对象后，如果PhantomReference对象不会被回收的话（比如被其他GC ROOT可达的对象引用），需要调用 clear方法解除PhantomReference和其引用对象的引用关系。

        3.虚引用在Jdk中有哪些场景下用到了呢？

        DirectByteBuffer中是用虚引用的子类 Cleaner.java来实现堆外内存回收的

        你可能感兴趣的:(Java基础)

        • Hadoop 与 Spark：大数据处理的比较 王子良. 大数据经验分享hadoopspark大数据
          欢迎来到我的博客！非常高兴能在这里与您相遇。在这里，您不仅能获得有趣的技术分享，还能感受到轻松愉快的氛围。无论您是编程新手，还是资深开发者，都能在这里找到属于您的知识宝藏，学习和成长。博客内容包括：Java核心技术与微服务：涵盖Java基础、JVM、并发编程、Redis、Kafka、Spring等，帮助您全面掌握企业级开发技术。大数据技术：涵盖Hadoop（HDFS）、Hive、Spark、Fli
        • 2025春招，Spring 面试题汇总 springjava面试
          大家好，我是V哥。2025年金三银四春招马上进入白热化，兄弟们在即将到来的假期，除了吃喝欢乐过新年，想年后跳槽升职的兄弟也要做好充分的准备，要相信，机会永远只留给有准备的人。以下是一份2025年春招Spring面试题汇总，送给大家，关于Java基础相关的请移步V哥上一篇文章《【长文收藏】2025备战金三银四Java大厂面试题》：Spring基础部分一、Spring基础1.什么是Spring框架？答
        • Java基础——数据类型（种类、包装类型、缓存机制、装拆箱、精度丢失） Camel卡蒙 Java基础java缓存python
          我是一个计算机专业研0的学生卡蒙Camel（刚保研）记录每天学习过程（主要学习Java、python、人工智能），总结知识点（内容来自：自我总结+网上借鉴）希望大家能一起发现问题和补充，也欢迎讨论文章目录Java数据类型数据类型种类包装类型和基本类型包装类型的缓存机制装箱与拆箱BigDecimal精度丢失问题使用BigDecimal解决Java数据类型数据类型种类Java有8大基本数据类型：类型关
        • 【Java基础】抽象类、接口、内部的运用与作用分析，枚举类型的使用 唐僧洗头爱飘柔9527 javajava开发语言JavaSE内部类抽象类interface接口枚举类
          1.抽象类在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法、初始化块和构造方法和普通类一样。并且抽象类和普通类相比还多出了抽象方法。格式：[修饰符]abstractclass类名{//零到多个成员变量//零到多
        • 【Springboot】——响应与分层解耦架构 Y小夜 架构springboot后端javaspring
          博主现有专栏：C51单片机（STC89C516），c语言，c++，离散数学，算法设计与分析，数据结构，Python，Java基础，MySQL，linux，基于HTML5的网页设计及应用，Rust（官方文档重点总结），jQuery，前端vue.js，Javaweb开发，设计模式、Python机器学习、Springboot等主页链接：Y小夜-CSDN博客目录响应响应数据✨@ResponseBody✨G
        • 2021秋招总结：460道Java后端面试高频题,2022接着用 90后小伙追梦之路 java架构面试java面试开发语言github数据库
          由于个人水平有限，如若文章中有错误之处，敬请指正。本文按照我平时复习的模块进行题目划分，由于题目较多，未贴出答案。如果想要答案版资料可以私信我【答案】来免费获取到Java基础解释下什么是面向对象？面向对象和面向过程的区别？面向对象的三大特性？分别解释下？JDK、JRE、JVM三者之间的关系？重载和重写的区别？Java中是否可以重写一个private或者static方法？构造器是否可以被重写？构造方
        • Java从小白到微服务学习路线 墨说智能制造 Java开发知识体系java学习微服务
          JAVA基础教程基础语法对象和类基本数据类型变量类型修饰符运算符循环结构条件语句switchcaseNumber&Math类Character类String类StringBuffer数组日期时间正则表达式方法StreamFile.IOScanner类异常处理JAVA面向对象面向对象继承Override/Overload多态抽象类封装接口枚举包(package)JAVA高级教程数据结构集合框架Arr
        • 庖丁解java(一篇文章学java) 庖丁解java java开发语言
          (大家不用收藏这篇文章,因为这篇文章会经常更新,也就是删除后重发)一篇文章学java,这是我滴一个执念...当然,真一篇文章就写完java基础,java架构,java业务实现,java业务扩展,根本不可能.所以,这篇文章,就是一个索引,索什么呢?请看下文...关于决定开始写博文的介绍(一切故事的起点源于这一次反省)中小技术公司的软扩展(微服务扩展是否有必要?)-CSDN博客SpringCloud(
        • 后端程序员基础篇（一） JAVA基础 菜鸡来咯 java
          在以往的博客中，大部分讲解的是框架的基础框架和功能模块，对于想要从事Web开发的同学来说，框架和各个功能模块固然非常重要，但这些都是建立在你有深厚的基础之上的，一开始学习的重点应该放在基础上面，在有了深厚的地基之后，学习框架和各个功能模块再之后的微服务等各个架构才能举一反三，学习得更加透彻接下来以我的逻辑来简要说明一下Web应用的开发人员的学习之路，算是帮助目前还比较迷茫的同学。Java基础，Sq
        • JAVA基础语句整理 chengxuyuan66666 javapython开发语言
          Java是一种广泛使用的面向对象编程语言，它具有简洁、强大、跨平台等特性。以下是Java中的一些基础语句和概念，适合初学者了解：1.类与对象Java是基于类的，程序的基本单位是类（class）。对象是类的实例。java复制代码//定义一个类publicclassPerson{//属性（成员变量）Stringname;intage;//方法（成员函数）voidintroduce(){System.o
        • Java基础——String 白暮晚 Java八股java
          Java基础——StringString是Java基础类型中较为特殊的一个类，我们这里着重探讨一下这个类。StringString底层使用一个char类型的数组来存储字符串，且该数组使用了private和final修饰为什么说String是不可变的final与private修饰该字符数组且未暴露修改方法，杜绝了从外部修改该对象的可能性由于final的使用导致子类无法继承该对象，进而导致子类不可能修
        • Hadoop 和 Spark 的内存管理机制分析 王子良. 经验分享hadoopspark大数据
          欢迎来到我的博客！非常高兴能在这里与您相遇。在这里，您不仅能获得有趣的技术分享，还能感受到轻松愉快的氛围。无论您是编程新手，还是资深开发者，都能在这里找到属于您的知识宝藏，学习和成长。博客内容包括：Java核心技术与微服务：涵盖Java基础、JVM、并发编程、Redis、Kafka、Spring等，帮助您全面掌握企业级开发技术。大数据技术：涵盖Hadoop（HDFS）、Hive、Spark、Fli
        • MyBatis学习笔记 繁星依月 开发技术学习笔记mybatis学习笔记
          MyBatis学习笔记MyBatis绪论功能：访问数据库相当于增强版JDBC官网：mybatis–MyBatis3|简介MyBatis环境JDK1.8MySQL5.7/8.0（经典！）maven3.6+IDEAMyBatis前序JDBC、MySQL、Java基础、Maven、JunitMyBatis简介什么是MyBatisMyBatis是一款优秀的持久层框架，它支持自定义SQL、存储过程以及高级映
        • springboot项目架构 m0_74823471 springboot架构后端
          前言SpringBoot是一个开源的Java基础框架，用于创建独立、生产级别的基于Spring框架的应用程序。它简化了基于Spring的应用开发，你只需要“启动”即可。一、springboot概述在SpringBoot出现之前，使用Spring框架开发应用程序时，开发人员需要花费大量时间进行复杂的配置，包括配置各种XML文件或者Java配置类来整合Spring的各个模块，如SpringMVC、Sp
        • 使用 Hadoop 实现大数据的高效存储与查询 王子良. 经验分享大数据hadoop分布式
          欢迎来到我的博客！非常高兴能在这里与您相遇。在这里，您不仅能获得有趣的技术分享，还能感受到轻松愉快的氛围。无论您是编程新手，还是资深开发者，都能在这里找到属于您的知识宝藏，学习和成长。博客内容包括：Java核心技术与微服务：涵盖Java基础、JVM、并发编程、Redis、Kafka、Spring等，帮助您全面掌握企业级开发技术。大数据技术：涵盖Hadoop（HDFS）、Hive、Spark、Fli
        • 入门知识（JAVA基础） 一只藏羚吖 JAVA基础java开发语言
          目录一、二进制二、变量的本质三、八种数据类型四、运算符1、算术运算符2、关系运算符3、逻辑运算符4、位运算符5、移位运算符6、条件运算符（三目操作符）五、类型转换一、二进制二进制（binary）是在数学和数字电路中以2为基数的记数系统，它使用两个不同的符号0（代表零）和1（代表一）来表示数值。二进制由德国数学家莱布尼茨在17世纪至18世纪提出，是现代计算机科学和数字电路的基础。二进制的特点主要有：
        • JAVA基础二进制 肉肉的小白 java
          二进制计算机中的数据都以二进制数字保存。二进制：逢二进一。即只有0、1两个值。如：十进制的10在计算机内保存为二进制的1010计算机中信息的存储单位位（Bit）：表示一个二进制数码0或1，是计算机存储处理信息的最基本的单位。字节（Byte）：一个字节由8个位组成。它表示作为一个完整处理单位的8个二进制数码。补码：事实上，计算机内的二进制数值是以补码形式表示的。补码：一个正数的补码和其原码的形式是相
        • Python 爬虫：获取网页数据的 5 种方法 王子良. 经验分享pythonpython开发语言爬虫
          欢迎来到我的博客！非常高兴能在这里与您相遇。在这里，您不仅能获得有趣的技术分享，还能感受到轻松愉快的氛围。无论您是编程新手，还是资深开发者，都能在这里找到属于您的知识宝藏，学习和成长。博客内容包括：Java核心技术与微服务：涵盖Java基础、JVM、并发编程、Redis、Kafka、Spring等，帮助您全面掌握企业级开发技术。大数据技术：涵盖Hadoop（HDFS）、Hive、Spark、Fli
        • 【Rust】——不安全Rust Y小夜 Rust（官方文档重点总结）rust开发语言后端
          博主现有专栏：C51单片机（STC89C516），c语言，c++，离散数学，算法设计与分析，数据结构，Python，Java基础，MySQL，linux，基于HTML5的网页设计及应用，Rust（官方文档重点总结），jQuery，前端vue.js，Javaweb开发，Python机器学习等主页链接：Y小夜-CSDN博客目录不安全的超能力解引用裸指针调用不安全函数或方法创建不安全代码的安全抽象使用e
        • Java基础二维数组 五度鱼Java javaseArray二维数组
          关于java中的二维数组1、二维数组其实是一个特殊的一维数组，特殊在这个一维数组当中的每个元素是一个一维数组2、三维数组是什么？三维数组是一个特殊的二维数组，特殊在这个二维数组中每个元素是一个一维数组。实际开发中使用最多的就是一维数组。二维数组也很少使用。三维数组几乎不用。3、二维数组的静态初始化int[][]array={{1,2,5,8,7},{1,2,3,4,5},{4,7,8,9},{,4
        • Java学生信息管理系统 析杴 java开发语言
          Java学生信息管理系统文章目录Java学生信息管理系统前言一、创建学生信息类二、实现系统功能1.添加学生信息2.删除学生信息3.修改学生信息4.查看学生信息总结前言简单实现Java学生信息管理系统，无数据库部分，仅用Java基础指数实现简单的Java学生信息管理系统。学生信息可自由添加，功能仅限于简单的增删改查。一、创建学生信息类为简单操作，将学生信息设定为四项，学号，姓名，学院，专业，学号类似
        • Java中private和static同时使用会出现什么情况？ 乐悠小码 java开发语言jvm
          引言这几天在学习单例设计模式（后面会出一期包含23种设计模式介绍的博客）的时候发现了一段代码privatestaticSinglesingle;当时我就在想，这个private和static一起用的话外界想要访问这个成员变量到底是能不能访问到呢？当时在学习Java基础的时候也没有仔细研究过这里，下面就详细的来解释一下，把这块空缺的知识点补上！private的作用private作为权限修饰符，用来声
        • Java应届生面试/笔试突击 莱宝 JavaJava面试笔试
          Java应届生面试突击_章节目录  Java基础    ♦JVM相关    ♦Java中的集合类    ♦设计模式相关    ♦Java语言相关    ♦Java基础专题  多线程和并发    ♦多线程和并发专题    ♦并发包的问题    ♦阻塞队列相关的问题    ♦多线程相关的问题    ♦其他问题  数据库    ♦数据库专题    ♦sql注入的问题    ♦连接问题    ♦存储过程相
        • Java基础-常用API-Object类 后端java
          继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。Java是单继承语言，所有的类都有一个共同的父类，就是Object类。如果一个类没有用extends明确指出继承于某个类，其实它默认就继承Object类。Object类常见方法：Object()Object类的构造方法，这个没什么可说的。(非重点)registerNatives()
        • Spring Boot 和微服务：快速入门指南 王子良. Java经验分享springboot微服务后端
          欢迎来到我的博客！非常高兴能在这里与您相遇。在这里，您不仅能获得有趣的技术分享，还能感受到轻松愉快的氛围。无论您是编程新手，还是资深开发者，都能在这里找到属于您的知识宝藏，学习和成长。博客内容包括：Java核心技术与微服务：涵盖Java基础、JVM、并发编程、Redis、Kafka、Spring等，帮助您全面掌握企业级开发技术。大数据技术：涵盖Hadoop（HDFS）、Hive、Spark、Fli
        • Java基础面试：可变长参数 程序员java面试
          Java中的可变长参数什么是可变参可变参数是在Java5.0中引入的一个特性，是一种语法糖，它允许方法可以接受不定数量的参数，而无需显式地处理数组。在编译时，方法声明中的可变参数会被转换为数组参数，方法调用中的参数会被打包成一个数组。可变参的语法可变参数的语法非常简单，只需要在参数类型后面加上三个点...即可。例如：publicvoidprintNumbers(int...numbers){for
        • Java面试题汇总-集合篇+JUC篇 泰山小张只吃荷园 java哈希算法开发语言后端面试springboot
          其他面试题Java面试题汇总-Java基础篇（共50道题）-CSDN博客Java集合目录1.请你说说java中hashmap的原理2.HashMap的put(key,value)和get(key)过程3.在使用hashmap时，有哪些提升性能的技巧？4.什么是哈希碰撞？怎么解决哈希碰撞？5.谈一谈hashmap的扩容操作？6.hashmap的初始容量和负载因子越大越好吗？7.为什么jdk1.8之后
        • Java基础：Iterator迭代器 重生之Java开发工程师 java开发语言
          一、什么是Iterator：迭代器(Iterator)是一个对象，它的工作是遍历并目标序列中的对象，它提供了一种访问一个容器(container)对象中的各个元素的方法，把访问逻辑从不同类型的集合类中抽象出来，又不必暴露该对象内部细节。通过迭代器，开发人员不需要了解容器底层的结构，就可以实现对容器的遍历。由于创建迭代器的代价小，因此迭代器通常被称为轻量级的容器。常常使用JDK提供的迭代接口进行Ja
        • 初学者如何用 Python 写第一个爬虫？ 王子良. python经验分享python开发语言爬虫
          欢迎来到我的博客！非常高兴能在这里与您相遇。在这里，您不仅能获得有趣的技术分享，还能感受到轻松愉快的氛围。无论您是编程新手，还是资深开发者，都能在这里找到属于您的知识宝藏，学习和成长。博客内容包括：Java核心技术与微服务：涵盖Java基础、JVM、并发编程、Redis、Kafka、Spring等，帮助您全面掌握企业级开发技术。大数据技术：涵盖Hadoop（HDFS）、Hive、Spark、Fli
        • 大数据学习记录，Java基础（3） 灵敏的迅捷蟹 大数据学习java
          面向对象面向对象的特征：封装随着系统越来越复杂，类会越来越多，那么类之间的访问边界必须把握好，面向对象的开发原则要遵循“高内聚、低耦合”，而“高内聚，低耦合”的体现之一：高内聚：类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用，尽量方便外部调用封装可以认为是一个保护屏障，防止该类的代码和数据被其他类随意访问，加强了代码的安全性。隐藏对象内部的复杂性，只对外公开简单和
        • 面向对象面向过程 3213213333332132 java
          面向对象：把要完成的一件事，通过对象间的协作实现。 面向过程：把要完成的一件事，通过循序依次调用各个模块实现。 我把大象装进冰箱这件事为例，用面向对象和面向过程实现，都是用java代码完成。 1、面向对象 package bigDemo.ObjectOriented; /** * 大象类 * * @Description * @author FuJian
        • Java Hotspot: Remove the Permanent Generation bookjovi HotSpot
            openjdk上关于hotspot将移除永久带的描述非常详细，http://openjdk.java.net/jeps/122   JEP 122: Remove the Permanent Generation Author Jon Masamitsu Organization Oracle Created 2010/8/15 Updated 2011/
        • 正则表达式向前查找向后查找,环绕或零宽断言 dcj3sjt126com 正则表达式
          向前查找和向后查找 1. 向前查找：根据要匹配的字符序列后面存在一个特定的字符序列(肯定式向前查找)或不存在一个特定的序列(否定式向前查找)来决定是否匹配。.NET将向前查找称之为零宽度向前查找断言。     对于向前查找，出现在指定项之后的字符序列不会被正则表达式引擎返回。 2. 向后查找：一个要匹配的字符序列前面有或者没有指定的
        • BaseDao 171815164 seda
          import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.sql.PreparedStatement; import java.sql.ResultSet; public class BaseDao { public Conn
        • Ant标签详解--Java命令 g21121 Java命令
                  这一篇主要介绍与java相关标签的使用         终于开始重头戏了，Java部分是我们关注的重点也是项目中用处最多的部分。           1
        • [简单]代码片段_电梯数字排列 53873039oycg 代码
                 今天看电梯数字排列是9 18 26这样呈倒N排列的,写了个类似的打印例子，如下:       import java.util.Arrays; public class 电梯数字排列_S3_Test { public static void main(S
        • Hessian原理 云端月影 hessian原理
          Hessian 原理分析 一．      远程通讯协议的基本原理 网络通信需要做的就是将流从一台计算机传输到另外一台计算机，基于传输协议和网络 IO 来实现，其中传输协议比较出名的有 http 、 tcp 、 udp 等等， http 、 tcp 、 udp 都是在基于 Socket 概念上为某类应用场景而扩展出的传输协
        • 区分Activity的四种加载模式----以及Intent的setFlags aijuans android
            在多Activity开发中，有可能是自己应用之间的Activity跳转，或者夹带其他应用的可复用Activity。可能会希望跳转到原来某个Activity实例，而不是产生大量重复的Activity。 这需要为Activity配置特定的加载模式，而不是使用默认的加载模式。 加载模式分类及在哪里配置 Activity有四种加载模式： standard singleTop
        • hibernate几个核心API及其查询分析 antonyup_2006 html.netHibernatexml配置管理
          (一)  org.hibernate.cfg.Configuration类         读取配置文件并创建唯一的SessionFactory对象.(一般,程序初始化hibernate时创建.)         Configuration co
        • PL/SQL的流程控制 百合不是茶 oraclePL/SQL编程循环控制
          PL/SQL也是一门高级语言,所以流程控制是必须要有的,oracle数据库的pl/sql比sqlserver数据库要难,很多pl/sql中有的sqlserver里面没有   流程控制; 分支语句 if 条件 then 结果 else 结果 end if ; 条件语句 case when 条件 then 结果; 循环语句 loop
        • 强大的Mockito测试框架 bijian1013 mockito单元测试
          一.自动生成Mock类        在需要Mock的属性上标记@Mock注解，然后@RunWith中配置Mockito的TestRunner或者在setUp()方法中显示调用MockitoAnnotations.initMocks(this);生成Mock类即可。二.自动注入Mock类到被测试类  &nbs
        • 精通Oracle10编程SQL(11)开发子程序 bijian1013 oracle数据库plsql
          /* *开发子程序 */ --子程序目是指被命名的PL/SQL块，这种块可以带有参数，可以在不同应用程序中多次调用 --PL/SQL有两种类型的子程序：过程和函数 --开发过程 --建立过程：不带任何参数 CREATE OR REPLACE PROCEDURE out_time IS BEGIN DBMS_OUTPUT.put_line(systimestamp); E
        • 【EhCache一】EhCache版Hello World bit1129 Hello world
          本篇是EhCache系列的第一篇，总体介绍使用EhCache缓存进行CRUD的API的基本使用，更细节的内容包括EhCache源代码和设计、实现原理在接下来的文章中进行介绍   环境准备 1.新建Maven项目   2.添加EhCache的Maven依赖 <dependency> <groupId>ne
        • 学习EJB3基础知识笔记 白糖_ beanHibernatejbosswebserviceejb
          最近项目进入系统测试阶段，全赖袁大虾领导有力，保持一周零bug记录，这也让自己腾出不少时间补充知识。花了两天时间把“传智播客EJB3.0”看完了，EJB基本的知识也有些了解，在这记录下EJB的部分知识，以供自己以后复习使用。   EJB是sun的服务器端组件模型，最大的用处是部署分布式应用程序。EJB (Enterprise JavaBean)是J2EE的一部分，定义了一个用于开发基
        • angular.bootstrap boyitech AngularJSAngularJS APIangular中文api
          angular.bootstrap 描述：     手动初始化angular。     这个函数会自动检测创建的module有没有被加载多次，如果有则会在浏览器的控制台打出警告日志，并且不会再次加载。这样可以避免在程序运行过程中许多奇怪的问题发生。   使用方法：     angular .
        • java-谷歌面试题-给定一个固定长度的数组，将递增整数序列写入这个数组。当写到数组尾部时，返回数组开始重新写，并覆盖先前写过的数 bylijinnan java
          public class SearchInShiftedArray { /** * 题目：给定一个固定长度的数组，将递增整数序列写入这个数组。当写到数组尾部时，返回数组开始重新写，并覆盖先前写过的数。 * 请在这个特殊数组中找出给定的整数。 * 解答： * 其实就是“旋转数组”。旋转数组的最小元素见http://bylijinnan.iteye.com/bl
        • 天使还是魔鬼？都是我们制造 ducklsl 生活教育情感
          ----------------------------剧透请原谅，有兴趣的朋友可以自己看看电影，互相讨论哦！！！     从厦门回来的动车上，无意中瞟到了书中推荐的几部关于儿童的电影。当然，这几部电影可能会另大家失望，并不是类似小鬼当家的电影，而是关于“坏小孩”的电影！     自己挑了两部先看了看，但是发现看完之后，心里久久不能平
        • [机器智能与生物]研究生物智能的问题 comsci 生物
                我想,人的神经网络和苍蝇的神经网络,并没有本质的区别...就是大规模拓扑系统和中小规模拓扑分析的区别....       但是,如果去研究活体人类的神经网络和脑系统,可能会受到一些法律和道德方面的限制,而且研究结果也不一定可靠,那么希望从事生物神经网络研究的朋友,不如把
        • 获取Android Device的信息 dai_lm android
          String phoneInfo = "PRODUCT: " + android.os.Build.PRODUCT; phoneInfo += ", CPU_ABI: " + android.os.Build.CPU_ABI; phoneInfo += ", TAGS: " + android.os.Build.TAGS; ph
        • 最佳字符串匹配算法（Damerau-Levenshtein距离算法）的Java实现 datamachine java算法字符串匹配
          原文：http://www.javacodegeeks.com/2013/11/java-implementation-of-optimal-string-alignment.html------------------------------------------------------------------------------------------------------------
        • 小学5年级英语单词背诵第一课 dcj3sjt126com englishword
          long 长的 show 给...看，出示 mouth 口，嘴 write 写   use 用，使用 take 拿，带来 hand 手 clever 聪明的   often 经常 wash 洗 slow 慢的 house 房子   water 水 clean 清洁的 supper 晚餐 out 在外   face 脸，
        • macvim的使用实战 dcj3sjt126com macvim
          macvim用的是mac里面的vim, 只不过是一个GUI的APP, 相当于一个壳   1. 下载macvim https://code.google.com/p/macvim/   2. 了解macvim :h               vim的使用帮助信息 :h macvim  
        • java二分法查找 蕃薯耀 java二分法查找二分法java二分法
          java二分法查找 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年6月23日 11:40:03 星期二 http:/
        • Spring Cache注解+Memcached hanqunfeng springmemcached
          Spring3.1 Cache注解  依赖jar包： <!-- simple-spring-memcached --> <dependency> <groupId>com.google.code.simple-spring-memcached</groupId> <artifactId>simple-s
        • apache commons io包快速入门 jackyrong apache commons
          原文参考 http://www.javacodegeeks.com/2014/10/apache-commons-io-tutorial.html   Apache Commons IO 包绝对是好东西，地址在http://commons.apache.org/proper/commons-io/，下面用例子分别介绍：   1）  工具类   2
        • 如何学习编程 lampcy java编程C++c
          首先,我想说一下学习思想.学编程其实跟网络游戏有着类似的效果.开始的时候,你会对那些代码,函数等产生很大的兴趣,尤其是刚接触编程的人,刚学习第一种语言的人.可是,当你一步步深入的时候,你会发现你没有了以前那种斗志.就好象你在玩韩国泡菜网游似的,玩到一定程度,每天就是练级练级,完全是一个想冲到高级别的意志力在支持着你.而学编程就更难了,学了两个月后,总是觉得你好象全都学会了,却又什么都做不了,又没有
        • 架构师之spring-----spring3.0新特性的bean加载控制@DependsOn和@Lazy nannan408 Spring3
          1.前言。    如题。 2.描述。    @DependsOn用于强制初始化其他Bean。可以修饰Bean类或方法，使用该Annotation时可以指定一个字符串数组作为参数，每个数组元素对应于一个强制初始化的Bean。 @DependsOn({"steelAxe","abc"}) @Comp
        • Spring4+quartz2的配置和代码方式调度 Everyday都不同 代码配置spring4quartz2.x定时任务
          前言：这些天简直被quartz虐哭。。因为quartz 2.x版本相比quartz1.x版本的API改动太多，所以，只好自己去查阅底层API……   quartz定时任务必须搞清楚几个概念： JobDetail——处理类 Trigger——触发器，指定触发时间，必须要有JobDetail属性，即触发对象 Scheduler——调度器，组织处理类和触发器，配置方式一般只需指定触发
        • Hibernate入门 tntxia Hibernate
            前言   使用面向对象的语言和关系型的数据库，开发起来很繁琐，费时。由于现在流行的数据库都不面向对象。Hibernate 是一个Java的ORM（Object/Relational Mapping）解决方案。   Hibernte不仅关心把Java对象对应到数据库的表中，而且提供了请求和检索的方法。简化了手工进行JDBC操作的流程。   如
        • Math类 xiaoxing598 Math
          一、Java中的数字（Math）类是final类，不可继承。 1、常数 PI：double圆周率 E：double自然对数 2、截取（注意方法的返回类型） double ceil(double d) 返回不小于d的最小整数 double floor(double d) 返回不大于d的整最大数 int round(float f) 返回四舍五入后的整数 long round