冰河winner
冰河winner

JAVA进阶之Reference

1、引用级别

在JVM中，垃圾回收器一直在背后默默地承担着内存回收的工作，我们不需要像使用C语音开发那样小心翼翼地管理内存。但是凡事皆有两面性，这种机制的好处是极大地释放了程序员无处安放的焦虑，坏处是难以对回收过程进行更灵活地干预。

为了增加对垃圾回收的力度把控，Java引入了引用级别的概念。

在JDK 1.2以前的版本中，只有在对象没有任何其他对象引用它时，垃圾回收器才会对它进行收集。对象只有被引用和没有被引用两种状态。这种方式无法描述一些“食之无味，弃之可惜”的对象。而很多时候，我们希望存在这样一些对象：当内存空间足够时，不进行回收；当内存空间变得紧张时，允许JVM回收这些对象。大部分缓存都符合这样的场景。

从JDK 1.2版本开始，Java对引用的概念进行了扩充，对象的引用分成了4种级别，从而使程序开发者能更加灵活地控制对象的生命周期，更好的控制创建的对象何时被释放和回收。

这4种级别由高到低依次为：强引用、软引用、弱引用和虚引用。

1.1 强引用(StrongReference)

我们使用的大部分的引用都是强引用，这是使用最普遍的引用。如果一个对象具有强引用，那就类似于必不可少的生活用品，垃圾回收器绝不会回收它。当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足问题。

如果强引用对象不使用时，需要弱化从而使GC能够回收，如：

strongReference = null;

显式地设置strongReference对象为null，或让其超出对象的生命周期范围，则gc认为该对象不存在引用，这时就可以回收这个对象。具体什么时候收集这要取决于GC算法。

public void test() {
    Object strongReference = new Object();
    // 省略其他操作
}

在一个方法的内部有一个强引用，这个引用保存在Java栈中，而真正的引用内容(Object)保存在Java堆中。 当这个方法运行完成后，就会退出方法栈，则引用对象的引用数为0，这个对象会被回收。但是如果这个strongReference是全局变量时，就需要在不用这个对象时赋值为null，因为强引用不会被垃圾回收。

ArrayList的Clear方法：

public void clear() {
    modCount++;

    // clear to let GC do its work
    for (int i = 0; i < size; i++)
        elementData[i] = null;

    size = 0;
}

在ArrayList类中定义了一个elementData数组，在调用clear方法清空数组时，每个数组元素被赋值为null。 但是，这里为什么不直接将数组设置为null：

elementData=null;

一行代码搞定，岂不更加简单粗暴？
如果将整个数组指向null，该数组的内存空间会被回收掉，而将数组的元素逐个指向null只会把数组中存放的强引用释放，整个数组对象还是存在的，这样以来，如果再有add()等操作就不用再次分配内存了。

1.2 软引用（SoftReference）

如果一个对象只具有软引用，那就类似于可有可无的生活用品。如果内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。
软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收，JAVA虚拟机就会把这个软引用加入到与之关联的引用队列中。

    ReferenceQueue referenceQueue = new ReferenceQueue<>();
    String str = new String("abc");
    SoftReference softReference = new SoftReference<>(str, referenceQueue);

    str = null;
    // Notify GC
    System.gc();

    System.out.println(softReference.get()); // abc

    Reference reference = referenceQueue.poll();
    System.out.println(reference); //null

注意： 软引用对象是在jvm内存不够的时候才会被回收，我们调用System.gc()方法只是起通知作用，JVM什么时候扫描回收对象是JVM自己的状态决定的。就算扫描到软引用对象也不一定会回收它，只有内存不够的时候才会回收。
当内存不足时，JVM首先将软引用中的对象引用置为null，然后通知垃圾回收器进行回收。也就是说，垃圾收集线程会在虚拟机抛出OutOfMemoryError之前回收软引用对象，而且虚拟机会尽可能优先回收长时间闲置不用的软引用对象。对那些刚构建的或刚使用过的“较新的”软对象会被虚拟机尽可能保留，这就是引入引用队列ReferenceQueue的原因。

1.3 弱引用（WeakReference）

弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它 所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程， 因此不一定会很快发现那些只具有弱引用的对象。
弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。

    String str = new String("abc");
    WeakReference weakReference = new WeakReference<>(str);
    System.out.println(weakReference.get() == null); //false
        
    str = null;
    System.gc(); //触发垃圾回收
        
    System.out.println(weakReference.get() == null); //true

下面的代码会让一个弱引用再次变为一个强引用：

    String str = new String("abc");
    WeakReference weakReference = new WeakReference<>(str);
    // 弱引用转强引用
    String strongReference = weakReference.get();

1.4 虚引用（PhantomReference）

"虚引用"顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收。

    String str = new String("abc");
    ReferenceQueue queue = new ReferenceQueue();
    // 创建虚引用，要求必须与一个引用队列关联
    PhantomReference pr = new PhantomReference(str, queue);

虚引用主要用来跟踪对象被垃圾回收的活动。虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列（ReferenceQueue）联合使用。当垃 圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是 否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。

2、java.lang.ref包

java.lang.ref包下都是与reference相关的类，包括：

1.png
  • Reference：引用对象的抽象基类，定义了所有引用对象的通用操作
  • ReferenceQueue： 引用队列，垃圾回收器在检测到对象可以回收时，会将该对象的Reference放到队列（如果有）
  • SoftReference：Reference子类，代表软引用
  • WeakReference：Reference子类，代表弱引用
  • PhantomReference：Reference子类，代表虚引用
  • FinalReference：Reference子类，访问权限是package，外部无法访问，由JVM来实例化，JVM会对那些实现了Object中finalize()方法的类实例化一个对应的FinalReference
  • Finalizerd：FinalReference子类，访问权限是package，且为final类，外部无法访问。JVM实际操作的是Finalizer。当一个类满足实例化FinalReference的条件时，JVM会调用Finalizer.register()进行注册

3、Reference

3.1 内部变量

先来看一下Reference类中的变量

    private T referent;  

    volatile ReferenceQueue queue;
    Reference next;

    private static Reference pending = null;
    transient private Reference discovered;

    static private class Lock { }
    private static Lock lock = new Lock(); 
 
 
     
  
  • referent
    •  
 
 
 
表示其引用的对象，即在构造的时候需要被包装在其中的对象。
 
 
     
  
  • queue
    •  
 
 
 
是对象即将被回收时所要通知的队列。当对象即将被回收时，整个reference对象，而不仅仅是被回收的对象，会被放到queue 里面，然后外部程序通过监控这个 queue 即可拿到相应的数据了。ReferenceQueue并不是一个链表数据结构，它只持有这个链表的表头对象header，这个链表是由Refence对象里面的next变量构建起来，next也就是链表当前节点的下一个节点，所以Reference对象本身就是一个链表的节点，这个链表由ReferenceHander线程从pending队列中取出的数据构建而来
 
 
     
  
  • next
    •  
 
 
 
与queue 搭配使用，仅在Reference放到queue中时才有意义，一系列的Reference正是依靠next组成了一个单链表
 
 
     
  
  • pending
    •  
 
 
 
pending与后面的discovered一起构成了一个pending单向链表。注意这个变量是一个静态对象，所以是全局唯一的。pending为链表的头节点，discovered为链表当前Reference节点指向下一个节点的引用，这个队列是由JVM构建的，当对象除了被reference引用之外没有其它强引用了，JVM就会将指向需要回收的对象的Reference都放入到这个队列里面（注意是指向要回收的对象的Reference，要回收的对象就是Reference的成员变量refernt持有的对象，是refernt持有的对象要被回收，而不是Reference对象本身），这个队列会由ReferenceHander线程来处理。
 
 
     
  
  • discovered
    •  
 
 
 
表示ReferenceHander要处理的pending对象的下一个对象。ReferenceHander只需要不停地拿到pending，然后再通过discovered 不断地拿到下一个对象赋值给pending即可，直到取到了最有一个。
 
 
     
  
  • lock
    •  
 
 
 
lock是pending队列的全局锁，只在ReferenceHander线程的run方法里面用到。但是，除了当前线程，JVM垃圾回收器线程也会操作pending队列，所以需要通过这个锁来防止并发问题。
 
 
3.2 ReferenceHander
 
 
ReferenceHanderReference的一个内部类，继承自Thread：
 
 
    private static class ReferenceHandler extends Thread {

        private static void ensureClassInitialized(Class clazz) {
            try {
                Class.forName(clazz.getName(), true, clazz.getClassLoader());
            } catch (ClassNotFoundException e) {
                throw (Error) new NoClassDefFoundError(e.getMessage()).initCause(e);
            }
        }

        static {
           // 确保依赖的其他类已被加载
            ensureClassInitialized(InterruptedException.class);
            ensureClassInitialized(Cleaner.class);
        }

        ReferenceHandler(ThreadGroup g, String name) {
            super(g, name);
        }

        public void run() {
            while (true) {
                //启动后无限循环，调用tryHandlePending方法
                tryHandlePending(true);
            }
        }
    }

    static boolean tryHandlePending(boolean waitForNotify) {
        Reference r;
        Cleaner c;
        try {
            //此处需要加全局锁，因为除了当前线程，gc线程也会操作pending队列
            synchronized (lock) {
                //如果pending队列不为空，则将第一个Reference对象取出
                if (pending != null) {
                    r = pending;
                    c = r instanceof Cleaner ? (Cleaner) r : null;
                    //将头节点指向discovered，即队列中的下一个节点，这样就把第一个头结点出队了
                    pending = r.discovered;
                     //将当前节点的discovered设置为null；当前节点已出队，不再需要链表序列
                    r.discovered = null;
                } else {
                    //如果pending队列为空且需要等待，则进入阻塞状态
                    if (waitForNotify) {
                        lock.wait();
                    }
                   
                    return waitForNotify;
                }
            }
        } catch (OutOfMemoryError x) {
            Thread.yield();
            return true;
        } catch (InterruptedException x) {
            return true;
        }

        // 如果从pending队列出队的是一个Cleaner对象，那么直接执行其clean()方法
        if (c != null) {
            c.clean();
            //注意这里，这里已经不往下执行了，所以Cleaner对象是不会进入到队列里面的，给它设置ReferenceQueue的作用是为了让它能进入Pending队列后被ReferenceHander线程处理
            return true;
        }

        //如果绑定了ReferenceQueue队列，则将对象插入其中
        ReferenceQueue q = r.queue;
        if (q != ReferenceQueue.NULL) q.enqueue(r);
        return true;
    }
 
 
可见，ReferenceHander的任务就是将pending队列中要被回收的Reference对象移除出来，如果Reference对象在初始化的时候传入了ReferenceQueue队列，那么就把从pending队列里面移除的Reference放到它自己的ReferenceQueue队列里，如果没有ReferenceQueue队列，那么其关联的对象就不会进入到Pending队列中，会直接被回收掉。
 
 
如果把pending与discovered看做指针，ReferenceHander操作pending队列的流程可以简化为下图：
 
 
 
  
 
   
  
   
 
  
 
  

    2.jpg 
  
 
 
 
 
那么问题来了：
 
 
1、Reference 源码中并没有发现给 discovered和 pending 赋值的地方，是谁负责它们的初始化呢？
 
 
2、ReferenceHandler是什么时候由谁启动的？
 
 
问题1，pending队列由JVM的垃圾回收器维护，负责初始化discovered和 pending，并不断将新的Reference追加到队列当中。
 
 
问题2，去源码中寻找答案，Reference类中有一段静态代码：
 
 
    static {
        ThreadGroup tg = Thread.currentThread().getThreadGroup();
        for (ThreadGroup tgn = tg;
             tgn != null;
             tg = tgn, tgn = tg.getParent());
        Thread handler = new ReferenceHandler(tg, "Reference Handler");
        //拥有最高优先级
        handler.setPriority(Thread.MAX_PRIORITY); 
        //设为守护线程
        handler.setDaemon(true);
        //启动线程
        handler.start();

        // provide access in SharedSecrets
        SharedSecrets.setJavaLangRefAccess(new JavaLangRefAccess() {
            @Override
            public boolean tryHandlePendingReference() {
                return tryHandlePending(false);
            }
        });
    }

 
 
ReferenceHandler是一个拥有最高优先级的守护线程，在Reference类加载执行cinit的时候被初始化并启动。
 
 
3.3 Reference状态及其转换
 
 
Reference源码开头有一段很长的注释，说明了Reference对象的四种状态：
 
 
     
  
  • Active
    •  
 
 
 
活动状态,对象存在强引用状态,还没有被回收
 
 
     
  
  • Pending
    •  
 
 
 
垃圾回收器将没有强引用的Reference对象放入到pending队列中，等待ReferenceHander线程处理（前提是这个Reference对象创建的时候传入了ReferenceQueue，否则的话对象会直接进入Inactive状态）
 
 
     
  
  • Enqueued
    •  
 
 
 
:ReferenceHander线程将pending队列中的对象取出来放到ReferenceQueue队列里
 
 
     
  
  • Inactive
    •  
 
 
 
处于此状态的Reference对象可以被回收,并且其内部封装的对象也可以被回收掉了，有两个路径可以进入此状态：
 
 
路径一：在创建时没有传入ReferenceQueue的Reference对象，被Reference封装的对象在没有强引用时，指向它的Reference对象会直接进入此状态；
 
 
路径二：此Reference对象经过前面三个状态后，已经由外部从ReferenceQueue中获取到,并且已经处理掉了。
 
 
状态的转换示意图如下：
 
 
 
  
 
   
  
   
 
  
 
  

    3.jpg 
  
 
 
 
 
从代码层面来说，Reference对象的状态只需要通过成员变量next和queue来判断：
 
 
     
  
  •  Active：next=null
    •  
  
  •  Pending：next = this, queue = ReferenceQueue
    •  
  
  •  Enqueued：queue =ReferenceQueue.ENQUEUED
    •  
  
  •  Inactive：next = this, queue = ReferenceQueue.NULL;
    •  
 
 
 
可以结合后面的ReferenceQueue源码加深理解。
 
 
4、 ReferenceQueue
 
 
4.1 内部变量
 
 
    private static class Null extends ReferenceQueue {
        boolean enqueue(Reference r) {
            return false;
        }
    }   
    static ReferenceQueue NULL = new Null<>();
    static ReferenceQueue ENQUEUED = new Null<>();

    static private class Lock { };
    private Lock lock = new Lock();

    //队列头
    private volatile Reference head = null;
    //队列长度
    private long queueLength = 0;
 
 
ReferenceQueue定义了一个内部类Null，重写了enqueue入队方法，永远返回false，所以它不会存储任何数据，是一个用来做状态识别的空队列。
 成员变量NULL和ENQUEUED是内部类的两个实例，用以标识Reference的状态。当Reference对象创建时没有指定queue或Reference对象已经处于inactive状态时，其持有的queue会指向NULL；当Reference被ReferenceHander线程从pending队列移到queue里面时，其持有的queue会指向ENQUEUED。
 
 
与Reference类似，ReferenceQueue内部也定义了一个Lock类，内部没有任何代码填充，就是一个标志类，用来充当锁的载体。但是，Reference中的Reference中的lock变量是静态的，也就是被所有实例共享的；而ReferenceQueue中的lock变量是非静态的，也就是每个ReferenceQueue实例独占一份，这是为什么呢？
 原因在于，Reference中的lock用于锁定pending队列，pending队列本身就是静态变量，全局唯一，lock变量当然也得是静态的；而ReferenceQueue是与某个具体的Reference绑定，入队、出队等操作对于每个ReferenceQueue实例来说都是相互独立的，只需要锁定实例相关的队列即可，所以lock是实例变量，而非静态变量
 
 
head变量持有队列的队头，head与Reference中的next变量构成了一个单链表。Reference对象是从队头做出队入队操作，所以它是一个后进先出的队列，其实在数据结构上更像更像一个栈。
 
 
4.2 入队操作
 
 
    boolean enqueue(Reference r) { 
        //首先要锁定队列
        synchronized (lock) { 
            ReferenceQueue queue = r.queue;
            //如果Reference没有绑定队列，或者已经入队，直接返回
            if ((queue == NULL) || (queue == ENQUEUED)) {
                return false;
            }
            assert queue == this;
            //将Reference设为已入队状态
            r.queue = ENQUEUED;
            //如果队列为空，Reference的next指向自己（自己将会成为队头）；否则，指向队头
            r.next = (head == null) ? r : head;
            //将自己设为队头
            head = r;
            //增加队列长度
            queueLength++;
            if (r instanceof FinalReference) {
                sun.misc.VM.addFinalRefCount(1);
            }
            //唤醒出队操作的等待线程
            lock.notifyAll();
            return true;
        }
    }

 
 
入队的操作很简单，就是不断地将新对象插入到队头，流程示意图如下：
 
 
 
  
 
   
  
   
 
  
 
  

    4.jpg 
  
 
 
 
 
4.3 出队操作
 
 
有两种出队操作：
 
 
     
  
  •  poll：非阻塞式，队列中没有对象直接返回
    •  
  
  •  remove：阻塞式，队列中没有对象时阻塞线程，直到有新对象进来，可以设置最长的阻塞时间
    •  
 
 
 
    //真正执行出队操作的方法，poll与remove都会调用
    private Reference reallyPoll() { 
        //获取队头
        Reference r = head;
        if (r != null) {
            //将队头重置为下一个对象
            head = (r.next == r) ?
                null :
                r.next; 
            //出队的reference设为已出队状态
            r.queue = NULL;
            //next指向自己
            r.next = r;
            //减少队列长度
            queueLength--;
            if (r instanceof FinalReference) {
                sun.misc.VM.addFinalRefCount(-1);
            }
            return r;
        }
        //队列为空，则直接返回
        return null;
    }

    //非阻塞式出队
    public Reference poll() {
        if (head == null)
            return null;
        synchronized (lock) {
            return reallyPoll();
        }
    }

    //阻塞式出队
    public Reference remove(long timeout)
        throws IllegalArgumentException, InterruptedException
    {
        if (timeout < 0) {
            throw new IllegalArgumentException("Negative timeout value");
        }
        synchronized (lock) {
            Reference r = reallyPoll();
            //出队成功，返回结果
            if (r != null) return r;
            long start = (timeout == 0) ? 0 : System.nanoTime();
            for (;;) {
                //出队失败，阻塞线程一定时间
                lock.wait(timeout);
                //期间如果被唤醒，会重试出队操作
                r = reallyPoll();
                //出队成功，返回结果
                if (r != null) return r;
                //重试仍然失败，如果未超时，继续循环
                if (timeout != 0) {
                    long end = System.nanoTime();
                    timeout -= (end - start) / 1000_000;
                    if (timeout <= 0) return null;
                    start = end;
                }
            }
        }
    }

 
 
出队的流程示意图如下：
 
 
 
  
 
   
  
   
 
  
 
  

    6.jpg 
  
 
 
 
 
5、 SoftReference、WeakReference和PhantomReference
 
 
SoftReference、WeakReference和PhantomReference是reference的三个子类，主要功能都已在父类定义，无需赘言。
 值得额外提一句的是SoftReference，相较于其他子类，其特殊的地方在于多了两个内部变量：clock和timestamp。
 
 
    //由垃圾回收器维护的一个时钟
    static private long clock;

    //每次调用get方法时，会将使用lock更新这个时间戳
    private long timestamp;

    public T get() {
        T o = super.get();
        if (o != null && this.timestamp != clock)
            this.timestamp = clock;
        return o;
    }

 
 
clock是一个静态变量，由垃圾回收器负责维护。
 
 
timestamp是非静态变量，初始值等于clock，并且在每次get的时候更新，JVM会参考timestamp来决定是否回收该引用。
 
 
6、 FinalReference和Finalizer
 
 
6.1 Finalizer机制
 
 
Java有垃圾回收器负责回收无用的内存空间，但JVM只能管理自己的内存空间，对于应用运行时需要的其它native资源(jvm通过jni暴漏出来的功能)：例如直接内存DirectByteBuffer，网络连接SocksSocketImpl，文件流FileInputStream等与操作系统有交互的资源，JVM就无能为力了，需要我们自己来调用释放资源的方法。
 
 
但是人在计算机世界中是个最不靠谱的因素，一旦程序员没有手动释放这些资源，岂不会导致资源泄露？为了帮助愚蠢的人类，Java提供了finalizer机制：如果对象实现了Object.finalize()方法，JVM会在回收对象之前调用该方法，释放掉外部资源。
 例如，FileInputStream的finalize()：
 
 
    protected void finalize() throws IOException {
        if ((fd != null) &&  (fd != FileDescriptor.in)) {
            /* if fd is shared, the references in FileDescriptor
             * will ensure that finalizer is only called when
             * safe to do so. All references using the fd have
             * become unreachable. We can call close()
             */
            close();
        }
    }

 
 
SocksSocketImpl则在父类AbstractPlainSocketImpl中实现了finalize()方法：
 
 
    protected void finalize() throws IOException {
        close();
    }

 
 
6.2 unfinalized队列
 
 
Finalizer机制与FinalReference类、Finalizer类密切相关。
 
 
class FinalReference extends Reference {
    public FinalReference(T referent, ReferenceQueue q) {
        super(referent, q);
    }
}

 
 
final class Finalizer extends FinalReference { 

    private Finalizer(Object finalizee) {
        super(finalizee, queue);
        add();
    }
    //...
}
 
 
Finalizer继承FinalReference类，FinalReference继承Reference类。
 
 
FinalReference和Finalizer的访问权限是package的，意味着我们不能直接去对其进行扩展。此外，Finalizer类还是final的，构造函数是private的，JDK把它包装的如此严密，看来不想让我们过多染指，尔等未开化的草民看看就行了。
 
 
先来看下Finalizer类的内部变量：
 
 
    private static ReferenceQueue queue = new ReferenceQueue<>();
    private static Finalizer unfinalized = null;
    private static final Object lock = new Object();

    private Finalizer
        next = null,
        prev = null;
 
 
首先定义了一个ReferenceQueue，会通过Finalizer的构造函数传给父类，实际上最终充当了Reference中的queue变量。值得注意的是，这个queue是是静态的，也就是说所有Finalizer共享同一个queue。
 此外，还定义了一个惯用的Lock，一个名为unfinalized的变量，两者也都是静态的。
 再往下看，又出现了两个私有变量，一个名为next，一个名为prev，顾名思义，隐约嗅到了一丝双端链表的味道。
 
 
    //添加节点到双端链表
    private void add() {
        //第一步肯定要锁住链表
        synchronized (lock) {
            //链表不为空，将表头置为自己的后继节点
            if (unfinalized != null) {
                this.next = unfinalized;
                unfinalized.prev = this;
            }
            //表头指向自己
            unfinalized = this;
        }
    }
    //从双端链表中删除节点
    private void remove() {
        //拿锁
        synchronized (lock) {
            //如果表头是自己，需要先将表头指向自己的后继节点或前驱节点
            if (unfinalized == this) {
                if (this.next != null) {
                    unfinalized = this.next;
                } else {
                    unfinalized = this.prev;
                }
            }
            //取消自己与后继节点的关联
            if (this.next != null) {
                this.next.prev = this.prev;
            }
             //取消自己与前驱节点的关联
            if (this.prev != null) {
                this.prev.next = this.next;
            }
            //后继节点与前驱节点都指向自己（代表节点已移除）
            this.next = this;   
            this.prev = this;
        }
    }

 
 
果然如此，Finalizer类实现了双端链表的增加、删除等方法，unfinalized指向表头，lock用于锁定链表，next与prev分别指向节点的后继与前驱。
 
 
添加示意图：
 
 
 
  
 
   
  
   
 
  
 
  

    7.jpg 
  
 
 
 
 
删除示意图：
 
 
 
  
 
   
  
   
 
  
 
  

    8.jpg 
  
 
 
 
 
6.3 f类
 
 
类的修饰有很多，比如final，abstract，public等，如果某个类用final修饰，我们就说这个类是final类，上面列的都是语法层面我们可以显式指定的，在JVM里其实还会给类标记一些其他符号，比如finalizer，表示这个类是一个finalizer类（为了和java.lang.ref.Fianlizer类区分，finalizer类简称为f类），GC在处理这种类的对象时要做一些特殊的处理，如在这个对象被回收之前会调用它的finalize方法。
 
 
JVM在类加载的时候会遍历当前类的所有方法，包括父类的方法，如果有一个方法满足一下条件，该类就会被标记为f类：
 
 
     
  
  • 当前类或其父类含有一个参数为空，返回值为void，名为finalize的方法；
    •  
  
  • 这个finalize方法体不能为空；
    •  
 
 
 
java.lang.Object里就有一个finalize()方法：
 
 
protected void finalize() throws Throwable { }

 
 
但是由于其方法体为空，Object并不是一个f类。
 
 
6.4 f类的注册
 
 
那么jvm又是在何时调用register方法的呢？
 
 
对象的创建其实是被拆分成多个步骤的，比如A a=new A(2)这样一条语句对应的字节码如下：
 
 
0: new           #1                  // class A
3: dup
4: iconst_2
5: invokespecial #11                 // Method "":(I)V

 
 
先执行new分配好对象空间，然后再执行invokespecial调用构造函数。JVM何时调用Finalizer.register方法，取决于参数RegisterFinalizersAtInit。改参数默认值为true，代表在构造函数返回之前调用Finalizer.register方法，如果通过-XX:-RegisterFinalizersAtInit关闭了该参数，那将在对象空间分配好之后将这个对象注册进去。
 当我们通过clone的方式复制一个对象时，如果当前类是一个f类，那么在clone完成时将调用Finalizer.register方法进行注册。
 
 
6.5 FinalizerThread线程
 
 
在Finalizer类的静态块里会创建一个FinalizerThread守护线程，这个线程的优先级并不是最高的，意味着在CPU很紧张的情况下其被调度的优先级可能会受到影响。
 
 
static {
    ThreadGroup tg = Thread.currentThread().getThreadGroup();
    for (ThreadGroup tgn = tg;
         tgn != null;
         tg = tgn, tgn = tg.getParent());
    Thread finalizer = new FinalizerThread(tg);
    //现成优先级设为8，高于普通现成的优先级5
    finalizer.setPriority(Thread.MAX_PRIORITY - 2);
    //设为守护线程
    finalizer.setDaemon(true);
    finalizer.start();
}

private static class FinalizerThread extends Thread {
    private volatile boolean running;
    FinalizerThread(ThreadGroup g) {
        super(g, "Finalizer");
    }
    public void run() {
        //如果run方法已经在执行了，直接退出
        if (running)
            return;

        //等待jvm初始化完成后才继续执行
        while (!VM.isBooted()) {
            // delay until VM completes initialization
            try {
                VM.awaitBooted();
            } catch (InterruptedException x) {
                // ignore and continue
            }
        }
        final JavaLangAccess jla = SharedSecrets.getJavaLangAccess();
        running = true;
        for (;;) {
            try {
                //将对象从ReferenceQueue中移除，
                Finalizer f = (Finalizer)queue.remove();
                //通过runFinalizer调用finalizer方法
                f.runFinalizer(jla);
            } catch (InterruptedException x) {
                // ignore and continue
            }
        }
    }
}

private void runFinalizer(JavaLangAccess jla) {
    synchronized (this) {
        //若next==this，则表明this对象已经从unfinalized对象链中移除，已经执行过一次runFinalizer了
        if (hasBeenFinalized()) return;
        //将该对象从unfinalized队列中移除  
        remove();
    }
    try {
        Object finalizee = this.get();
        if (finalizee != null && !(finalizee instanceof java.lang.Enum)) {
            //通过JDK调用对象的finalize方法
            jla.invokeFinalize(finalizee);
            finalizee = null;
        }
    } catch (Throwable x) { }
    super.clear();
}

private boolean hasBeenFinalized() {
    return (next == this);
}

 
 
这个线程用来从queue里获取Finalizer对象，然后执行该对象的runFinalizer方法，该方法会将Finalizer对象从unfinalized队列里剥离出来，这样意味着下次GC发生时就可以将其关联的f对象回收了，最后调用f类的finalized方法。
 
 
至此，Finalizer的整个流程打通了。从头再捋一遍：
 
 
     
  
  1. 当GC发生时，JVM会判断f类是否只被Finalizer类引用；
    2.  
  
  2. 若这个类只被Finalizer对象引用，说明这个对象在不久的将来会被回收，现在可以执行他的finalize方法了；
    3.  
  
  3. 将f类放到Finalizer类的ReferenceQueue中，但这个f类对象其实并没有被回收，因为Finalizer这个类还对他们保持引用；
    4.  
  
  4. GC完成之前，JVM会调用ReferenceQueue中lock对象的notify方法；
    5.  
  
  5. Finalizer的守护线程可能会被唤醒，从Queue中取出对象(remove)，执行该Finalizer对象的runFinalizer方法（将自己从unfinalized队列移除，然后执行引用对象的finalize方法）
    6.  
  
  6. 下次GC时回收这个对象。
    7.  
 
 
 
6.6 Finalizer类的评价
 
 
     
  
  • f类因为Finalizer的引用而变成了一个临时的强引用，即使没有其他的强引用，还是无法立即被回收；
    •  
  
  • f类至少经历两次GC才能被回收，因为只有在FinalizerThread执行完了f对象的finalize方法的情况下才有可能被下次GC回收，而有可能期间已经经历过多次GC了，但是一直还没执行f对象的finalize方法；
    •  
  
  • f对象的finalize方法被调用后，这个对象其实还并没有被回收，虽然可能在不久的将来会被回收。
    •  
  
  • Finalizer线程是一个单线程来处理f-queue，虽然可以再启动第二个（forkSecondaryFinalizer()），但是也是两个线程而已，如果系统中有很多线程争用cpu，在系统压力比较大的情况下，Finalizer线程获取到cpu时间片的时间是不确定的，在其获取到时间片之前，应该被回收的Finalizer对象一直在队列中积累，占用大量内存，经过n次gc后，仍然没有机会被释放掉，这些对象都进入到老年代，导致old剩余空间变小，从而使fullgc会更加频繁，如果Finalizer对象积压严重的甚至会导致oom；
    •  
  
  • 如果Finalizer对象生产的速度比Finalizer线程处理的速度要快，也会导致f-queue队列里面的Finalizer对象积压，这些对象一直占用jvm的内存，直到oom；
    •  
  
  • 如果执行某个f类的finalizer方法执行非常耗时，或这个方法里面的操作被锁阻塞了Finalizer线程，那么就会导致队列里面其它的Finalizer对象一直在等待队列里面无法被回收释放空间，最终导致oom；
    •  
  
  • Reference对象是在gc的时候来处理的，如果没有触发GC就没有机会触发Reference引用的处理操作，那么应该被回收的FinalReference对象就一直在unfinalized队列里，无法被回收，导致被它引用的对象也无法回收，然后又导致被引用对象占用的资源也不会释放，最终可能会导致native资源耗尽；
    •  
  
  • 可能导致资源泄露，例如当jvm退出时，很可能unfinalizer队列里的对象没有被处理完就退出了；
    •  
  
  • 对象有可能在执行过finalize方法后，又被强引用引用到了，于是对象就复活了；
    •  
 
 
 
一句话总结：尽量不要使用Finalizer类，释放资源一定要手动去释放，如果忘记释放，依靠finalizer的机制是不靠谱的，很可能会导致一些严重的内存问题或native资源泄露问题；如果一定要用，必须保证调用finalize方法能够快速执行完成。
 
 
7、 Cleaner
 
 
另外java里面还有一个sun.misc.Cleaner类，它继承自PhantomReference，作用同Finalize一样，它的清理工作是在ReferenceHandel线程里面完成的，只是少了Finalizer线程处理这一步，Finalize存在的问题，它基本都有，如果clean方法使用不当，阻塞ReferenceHander线程，会导致比finalizer线程更加严重的问题。
 
 
public class Cleaner
    extends PhantomReference
{

    // Dummy reference queue, needed because the PhantomReference constructor
    // insists that we pass a queue.  Nothing will ever be placed on this queue
    // since the reference handler invokes cleaners explicitly.
    // 就像英文注释所说的，这货没啥卵用
    private static final ReferenceQueue dummyQueue = new ReferenceQueue<>();

    // Doubly-linked list of live cleaners, which prevents the cleaners
    // themselves from being GC'd before their referents
    // 所有的cleaner都会被加到一个双向链表中去，这样做是为了保证在referent被回收之前
    // 这些Cleaner都是存活的。
    static private Cleaner first = null;

    private Cleaner
        next = null,
        prev = null;

    // 构造的时候把自己加到双向链表中去
    private static synchronized Cleaner add(Cleaner cl) {
        if (first != null) {
            cl.next = first;
            first.prev = cl;
        }
        first = cl;
        return cl;
    }

    // clean方法会调用remove把当前的cleaner从链表中删除。
    private static synchronized boolean remove(Cleaner cl) {
        // If already removed, do nothing
        if (cl.next == cl)
            return false;

        // Update list
        if (first == cl) {
            if (cl.next != null)
                first = cl.next;
            else
                first = cl.prev;
        }
        if (cl.next != null)
            cl.next.prev = cl.prev;
        if (cl.prev != null)
            cl.prev.next = cl.next;

        // Indicate removal by pointing the cleaner to itself
        cl.next = cl;
        cl.prev = cl;
        return true;
    }

    // 用户自定义的一个Runnable对象，
    private final Runnable thunk;

    // 私有有构造函数，保证了用户无法单独地使用new来创建Cleaner。
    private Cleaner(Object referent, Runnable thunk) {
        super(referent, dummyQueue);
        this.thunk = thunk;
    }

    /**
     * 所有的Cleaner都必须通过create方法进行创建。
     */
    public static Cleaner create(Object ob, Runnable thunk) {
        if (thunk == null)
            return null;
        return add(new Cleaner(ob, thunk));
    }

    /**
     * 这个方法会被Reference Handler线程调用，来清理资源。
     */
    public void clean() {
        if (!remove(this))
            return;
        try {
            thunk.run();
        } catch (final Throwable x) {
            AccessController.doPrivileged(new PrivilegedAction() {
                    public Void run() {
                        if (System.err != null)
                            new Error("Cleaner terminated abnormally", x)
                                .printStackTrace();
                        System.exit(1);
                        return null;
                    }});
        }
    }
}
 
 
Cleaner本身不带有清理逻辑，所有的逻辑都封装在thunk参数中，通过构造函数传入，因此thunk是怎么实现的才是最关键的。
 
 
JDK中的DirectByteBuffer就是使用Cleaner清理的，来看一下它得实现：
 
 
   DirectByteBuffer(int cap) {// package-private

        super(-1, 0, cap, cap);
        boolean pa = VM.isDirectMemoryPageAligned();
        int ps = Bits.pageSize();
        long size = Math.max(1L, (long)cap + (pa ? ps : 0));
        Bits.reserveMemory(size, cap);

        long base = 0;
        try {
            //通过unsafe分配内存
            base = unsafe.allocateMemory(size);
        } catch (OutOfMemoryError x) {
            Bits.unreserveMemory(size, cap);
            throw x;
        }
        unsafe.setMemory(base, size, (byte) 0);
        if (pa && (base % ps != 0)) {
            // Round up to page boundary
            address = base + ps - (base & (ps - 1));
        } else {
            address = base;
        }
        //构建Cleaner实例
        cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
        att = null;
    }


    private static class Deallocator
        implements Runnable
    {

        private static Unsafe unsafe = Unsafe.getUnsafe();

        private long address;
        private long size;
        private int capacity;

        private Deallocator(long address, long size, int capacity) {
            assert (address != 0);
            this.address = address;
            this.size = size;
            this.capacity = capacity;
        }

        public void run() {
            if (address == 0) {
                // Paranoia
                return;
            }
            //通过unsafe释放内存
            unsafe.freeMemory(address);
            address = 0;
            Bits.unreserveMemory(size, capacity);
        }

    }

 
 
可见，DirectBuffer的内存释放通过Cleaner调用unsafe类来实现。不过DirectBuffer的释放时机还是不确定的。首先，得发生GC，其次，Reference Handler得调度到，然后处理到你的cleaner才行。
 
 
如果要实现一个cleaner，万万不要在run方法里写一些执行时间很长，或者会阻塞线程的逻辑的，会把Reference Handler拖死。
 
 
由于Finalizer存在上文提到的诸多问题，Java 9中finalize方法已经被废弃，新增java.lang.ref.Cleaner类来提供更灵活、有效的资源释放方式。这个新的 java.lang.ref.Cleaner 其实是以前的 sun.misc.Cleaner 的公有API移植版。Cleaner 是基于 PhantomReference 的，所以不会像finalizer那样有复活对象的机会，所以坑会比finalizer稍微少一点。不过，也就是稍微少一点而已。
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(JAVA进阶之Reference)

        

            

                
    
                    
  • 扫地机类清洁产品之直流无刷电机控制
                        悟空胆好小
清洁服务机器人单片机人工智能
                        
    扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
    
                    
    • 
                    
  • 2018-07-23-催眠日作业-#不一样的31天#-66小鹿
                        小鹿_33

                        
    预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
    
                    
    • 
                    
  • 《大清方方案》| 第二话
                        谁佐清欢

                        
    和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
    
                    
    • 
                    
  • 《庄子.达生9》
                        钱江潮369

                        
    【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
    
                    
    • 
                    
  • 高端密码学院笔记285
                        柚子_b4b4

                        
    高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
    
                    
    • 
                    
  • 2020-04-12每天三百字之连接与替代
                        冷眼看潮

                        
    不知道是不是好为人师，有时候还真想和别人分享一下我对某些现象的看法或者解释。人类社会不断发展进步的过程，就是不断连接与替代的过程。人类发现了火并应用火以后，告别了茹毛饮血的野兽般的原始生活（火烧、烹饪替代了生食）人类用石器代替了完全手工，工具的使用使人类进步一大步。类似这样的替代还有很多，随着科技的发展，有更多的原始的事物被替代，代之以更高效、更先进的技术。在近现代，汽车替代了马车，高速公路和铁路
    
                    
    • 
                    
  • 东南林氏之九牧林候选父系
                        祖缘树TheYtree

                        
    渊源介绍东晋初年晋安林始祖林禄公入闽，传十世隋右丞林茂，由晋安迁居莆田北螺村。又五世而至林万宠，唐开元间任高平太守，生三子：韬、披、昌。韬公之孙攒，唐德宗立双阙以旌表其孝，时号"阙下林家"。昌公字茂吉，乃万宠公第三子，官兵部司马，配宋氏，生一子名萍。萍于唐贞元间明经及第，官沣洲司马(后追赠中宪大夫)。唐太和年间归隐后，迁居仙游游洋，世称“游洋林”；其后裔居游洋后迁移漳州漳浦路下，由路下林第四房平和
    
                    
    • 
                    
  • 大伟说成语之唉声叹气
                        求索大伟

                        
    ＊大伟说成语＊【唉声叹气】叹气：因心里不痛快或不如意而吐出长气，发出声音。因为痛苦、憋闷或感伤而发出叹息的声音。【大伟说】情绪外露，非人类所特有，动物亦有情绪，悲哀和欢乐所表示的情绪亦是不一样的，会嗷嗷大叫也会低吟痛哭。不同的是，人类的情绪更复杂，更多样，更丰富。唉声叹气，可以说是最基础的情绪，因为无奈而举足无措，不知该如何如何化解，只有独自一人慢慢承受，长吁短叹不知如何是好，其实是无能无力的表现
    
                    
    • 
                    
  • libyuv之linux编译
                        jaronho
Linuxlinux运维服务器
                        
    文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
    
                    
    • 
                    
  • 怎么做淘客赚钱(2022最新免费淘客盈利的方法)
                        高省_飞智666600

                        
    很多人都不知道什么是淘宝客，今天小编为大家解答一下吧。淘宝客，现在简称淘客，是时下比较流行的一个词语，特质为淘宝店推广商品获取提成的人，这些人没有自己的产品，只是在淘宝里面选择适合自己的产品，在自己比较熟悉的领域推广，把产品卖出去之后，会从淘宝店家那里获得百分之五到百分之五十左右的佣金。淘宝客付出的是什么呢？时间。你需要花时间去选适合自己推广的产品，需要花时间去选自己的推广方法，如果你打算自己做个
    
                    
    • 
                    
  • Python爬虫解析工具之xpath使用详解
                        eqa11
python爬虫开发语言
                        
    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
    
                    
    • 
                    
  • 锁之缘
                        尘缘诗词原创作品

                        
    是谁追寻梦的足迹，是谁在偷偷的哭泣，日月隔离在黑白天地情感在心中蔓延的痕迹天与地的距离有多远流失的星晨落入哪片空间不要让泪水模糊双眼心牢中一样充满温暖谁说爱情没有永远白娘子又为何爱许仙蝴蝶墓地展翅翩翩轻歌慢舞袖卷人间传奇千古留爱万年…………月落星飞徘徊是选择不去问自已为合舍不得寂寞本就是痛苦的不在追寻梦中的痕迹才不会失去真实的自已
    
                    
    • 
                    
  • ARM驱动学习之基础小知识
                        JT灬新一
ARM嵌入式arm开发学习
                        
    ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
    
                    
    • 
                    
  • ARM驱动学习之5 LEDS驱动
                        JT灬新一
嵌入式C底层arm开发学习单片机
                        
    ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
    
                    
    • 
                    
  • ARM驱动学习之4小结
                        JT灬新一
嵌入式C++arm开发学习linux
                        
    ARM驱动学习之4小结#include#include#include#include#include#defineDEVICE_NAME"hello_ctl123"MODULE_LICENSE("DualBSD/GPL");MODULE_AUTHOR("TOPEET");staticlonghello_ioctl(structfile*file,unsignedintcmd,unsignedlo
    
                    
    • 
                    
  • C++ | Leetcode C++题解之第409题最长回文串
                        Ddddddd_158
经验分享C++Leetcode题解
                        
    题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
    
                    
    • 
                    
  • 2020-12-24
                        我和我的天使们

                        
    阅读《老子的心事》391—403“将欲取之，必固与之”：想要得到什么，首先就要送出什么。我常常对孩子们说，你希望别人怎样对你你就怎样对待别人。想要得到别人的尊重，首先要尊重别人。我希望她们可以不迟到，因为不迟到是对别人的尊重，我就自己就先做到不迟到。哪怕是约朋友逛街，我尽量准时赴约。我严格要求孩子们，也同样严格要求自己，我跟孩子们一起把好的品格变成习惯。“是谓微明”：这就是微妙的智慧。看起来很少很
    
                    
    • 
                    
  • 18、架构-可观测性之聚合度量
                        大树~~
架构javapython后端架构
                        
    聚合度量聚合度量是指对系统运行时产生的各种指标数据进行收集、聚合和分析，以了解系统的健康状况和性能表现。聚合度量是可观测性的关键组成部分，通过对度量数据的分析，可以及时发现系统中的异常和瓶颈。以下是对聚合度量各个方面的详细解析，并结合具体的数据案例和技术支撑。指标收集收集系统运行时产生的各种指标数据是聚合度量的基础。常见的指标包括CPU使用率、内存使用率、请求处理时间、请求数、错误率等。以下是指标
    
                    
    • 
                    
  • 学习“论语”-第59天
                        春峰轩

                        
    12.14子张问政。子曰：“居之无倦，行之以忠。”子张问为政之道。孔子说：“在位尽职不懈怠，执行政令要忠诚。”12.15子曰：“博学于文，约之以礼，亦可以弗畔矣夫！”孔子说：“君子广泛地学习文献，并且用礼节约束自己，也就不会离经叛道了。”12.16子曰：“君子成人之美，不成人之恶。小人反是。”孔子说：“君子成全别人的好事，而不助长别人的坏处。小人则与此相反行事。”知识点:“成人之美，不成人之恶”贯
    
                    
    • 
                    
  • 2021-11-15
                        宙火

                        
    我给宋小姐写了首诗，是我在课上因思恋宋小姐而写的。“自古多情是唐宋，从来双飞归巢燕。邻家小女相聘婷，常使春意荡漾我。不知单思可为爱，惟愿一心付之汝。”我拿给宋小姐看了，她说我写得很棒。我很开心，但又不是那么开心。宋小姐是回复我了，但也只是说我写得很棒，对我诗句中蕴藏的真切感情，不知道是真的没发现，还是装作没发现。但我不深究，只是这样，我就很开心了。我答应宋小姐，一天给她写一首诗。
    
                    
    • 
                    
  • 《我的青葱岁月之缘来是你》 第二章 迎新晚会
                        思源思缘思怨

                        
    “怎么你也来了这里？”我愉快的问到，想着这是上天给的缘分吗？我还没去找他竟然就相遇了。那个让我开心的老乡。“你好，我也是舞蹈社的新人啊！”他说，笑起来回答我，眼睛弯弯的。“这么巧，我叫吴倩，你叫啥？”“我叫韩欢，你也是B市人吧，c中毕业的？”“我不是，我是f中的，不然肯定会认识你的”“是吗？以后多多关照了”他还冲我眨了眨眼睛。内心一阵悸动，这是……回到寝室，我兴奋的告诉我的室友这个事情，我再次觉得
    
                    
    • 
                    
  • 数据结构之哈希表
                        X同学的开始
数据结构数据结构散列表
                        
    哈希表(散列表)出现的原因在顺序表中查找时，需要从表头开始，依次遍历比较a[i]与key的值是否相等，直到相等才返回索引i；在有序表中查找时，我们经常使用的是二分查找，通过比较key与a[i]的大小来折半查找，直到相等时才返回索引i。最终通过索引找到我们要找的元素。但是，这两种方法的效率都依赖于查找中比较的次数。我们有一种想法，能不能不经过比较，而是直接通过关键字key一次得到所要的结果呢？这时，
    
                    
    • 
                    
  • 厦门自由行之第一天:
                        大苏子在广漂

                        
    厦门三人行之杂记出发前一天:12️28日下午15:00从广州粗发，来深圳集合！但是中间发生一个小插曲，验票时候发现车票不见了，或许也是一场恶作剧，对于不排队的人，忍不住说了一下，接下来就发现车票不见了，已经是拿在手上！不过还好，可以凭借购票订单查看到信息，所以有惊无险，顺利进站！晚上三个人一起去吃了柠檬鱼，说实话，那会，感觉美吃饱，啊哈哈！晚上回来，两个人又开始彻夜长谈，发现身边优秀的人，一大把，
    
                    
    • 
                    
  • “这才好”麻辣香锅 能够增加人身体的免疫能力
                        小补文知

                        
    我就来介绍一种香锅，那就是“这才好”麻辣香锅，它产出于著名的蜀地文化，具有悠久的历史土家风味，麻辣鲜香，健康安全。采用传统秘制麻辣香锅油辣子，还有贴心加料“孜然包”满足人们的不同口味需求，香锅底料辣椒，微辣且香，含有丰富微量元素和维生素，具有辣而不躁，味道纯正，醇厚温和。花椒采用历史悠久，被列为宫廷供品的“贡椒”的汉源花椒。我们还挑选了“川菜之魂”郫县豆瓣的鼻祖品牌豆瓣，保留最原始的郫县豆瓣味道，
    
                    
    • 
                    
  • 《太虚游》第六十二章。玄牝之威。
                        古楼臭道士

                        
    “好好好，流云这孩子深得我心，想必长爻知道是你的话定然会惊喜不已的。”白玄牝听得风流云应了下来，脸色慈和，伸手在他头顶轻轻抚了抚，如同抚在怀中九尾小狐一样自然，极其温柔。身后的四位青丘长老同时一怔，嘴角微动，似要开口劝阻。风流云只感到一道霞光瑞气如有实质一般顺着头顶百会大穴直沉在下丹田内，随后这股气息又逐渐凝聚，似乎给自己吃了什么东西一般。啊喔不好，这祖奶奶该不会是看中我这肉身，像人魔一样，要给她
    
                    
    • 
                    
  • 生命如花
                        坦释空

                        
    每个人的心中都有一株妙莲花。这是禅家语。禅家总是站在理性的高处，以超越红尘的洒脱来参悟人生和自省生命。那么，凡俗中人呢？生如夏花之绚丽，死如秋叶之静美。这是诗人语。多少人在赞美：姑娘好像花一样！又有多少人在咏歌：花儿与少年。的确，人生如花。花一样的生命，理应自诞生之日起，就一瓣一瓣地绽放她的美丽与清香，使这个原本死寂荒凉的世界五彩缤纷，充满快乐。事实上，人类自诞生起，就一代一代地做着这方面的努力，
    
                    
    • 
                    
  • 二婚到底是领证好还是不领证好？
                        孟妃青

                        
    伟人讲过，不以结婚为目的的谈恋爱，都是耍流氓！离婚了，再找对象，感情到了一定程度，领证结婚是水到渠成的事，再说我中华泱泱大国，有礼仪之邦的称谓，领证更是体现了尊重男女双方的行为。如果认为二婚就没必要领证了，只能说明，男女之间都暗藏心思，心不往一处走，日子过不好的。即便他们感情再深，都不是合法夫妻，只是名不正言不顺的同居关系。假如不要二人共同的孩子还好，就怕有了孩子，没领证，到时给孩子上户口都成问题
    
                    
    • 
                    
  • 《华杉讲透王阳明传习录》
                        微微微微神

                        
    〔5〕希渊问：“圣人可学而至。然伯夷伊尹于孔子，才力终不同。其同谓之圣者安在”？先生曰，“圣人之所以为圣，只是其心纯乎天理，而无人欲之杂。犹精金之所以为精，但以其成色足而无铜铅之杂也。人到纯乎天理方是圣。金到足色方是精。然圣人之才力，亦有大小不同。犹金之分两有轻重。尧舜犹万镒。文王孔子犹九千镒。禹汤武王犹七八千镒。伯夷伊尹犹四五千镒。才力不同，而纯乎天理则同。皆可谓之圣人。犹分两虽不同，而足色则同
    
                    
    • 
                    
  • “日舍一物”之42——活在当下，并向前看
                        記二十一

                        
    这件衣服已经有十五、六年了（突然发现我可真是能囤东西啊）。这原本是一件我非常喜欢的衣服，无论是样子，还是质地。照片拍的比较渣，但其实，白色棉质衣料中，尚织有银色的丝线，在阳光或灯光下，会闪亮，不晃眼，但很漂亮。或许正是因为太喜欢了，所以一直保留着，尽管很多年都没有再穿过了。因为不合适了。首先是随着年龄的增长，尽管体重总量没有太多变化（哦，其实还是涨了）。但是体型还是和十几年前不一样了，最明显的就是
    
                    
    • 
                    
  • 语文主题教学学习笔记之87
                        东哥杂谈

                        
    “语文主题教学”学习笔记之八十七（0125）今天继续学习小学语文主题教学的实践样态。板块三：教学中体现“书艺”味道。作为四大名著之一的《水浒传》，堪称我国文学宝库之经典。对从《水浒传》中摘选的单元，教师就要了解其原生态，即评书体特点。这也要求教师要了解一些常用的评书行话术语，然后在教学时适时地加入一些，让学生体味其文本中原有的特色。学生也要尽可能地通过朗读的方式，而不单是分析讲解的方式进行学习。细
    
                    
    • 
                                
  • java类加载顺序
                                    3213213333332132
java
                                    
    package com.demo;

/**
 * @Description 类加载顺序
 * @author FuJianyong
 * 2015-2-6上午11:21:37
 */
public class ClassLoaderSequence {
	
	String s1 = "成员属性"; 
	
	static String s2 = "
    
                                
    • 
                                
  • Hibernate与mybitas的比较
                                    BlueSkator
sqlHibernate框架ibatisorm
                                    
    第一章     Hibernate与MyBatis 
Hibernate 是当前最流行的O/R mapping框架，它出身于sf.net，现在已经成为Jboss的一部分。 Mybatis 是另外一种优秀的O/R mapping框架。目前属于apache的一个子项目。 
MyBatis 参考资料官网：http:
    
                                
    • 
                                
  • php多维数组排序以及实际工作中的应用
                                    dcj3sjt126com
PHPusortuasort
                                    
    自定义排序函数返回false或负数意味着第一个参数应该排在第二个参数的前面, 正数或true反之, 0相等usort不保存键名uasort 键名会保存下来uksort 排序是对键名进行的 
<!doctype html>
<html lang="en">
<head>
    <meta charset="utf-8&q
    
                                
    • 
                                
  • DOM改变字体大小
                                    周华华
前端
                                    
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> 
<html xmlns="http://www.w3.org/1999/xhtml&q
    
                                
    • 
                                
  • c3p0的配置
                                    g21121
c3p0
                                    
    c3p0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。c3p0的下载地址是：http://sourceforge.net/projects/c3p0/这里可以下载到c3p0最新版本。 
以在spring中配置dataSource为例： 
<!-- spring加载资源文件 -->
<bean name="prope
    
                                
    • 
                                
  • Java获取工程路径的几种方法
                                    510888780
java
                                    
    第一种： 
File f = new File(this.getClass().getResource("/").getPath()); 
System.out.println(f); 
结果: 
C:\Documents%20and%20Settings\Administrator\workspace\projectName\bin 
获取当前类的所在工程路径; 
如果不加“
    
                                
    • 
                                
  • 在类Unix系统下实现SSH免密码登录服务器
                                    Harry642
免密ssh
                                    
    1.客户机 
    (1)执行ssh-keygen -t rsa -C "[email protected]"生成公钥，xxx为自定义大email地址 
    (2)执行scp ~/.ssh/id_rsa.pub root@xxxxxxxxx:/tmp将公钥拷贝到服务器上，xxx为服务器地址 
    (3)执行cat
    
                                
    • 
                                
  • Java新手入门的30个基本概念一
                                    aijuans
javajava 入门新手
                                    
    在我们学习Java的过程中,掌握其中的基本概念对我们的学习无论是J2SE,J2EE,J2ME都是很重要的,J2SE是Java的基础,所以有必要对其中的基本概念做以归纳,以便大家在以后的学习过程中更好的理解java的精髓,在此我总结了30条基本的概念。　　Java概述:　　目前Java主要应用于中间件的开发(middleware)---处理客户机于服务器之间的通信技术,早期的实践证明,Java不适合
    
                                
    • 
                                
  • Memcached for windows 简单介绍
                                    antlove
javaWebwindowscachememcached
                                    
    1. 安装memcached server 
a. 下载memcached-1.2.6-win32-bin.zip 
b. 解压缩，dos 窗口切换到 memcached.exe所在目录，运行memcached.exe -d install 
c.启动memcached Server,直接在dos窗口键入 net start "memcached Server&quo
    
                                
    • 
                                
  • 数据库对象的视图和索引
                                    百合不是茶
索引oeacle数据库视图
                                    
      
视图 
  
  视图是从一个表或视图导出的表，也可以是从多个表或视图导出的表。视图是一个虚表，数据库不对视图所对应的数据进行实际存储，只存储视图的定义，对视图的数据进行操作时,只能将字段定义为视图,不能将具体的数据定义为视图 
  
    为什么oracle需要视图; 
   &
    
                                
    • 
                                
  • Mockito(一) --入门篇
                                    bijian1013
持续集成mockito单元测试
                                    
            Mockito是一个针对Java的mocking框架，它与EasyMock和jMock很相似，但是通过在执行后校验什么已经被调用，它消除了对期望 行为（expectations）的需要。其它的mocking库需要你在执行前记录期望行为（expectations），而这导致了丑陋的初始化代码。 
 &nb
    
                                
    • 
                                
  • 精通Oracle10编程SQL(5)SQL函数
                                    bijian1013
oracle数据库plsql
                                    
    /*
 * SQL函数
*/

--数字函数
--ABS(n):返回数字n的绝对值
declare
  v_abs number(6,2);
begin
  v_abs:=abs(&no);
  dbms_output.put_line('绝对值：'||v_abs);
end;

--ACOS(n):返回数字n的反余弦值，输入值的范围是-1~1，输出值的单位为弧度
    
                                
    • 
                                
  • 【Log4j一】Log4j总体介绍
                                    bit1129
log4j
                                    
    Log4j组件：Logger、Appender、Layout 
  
Log4j核心包含三个组件：logger、appender和layout。这三个组件协作提供日志功能： 
 
 日志的输出目标 
 日志的输出格式 
  日志的输出级别(是否抑制日志的输出) 
  logger继承特性 
A logger is said to be an ancestor of anothe
    
                                
    • 
                                
  • Java IO笔记
                                    白糖_
java
                                    
    	public static void main(String[] args) throws IOException {
		//输入流
		InputStream in = Test.class.getResourceAsStream("/test");
		InputStreamReader isr = new InputStreamReader(in);
		Bu
    
                                
    • 
                                
  • Docker 监控
                                    ronin47
docker监控
                                    
             
目前项目内部署了docker，于是涉及到关于监控的事情，参考一些经典实例以及一些自己的想法，总结一下思路。 1、关于监控的内容 监控宿主机本身 
监控宿主机本身还是比较简单的，同其他服务器监控类似，对cpu、network、io、disk等做通用的检查，这里不再细说。 
额外的，因为是docker的
    
                                
    • 
                                
  • java-顺时针打印图形
                                    bylijinnan
java
                                    
    一个画图程序 要求打印出： 
 

1.int i=5;   
2.1  2  3  4  5  
3.16 17 18 19 6  
4.15 24 25 20 7  
5.14 23 22 21 8  
6.13 12 11 10 9  
7.  
8.int i=6  
9.1  2  3  4  5   6  
10.20 21 22 23 24  7  
11.19
    
                                
    • 
                                
  • 关于iReport汉化版强制使用英文的配置方法
                                    Kai_Ge
iReport汉化英文版
                                    
    对于那些具有强迫症的工程师来说，软件汉化固然好用，但是汉化不完整却极为头疼，本方法针对iReport汉化不完整的情况，强制使用英文版，方法如下： 
在 iReport 安装路径下的 etc/ireport.conf 里增加红色部分启动参数，即可变为英文版。   
# ${HOME} will be replaced by user home directory accordin
    
                                
    • 
                                
  • [并行计算]论宇宙的可计算性
                                    comsci
并行计算
                                    
     
 
      现在我们知道,一个涡旋系统具有并行计算能力.按照自然运动理论,这个系统也同时具有存储能力,同时具备计算和存储能力的系统,在某种条件下一般都会产生意识...... 
 
      那么,这种概念让我们推论出一个结论 
 
 
    &nb
    
                                
    • 
                                
  • 用OpenGL实现无限循环的coverflow
                                    dai_lm
androidcoverflow
                                    
    网上找了很久，都是用Gallery实现的，效果不是很满意，结果发现这个用OpenGL实现的，稍微修改了一下源码，实现了无限循环功能 
 
源码地址： 
https://github.com/jackfengji/glcoverflow 
 
 

public class CoverFlowOpenGL extends GLSurfaceView implements
		GLSurfaceV
    
                                
    • 
                                
  • JAVA数据计算的几个解决方案1
                                    datamachine
javaHibernate计算
                                    
    老大丢过来的软件跑了10天，摸到点门道，正好跟以前攒的私房有关联，整理存档。 
 
-----------------------------华丽的分割线------------------------------------- 
 
    数据计算层是指介于数据存储和应用程序之间，负责计算数据存储层的数据，并将计算结果返回应用程序的层次。J 
 &nbs
    
                                
    • 
                                
  • 简单的用户授权系统,利用给user表添加一个字段标识管理员的方式
                                    dcj3sjt126com
yii
                                    
    怎么创建一个简单的(非 RBAC)用户授权系统 
通过查看论坛，我发现这是一个常见的问题，所以我决定写这篇文章。 
本文只包括授权系统.假设你已经知道怎么创建身份验证系统(登录)。 数据库 
首先在 user 表创建一个新的字段(integer 类型),字段名 'accessLevel',它定义了用户的访问权限 扩展 CWebUser 类 
在配置文件(一般为 protecte
    
                                
    • 
                                
  • 未选之路
                                    dcj3sjt126com
诗
                                    
    作者:罗伯特*费罗斯特 
  
黄色的树林里分出两条路, 
可惜我不能同时去涉足, 
我在那路口久久伫立, 
我向着一条路极目望去, 
直到它消失在丛林深处. 
  
但我却选了另外一条路, 
它荒草萋萋,十分幽寂; 
显得更诱人,更美丽, 
虽然在这两条小路上, 
都很少留下旅人的足迹. 
  
那天清晨落叶满地, 
两条路都未见脚印痕迹. 
呵,留下一条路等改日再
    
                                
    • 
                                
  • Java处理15位身份证变18位
                                    蕃薯耀
18位身份证变15位15位身份证变18位身份证转换
                                    
      
15位身份证变18位，18位身份证变15位 
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 
蕃薯耀 201
    
                                
    • 
                                
  • SpringMVC4零配置--应用上下文配置【AppConfig】
                                    hanqunfeng
springmvc4
                                    
    从spring3.0开始，Spring将JavaConfig整合到核心模块，普通的POJO只需要标注@Configuration注解，就可以成为spring配置类，并通过在方法上标注@Bean注解的方式注入bean。 
  
Xml配置和Java类配置对比如下： 
applicationContext-AppConfig.xml 
  
<!-- 激活自动代理功能 参看：
    
                                
    • 
                                
  • Android中webview跟JAVASCRIPT中的交互
                                    jackyrong
JavaScripthtmlandroid脚本
                                    
      在android的应用程序中,可以直接调用webview中的javascript代码,而webview中的javascript代码,也可以去调用ANDROID应用程序(也就是JAVA部分的代码).下面举例说明之: 
 
1 JAVASCRIPT脚本调用android程序 
   要在webview中,调用addJavascriptInterface(OBJ,int
    
                                
    • 
                                
  • 8个最佳Web开发资源推荐
                                    lampcy
编程Web程序员
                                    
    Web开发对程序员来说是一项较为复杂的工作，程序员需要快速地满足用户需求。如今很多的在线资源可以给程序员提供帮助，比如指导手册、在线课程和一些参考资料，而且这些资源基本都是免费和适合初学者的。无论你是需要选择一门新的编程语言，或是了解最新的标准，还是需要从其他地方找到一些灵感，我们这里为你整理了一些很好的Web开发资源，帮助你更成功地进行Web开发。 
这里列出10个最佳Web开发资源，它们都是受
    
                                
    • 
                                
  • 架构师之面试------jdk的hashMap实现
                                    nannan408
HashMap
                                    
    1.前言。 
  如题。 
2.详述。 
  (1)hashMap算法就是数组链表。数组存放的元素是键值对。jdk通过移位算法（其实也就是简单的加乘算法），如下代码来生成数组下标(生成后indexFor一下就成下标了）。 
 

static int hash(int h) 
{ 
    h ^= (h >>> 20) ^ (h >>>
    
                                
    • 
                                
  • html禁止清除input文本输入缓存
                                    Rainbow702
html缓存input输入框change
                                    
    多数浏览器默认会缓存input的值，只有使用ctl+F5强制刷新的才可以清除缓存记录。    
如果不想让浏览器缓存input的值，有2种方法： 
方法一： 在不想使用缓存的input中添加 autocomplete="off";  
<input type="text" autocomplete="off" n
    
                                
    • 
                                
  • POJO和JavaBean的区别和联系
                                    tjmljw
POJOjava beans
                                    
    POJO 和JavaBean是我们常见的两个关键字，一般容易混淆，POJO全称是Plain Ordinary Java Object / Pure Old Java Object，中文可以翻译成：普通Java类，具有一部分getter/setter方法的那种类就可以称作POJO，但是JavaBean则比 POJO复杂很多， Java Bean 是可复用的组件，对 Java Bean 并没有严格的规
    
                                
    • 
                                
  • java中单例的五种写法
                                    liuxiaoling
java单例
                                    
    /**
 * 单例模式的五种写法：
 * 1、懒汉
 * 2、恶汉
 * 3、静态内部类
 * 4、枚举
 * 5、双重校验锁
 */
/**
 * 五、 双重校验锁，在当前的内存模型中无效
 */
class LockSingleton
{

    private volatile static LockSingleton singleton;

    pri
    
                                
    •