tracy_668
tracy_668

彻底理解 java Reference

java引用体系中我们最熟悉的就是强引用类型，如 A a= new A();这是我们经常说的强引用StrongReference，jvm gc时会检测对象是否存在强引用，如果存在由根对象对其有传递的强引用，则不会对其进行回收，即使内存不足抛出OutOfMemoryError。

除了强引用外，Java还引入了SoftReference，WeakReference，PhantomReference，FinalReference ，这些类放在java.lang.ref包下，类的继承体系如下图


image.png

Java额外引入这个四种类型引用主要目的是在jvm 在gc时，按照引用类型的不同，在回收时采用不同的逻辑。可以把这些引用看作是对对象的一层包裹，jvm根据外层不同的包裹，对其包裹的对象采用不同的回收策略.

Reference指代引用对象本身，Referent指代被引用对象

对象可达性判断
jvm gc时，判断一个对象是否存在引用时，都是从根结合引用(Root Set of References)开始去标识,往往到达一个对象的引用路径会存在多条，如下图

image.png

那么 垃圾回收时会依据两个原则来判断对象的可达性：

  • 单一路径中，以最弱的引用为准
  • 多路径中，以最强的引用为准

例如Obj4的引用，存在3个路径:1->6、2->5、3->4, 那么从根对象到Obj4最强的引用是2->5，因为它们都是强引用。如果仅仅存在一个路径对Obj4有引用时，比如现在只剩1->6,那么根对象到Obj4的引用就是以最弱的为准，就是SoftReference引用,Obj4就是softly-reachable对象。

Java最初只有普通的强引用，只有对象存在引用，则对象就不会被回收，即使内存不足，也是如此，JVM会爆出OOM，也不会去回收存在引用的对象。

如果只提供强引用，我们就很难写出“这个对象不是很重要，如果内存不足GC回收掉也是可以的”这种语义的代码。Java在1.2版本中完善了引用体系，提供了4中引用类型：强引用，软引用，弱引用，虚引用。使用这些引用类型，我们不但可以控制垃圾回收器对对象的回收策略，同时还能在对象被回收后得到通知，进行相应的后续操作。

Java目前有4中引用类型：

  1. 强引用(Strong Reference)：普通的的引用类型，new一个对象默认得到的引用就是强引用，只要对象存在强引用，就不会被GC。
  2. 软引用(Soft Reference)：相对较弱的引用，垃圾回收器会在内存不足时回收弱引用指向的对象。JVM会在抛出OOME前清理所有弱引用指向的对象，如果清理完还是内存不足，才会抛出OOME。所以软引用一般用于实现内存敏感缓存。
  3. 弱引用(Weak Reference)：更弱的引用类型，垃圾回收器在GC时会回收此对象，也可以用于实现缓存，比如JDK提供的WeakHashMap。
  4. 虚引用(Phantom Reference)：一种特殊的引用类型，不能通过虚引用获取到关联对象，只是用于获取对象被回收的通知。

SoftReference：软引用，堆内存不足时，垃圾回收器会回收对应引用
WeakReference：弱引用，每次垃圾回收都会回收其引用
PhantomReference：虚引用，对引用无影响，只用于获取对象被回收的通知
FinalReference：Java用于实现finalization的一个内部类

Reference的核心

Java的多种引用类型实现，不是通过扩展语法实现的，而是利用类实现的，Reference类表示一个引用，其核心代码就是一个成员变量reference

public abstract class Reference {
    private T referent; // 会被GC特殊对待
    
    // 获取Reference管理的对象
    public T get() {
        return this.referent;
    }
    
    // ...
}

如果JVM没有对这个变量做特殊处理，它依然只是一个普通的强引用，之所以会出现不同的引用类型，是因为JVM垃圾回收器硬编码识别SoftReference，WeakReference，PhantomReference等这些具体的类，对其reference变量进行特殊对象，才有了不同的引用类型的效果。

Reference及其子类有两大功能：

  • 实现特定的引用类型
  • 用户可以对象被回收后得到通知

第一个功能很清楚，第二个功能是如何做到的呢？

一种思路是在新建一个Reference实例是，添加一个回调，当java.lang.ref.Reference#referent被回收时，JVM调用该回调，这种思路比较符合一般的通知模型，但是对于引用与垃圾回收这种底层场景来说，会导致实现复杂，性能不高的问题，比如需要考虑在什么线程中执行这个回调，回调执行阻塞怎么办等等。

所以Reference使用了一种更加原始的方式来做通知，就是把引用对象被回收的Reference添加到一个队列中，用户后续自己去从队列中获取并使用。

理解了设计后对应到代码上就好理解了，Reference有一个queue成员变量，用于存储引用对象被回收的Reference实例：

public abstract class Reference {
    // 会被GC特殊对待
    private T referent; 
    // reference被回收后，当前Reference实例会被添加到这个队列中
    volatile ReferenceQueue queue;
    
    // 只传入reference的构造函数，意味着用户只需要特殊的引用类型，不关心对象何时被GC
    Reference(T referent) {
        this(referent, null);
    }
    
    // 传入referent和ReferenceQueue的构造函数，reference被回收后，会添加到queue中
    Reference(T referent, ReferenceQueue queue) {
        this.referent = referent;
        this.queue = (queue == null) ? ReferenceQueue.NULL : queue;
    }
    
    // ...
}

Reference的状态
Reference对象是有状态的。一共有4中状态：

  • Active：新创建的实例的状态，由垃圾回收器进行处理，如果实例的可达性处于合适的状态，垃圾回收器会切换实例的状态为Pending或者Inactive。如果Reference注册了ReferenceQueue，则会切换为Pending，并且Reference会加入pending-Reference链表中，如果没有注册ReferenceQueue，会切换为Inactive。
  • Pending：在pending-Reference链表中的Reference的状态，这些Reference等待被加入ReferenceQueue中。
  • Enqueued：在ReferenceQueue队列中的Reference的状态，如果Reference从队列中移除，会进入Inactive状态
  • Inactive：Reference的最终状态
image.png

除了上文提到的ReferenceQueue，这里出现了一个新的数据结构：pending-Reference。这个链表是用来干什么的呢？

上文提到了，reference引用的对象被回收后，该Reference实例会被添加到ReferenceQueue中，但是这个不是垃圾回收器来做的，这个操作还是有一定逻辑的。 如果垃圾回收器还需要执行这个操作，会降低其效率。从另外一方面想，Reference实例会被添加到ReferenceQueue中的实效性要求不高，所以也没必要在回收时立马加入ReferenceQueue。

所以垃圾回收器做的是一个更轻量级的操作：把Reference添加到pending-Reference链表中。Reference对象中有一个pending成员变量，是静态变量，它就是这个pending-Reference链表的头结点。要组成链表，还需要一个指针，指向下一个节点，这个对应的是java.lang.ref.Reference#discovered这个成员变量。

public abstract class Reference {
    // 会被GC特殊对待
    private T referent; 
    // reference被回收后，当前Reference实例会被添加到这个队列中
    volatile ReferenceQueue queue; 
    
    // 全局唯一的pending-Reference列表
    private static Reference pending = null;
    
    // Reference为Active：由垃圾回收器管理的已发现的引用列表(这个不在本文讨论访问内)
    // Reference为Pending：在pending列表中的下一个元素，如果没有为null
    // 其他状态：NULL
    transient private Reference discovered;  /* used by VM */
    // ...
}
 
 
ReferenceHandler线程
 通过上文的讨论，我们知道一个Reference实例化后状态为Active，其引用的对象被回收后，垃圾回收器将其加入到pending-Reference链表，等待加入ReferenceQueue。这个过程是如何实现的呢？
 
 
这个过程不能对垃圾回收器产生影响，所以不能在垃圾回收线程中执行，也就需要一个独立的线程来负责。这个线程就是ReferenceHandler，它定义在Reference类中：
 
 
// 用于控制垃圾回收器操作与Pending状态的Reference入队操作不冲突执行的全局锁
// 垃圾回收器开始一轮垃圾回收前要获取此锁
// 所以所有占用这个锁的代码必须尽快完成，不能生成新对象，也不能调用用户代码
static private class Lock { };
private static Lock lock = new Lock();

private static class ReferenceHandler extends Thread {

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

    public void run() {
        // 这个线程一直执行
        for (;;) {
            Reference r;
            // 获取锁，避免与垃圾回收器同时操作
            synchronized (lock) {
                // 判断pending-Reference链表是否有数据
                if (pending != null) {
                    // 如果有Pending Reference，从列表中取出
                    r = pending;
                    pending = r.discovered;
                    r.discovered = null;
                } else {
                    // 如果没有Pending Reference，调用wait等待
                    // 
                    // wait等待锁，是可能抛出OOME的，
                    // 因为可能发生InterruptedException异常，然后就需要实例化这个异常对象，
                    // 如果此时内存不足，就可能抛出OOME，所以这里需要捕获OutOfMemoryError，
                    // 避免因为OOME而导致ReferenceHandler进程静默退出
                    try {
                        try {
                            lock.wait();
                        } catch (OutOfMemoryError x) { }
                    } catch (InterruptedException x) { }
                    continue;
                }
            }

            // 如果Reference是Cleaner，调用其clean方法
            // 这与Cleaner机制有关系，不在此文的讨论访问
            if (r instanceof Cleaner) {
                ((Cleaner)r).clean();
                continue;
            }

            // 把Reference添加到关联的ReferenceQueue中
            // 如果Reference构造时没有关联ReferenceQueue，会关联ReferenceQueue.NULL，这里就不会进行入队操作了
            ReferenceQueue q = r.queue;
            if (q != ReferenceQueue.NULL) q.enqueue(r);
        }
    }
}
 
 
ReferenceHandler线程是在Reference的static块中启动的：
 
 
static {
    // 获取system ThreadGroup
    ThreadGroup tg = Thread.currentThread().getThreadGroup();
    for (ThreadGroup tgn = tg;
         tgn != null;
         tg = tgn, tgn = tg.getParent());
    Thread handler = new ReferenceHandler(tg, "Reference Handler");

    // ReferenceHandler线程有最高优先级
    handler.setPriority(Thread.MAX_PRIORITY);
    handler.setDaemon(true);
    handler.start();
}

 
 
综上，ReferenceHandler是一个最高优先级的线程，其逻辑是从Pending-Reference链表中取出Reference，添加到其关联的Reference-Queue中。
 
 
 
  
 
   
  
   
 
  
 
  

    image.png 
  
 
 
 
 
再来看些细节代码：
 
 
ReferenceQueue VS Reference
 
 
Reference作为SoftReference，WeakReference，PhantomReference，FinalReference这几个引用类型的父类。主要有两个字段referent、queue，一个是指所引用的对象，一个是与之对应的ReferenceQueue。Reference类有个构造函数 Reference(T referent, ReferenceQueue queue)，可以通过该构造函数传入与Reference相伴的ReferenceQueue。
 
 
ReferenceQueue本身提供队列的功能，有入队(enqueue)和出队(poll,remove,其中remove阻塞等待提取队列元素)。ReferenceQueue对象本身保存了一个Reference类型的head节点，Reference封装了next字段，这样就是可以组成一个单向链表。同时ReferenceQueue提供了两个静态字段NULL，ENQUEUED
 
 
static ReferenceQueue NULL = new Null<>();
static ReferenceQueue ENQUEUED = new Null<>();
 
 
这两个字段的主要功能：NULL是当我们构造Reference实例时queue传入null时，会默认使用NULL，这样在enqueue时判断queue是否为NULL,如果为NULL直接返回，入队失败。ENQUEUED的作用是防止重复入队，reference后会把其queue字段赋值为ENQUEUED,当再次入队时会直接返回失败。
 
 
 boolean enqueue(Reference r) { /* Called only by Reference class */
        synchronized (lock) {
            // Check that since getting the lock this reference hasn't already been
            // enqueued (and even then removed)
            ReferenceQueue queue = r.queue;
            if ((queue == NULL) || (queue == ENQUEUED)) {
                return false;
            }
            assert queue == this;
            r.queue = ENQUEUED;
            r.next = (head == null) ? r : head;
            head = r;
            queueLength++;
            if (r instanceof FinalReference) {
                sun.misc.VM.addFinalRefCount(1);
            }
            lock.notifyAll();
            return true;
        }
    }

 
 
Reference与ReferenceQueue之间是如何工作的呢？Reference里有个静态字段pending，同时还通过静态代码块启动了Reference-handler thread。当一个Reference的referent被回收时, 垃圾回收器会把reference添加到pending这个链表里,然后Reference-handler thread不断的读取pending中的reference，把它加入到对应的ReferenceQueue中, 我们可以通过下面代码块来进行把SoftReference，WeakReference，PhantomReference与ReferenceQueue联合使用来验证这个机制。为了确保SoftReference在每次gc后，其引用的referent都被回收，我们需要加入-XX:SoftRefLRUPolicyMSPerMB=0参数，
 
 
通过jstack命令可以看到对应的Reference Handler thread
 
 
"Reference Handler" #2 daemon prio=10 os_prio=31 tid=0x00007f8fb2836800 nid=0x2e03 in Object.wait() [0x000070000082b000]
   java.lang.Thread.State: WAITING (on object monitor)
        at java.lang.Object.wait(Native Method)
        - waiting on <0x0000000740008878> (a java.lang.ref.Reference$Lock)
        at java.lang.Object.wait(Object.java:502)
        at java.lang.ref.Reference.tryHandlePending(Reference.java:191)
        - locked <0x0000000740008878> (a java.lang.ref.Reference$Lock)
        at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:153)


 
 
因此可以看出，当reference与referenQueue联合使用的主要作用就是当reference指向的referent回收时(或者要被回收 如下文要讲的Finalizer)，提供一种通知机制，通过queue取到这些reference，来做额外的处理工作。当然，如果我们不需要这种通知机制，我们就不用传入额外的queue,默认使用NULL queue就会入队失败。
 
 
SoftReference
 
 
根据上面我们讲的对象可达性原理，我们把一个对象存在根对象对其有直接或间接的SoftReference，并没有其他强引用路径，我们把该对象成为softly-reachable对象。JVM保证在抛出OutOfMemoryError前会回收这些softly-reachable对象。JVM会根据当前内存的情况来决定是否回收softly-reachable对象，但只要referent有强引用存在，该referent就一定不会被清理，因此SoftReference适合用来实现memory-sensitive caches。软引用的回收策略在不同的JVM实现会略有不同，javadoc中说明：
 
 
Virtual machine implementations are, however, encouraged to bias against clearing recently-created or recently-used soft references.

 
 
也就是说JVM不仅仅只会考虑当前内存情况，还会考虑软引用所指向的referent最近使用情况和创建时间来综合决定是否回收该referent。
 
 
Hotspot在gc时会根据两个标准来回收：
 
 
     
  
  • 根据SoftReference引用实例的timestamp(每次调用softReference.get()会自动更新该字段，把最近一次垃圾回收时间赋值给timestamp,见源码)
    •  
  
  • 当前JVM heap的内存剩余(free_heap)情况
    •  
 
 
 
计算的规则是：
 
 
     
  
  • free_heap 表示当前堆剩余的内存，单位是MB
    •  
  
  • interval 表示最近一次GC's clock 和 当前我们要判断的softReference的timestamp 差值
    •  
  
  • ms_per_mb is a constant number of milliseconds to keep around a SoftReference for each free megabyte in the heap（可以通过-XX:SoftRefLRUPolicyMSPerMB来设定）
    •  
 
 
 
那么判断依据就是: interval <= free_heap * ms_per_mb,如果为true,则保留，false则进行对象清除。_ ** SoftReferences will always be kept for at least one GC after their last access。**_ 因为 只要调用一次，那么clock和timestamp的值就会一样，clock-timestamp则为0，一定小于等于free_heap * ms_per_mb。 OpenJDK的大概referencePolicy.cpp代码是：
 
 
void LRUMaxHeapPolicy::setup() {
  size_t max_heap = MaxHeapSize;
  max_heap -= Universe::get_heap_used_at_last_gc();
  max_heap /= M;

  _max_interval = max_heap * SoftRefLRUPolicyMSPerMB;
  assert(_max_interval >= 0,"Sanity check");
}

bool LRUMaxHeapPolicy::should_clear_reference(oop p,
                                             jlong timestamp_clock) {
  jlong interval = timestamp_clock - java_lang_ref_SoftReference::timestamp(p);
  assert(interval >= 0, "Sanity check");

  // The interval will be zero if the ref was accessed since the last scavenge/gc.
  if(interval <= _max_interval) {
    return false;
  }

  return true;
}

 
 
可见，SoftReference在一定程度上会影响JVM GC的，例如softly-reachable对应的referent多次垃圾回收仍然不满足释放条件，那么它会停留在heap old区，占据很大部分空间，在JVM没有抛出OutOfMemoryError前，它有可能会导致频繁的Full GC。
 
 
WeakReference
 
 
当一个对象被WeakReference引用时，处于weakly-reachable状态时，只要发生GC时，就会被清除，同时会把WeakReference注册到引用队列中(如果存在的话)。 WeakReference不阻碍或影响它们对应的referent被终结(finalized)和回收(reclaimed)，因此，WeakReference经常被用作实现规范映射(canonicalizing mappings)。相比SoftReference来说，WeakReference对JVM GC几乎是没有影响的。
 
 
下面我们举个WeakReference应用场景，JDK自带的WeakHashMap，我们用下面的代码来测试查看WeakHashMap在gc后的entry的情况，加入-verbose:gc运行。
 
 
/**
 * 加入下面参数，观察gc情况
 * -verbose:gc
 */
public class WeakHashMapTest {

    private static Map caches=new WeakHashMap<>();

    public static void main(String[]args) throws InterruptedException {
        for (int i=0;i<100000;i++){
            caches.put(i+"",new byte[1024*1024*10]);
            System.out.println("put num: " + i + " but caches size:" + caches.size());
        }
    }
}

 
 
运行代码我们可以看到，虽然我们不断的往caches中put元素，但是caches size会伴随每次gc又从0开始了。
 
 
WeakHashMap实现原理很简单，它除了实现标准的Map接口，里面的机制也和HashMap的实现类似。从它entry子类中可以看出，它的key是用WeakReference包裹住的。当这个key对象本身不再被使用时，伴随着GC的发生，会自动把该key对应的entry都在Map中清除掉。它为啥能够自动清除呢？这就是利用上面我们讲的ReferenceQueue VS Reference的原理。WeakHashMap里声明了一个queue，Entry继承WeakReference,构造函数中用key和queue关联构造一个weakReference,当key不再被使用gc后会自动把把key注册到queue中:
 
 
 /**
     * Reference queue for cleared WeakEntries
     */
    private final ReferenceQueue queue = new ReferenceQueue<>();

   /**
     * The entries in this hash table extend WeakReference, using its main ref
     * field as the key.
     */
    private static class Entry extends WeakReference implements Map.Entry {
        V value;
        final int hash;
        Entry next;

        /**
         * Creates new entry.
         */
        Entry(Object key, V value,
              ReferenceQueue queue,
              int hash, Entry next) {
            super(key, queue);
            this.value = value;
            this.hash  = hash;
            this.next  = next;
        }
       //代码省略
    ｝
}
 
 
WeakHashMap关键的清理entry代码:
 
 
/**
     * Expunges stale entries from the table.
     */
    private void expungeStaleEntries() {
        for (Object x; (x = queue.poll()) != null; ) {
            synchronized (queue) {
                @SuppressWarnings("unchecked")
                    Entry e = (Entry) x;
                int i = indexFor(e.hash, table.length);

                Entry prev = table[i];
                Entry p = prev;
                while (p != null) {
                    Entry next = p.next;
                    if (p == e) {
                        if (prev == e)
                            table[i] = next;
                        else
                            prev.next = next;
                        // Must not null out e.next;
                        // stale entries may be in use by a HashIterator
                        e.value = null; // Help GC
                        size--;
                        break;
                    }
                    prev = p;
                    p = next;
                }
            }
        }
    }

 
 
这段代码会在resize,getTable,size里执行，清除失效的entry。
 
 
PhantomReference
 
 
PhantomReference 不同于WeakReference、SoftReference，它存在的意义不是为了获取referent,因为你也永远获取不到，因为它的get如下
 
 
public T get() {
        return null;
 }

 
 
PhantomReference主要作为其指向的referent被回收时的一种通知机制,它就是利用上文讲到的ReferenceQueue实现的。当referent被gc回收时，JVM自动把PhantomReference对象(reference)本身加入到ReferenceQueue中，像发出信号通知一样，表明该reference指向的referent被回收。然后可以通过去queue中取到reference，此时说明其指向的referent已经被回收，可以通过这个通知机制来做额外的清场工作。 因此有些情况可以用PhantomReference 代替finalize()，做资源释放更明智。
 
 
下面举个例子，用PhantomReference来自动关闭文件流。
 
 
public class ResourcePhantomReference extends PhantomReference {

    private List closeables;

    public ResourcePhantomReference(T referent, ReferenceQueue q, List resource) {
        super(referent, q);
        closeables = resource;
    }

    public void cleanUp() {
        if (closeables == null || closeables.size() == 0)
            return;
        for (Closeable closeable : closeables) {
            try {
                closeable.close();
                System.out.println("clean up:"+closeable);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

 
 
public class ResourceCloseDeamon extends Thread {

    private static ReferenceQueue QUEUE = new ReferenceQueue();

    //保持对reference的引用,防止reference本身被回收
    private static List references=new ArrayList<>();
    @Override
    public void run() {
        this.setName("ResourceCloseDeamon");
        while (true) {
            try {
                ResourcePhantomReference reference = (ResourcePhantomReference) QUEUE.remove();
                reference.cleanUp();
                references.remove(reference);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void register(Object referent, List closeables) {
        references.add(new ResourcePhantomReference(referent,QUEUE,closeables));
    }


}

 
 
public class FileOperation {

    private FileOutputStream outputStream;

    private FileInputStream inputStream;

    public FileOperation(FileInputStream inputStream, FileOutputStream outputStream) {
        this.outputStream = outputStream;
        this.inputStream = inputStream;
    }

    public void operate() {
        try {
            inputStream.getChannel().transferTo(0, inputStream.getChannel().size(), outputStream.getChannel());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


}


 
 
public class PhantomTest {

    public static void main(String[] args) throws Exception {
        //打开回收
        ResourceCloseDeamon deamon = new ResourceCloseDeamon();
        deamon.setDaemon(true);
        deamon.start();

        // touch a.txt b.txt
        // echo "hello" > a.txt

        //保留对象,防止gc把stream回收掉,其不到演示效果
        List all=new ArrayList<>();
        FileInputStream inputStream;
        FileOutputStream outputStream;

        for (int i = 0; i < 100000; i++) {
            inputStream = new FileInputStream("/Users/robin/a.txt");
            outputStream = new FileOutputStream("/Users/robin/b.txt");
            FileOperation operation = new FileOperation(inputStream, outputStream);
            operation.operate();
            TimeUnit.MILLISECONDS.sleep(100);

            Listcloseables=new ArrayList<>();
            closeables.add(inputStream);
            closeables.add(outputStream);
            all.addAll(closeables);
            ResourceCloseDeamon.register(operation,closeables);
            //用下面命令查看文件句柄,如果把上面register注释掉,就会发现句柄数量不断上升
            //jps | grep PhantomTest | awk '{print $1}' |head -1 | xargs  lsof -p  | grep /User/robin
            System.gc();

        }


    }

 
 
运行上面的代码，通过jps | grep PhantomTest | awk '{print $1}' |head -1 | xargs lsof -p | grep /User/robin ｜ wc -l 可以看到句柄没有上升，而去掉ResourceCloseDeamon.register(operation,closeables);时，句柄就不会被释放。
 
 
PhantomReference使用时一定要传一个referenceQueue,当然也可以传null,但是这样就毫无意义了。因为PhantomReference的get结果为null,如果在把queue设为null,那么在其指向的referent被回收时，reference本身将永远不会可能被加入队列中.
 
 
FinalReference
 
 
FinalReference 引用类型主要是为虚拟机提供的，提供 _ 对象被gc前需要执行finalize方法的对象_ 的机制。
 
 
FinalReference 很简单就是extend Reference类，没有做其他逻辑，只是把访问权限改为package,因此我们是无法直接使用的。Finalizer类是我们要讲的重点，它继承了FinalReference，并且是final 类型的。Finalize实现很简单，也是利用上面我们讲的ReferenceQueue VS Reference机制。
 
 
FinalizerThread
 
 
Finalizer静态代码块里启动了一个deamon线程，我们通过jstack命令查看线程时，总会看到一个Finalizer线程，就是这个原因:
 
 
 static {
        ThreadGroup tg = Thread.currentThread().getThreadGroup();
        for (ThreadGroup tgn = tg;
             tgn != null;
             tg = tgn, tgn = tg.getParent());
        Thread finalizer = new FinalizerThread(tg);
        finalizer.setPriority(Thread.MAX_PRIORITY - 2);
        finalizer.setDaemon(true);
        finalizer.start();
    }


 
 
FinalizerThread run方法是不断的从queue中去取Finalizer类型的reference，然后执行runFinalizer释放方法。
 
 
 public void run() {
            if (running)
                return;

            // Finalizer thread starts before System.initializeSystemClass
            // is called.  Wait until JavaLangAccess is available
            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 {
                    Finalizer f = (Finalizer)queue.remove();
                    f.runFinalizer(jla);
                } catch (InterruptedException x) {
                    // ignore and continue
                }
            }
       }

 
 
runFinalizer方法体，执行事发逻辑,可以看出如果finalize方法中抛出异常会被直接吃掉：
 
 
  private void runFinalizer(JavaLangAccess jla) {
        synchronized (this) {
            if (hasBeenFinalized()) return;
            remove();
        }
        try {
            Object finalizee = this.get();
            if (finalizee != null && !(finalizee instanceof java.lang.Enum)) {
                jla.invokeFinalize(finalizee);

                /* Clear stack slot containing this variable, to decrease
                   the chances of false retention with a conservative GC */
                finalizee = null;
            }
        } catch (Throwable x) { }
        super.clear();
    }

 
 
介绍完上面的处理机制，那么剩下的就是入queue的事情，就是哪些类对象需要入队，何时入队.
 
 
哪些类对象是Finalizer reference类型的referent呢
 
 
只要类覆写了Object 上的finalize方法，方法体非空。那么这个类的实例都会被Finalizer引用类型引用的。下文中我们简称Finalizer 型的referent为finalizee。
 
 
何时调用Finalizer.register生成一个Finalizer类型的reference
 
 
Finalizer的构造函数是private的，也就是不能通过new 来生成一个Fianlizer reference。只能通过静态的register方法来生成。同时Finalizer有个静态字段unfinalized，维护了一个未执行finalize方法的reference列表，在构造函数中通过add()方法把Finalizer引用本身加入到unfinalized列表中，同时关联finalizee和queue,实现通知机制。维护静态字段unfinalized的目的是为了一直保持对未未执行finalize方法的reference的强引用，防止被gc回收掉。
 
 
  private static Finalizer unfinalized = null;
    private Finalizer(Object finalizee) {
        super(finalizee, queue);
        add();
    }
    /* Invoked by VM */
    static void register(Object finalizee) {
        new Finalizer(finalizee);
    }
    private void add() {
        synchronized (lock) {
            if (unfinalized != null) {
                this.next = unfinalized;
                unfinalized.prev = this;
            }
            unfinalized = this;
        }
    }

 
 
那么register是被VM何时调用的呢？JVM通过VM参数 RegisterFinalizersAtInit 的值来确定何时调用register，RegisterFinalizersAtInit默认为true,则会在构造函数返回之前调用call_register_finalizer方法。
 
 
void Parse::return_current(Node* value) {
  if (RegisterFinalizersAtInit &&
      method()->intrinsic_id() == vmIntrinsics::_Object_init) {
    call_register_finalizer();
  }
  ..............
}

 
 
如果通过-XX:-RegisterFinalizersAtInit 设为false，则会在对象空间分配好之后就调用call_register_finalizer
 
 
nstanceOop InstanceKlass::allocate_instance(TRAPS) {
  bool has_finalizer_flag = has_finalizer(); // Query before possible GC
  int size = size_helper();  // Query before forming handle.

  KlassHandle h_k(THREAD, this);

  instanceOop i;

  i = (instanceOop)CollectedHeap::obj_allocate(h_k, size, CHECK_NULL);
  if (has_finalizer_flag && !RegisterFinalizersAtInit) {
    i = register_finalizer(i, CHECK_NULL);
  }
  return i;
}

 
 
何时入queue
 当一个finalizee 只剩Finalizer引用，没有其他引用时，需要被回收了，GC就会把该finalizee对应的reference放到Finalizer的refereneQueue中,等待FinalizerThread来执行finalizee的finalize方法，然后finalizee对象才能被GC回收。
 
 
Finalizer问题
 
 
     
  
  1. finalizee对象在finalize重新被赋给一个强引用复活，那么下次GC前会不会被再次执行finalize方法?
    2.  
 
 
 
答案是不会的，runFinalizer中会把该finalizee对应的Finalizer引用从unfinalized队列中移除，第二次执行的时会通过hasBeenFinalized方法判断，保证不会被重复执行。
 
 
 private void runFinalizer(JavaLangAccess jla) {
        synchronized (this) {
            if (hasBeenFinalized()) return;
            remove();
        }
        try {
            Object finalizee = this.get();
            if (finalizee != null && !(finalizee instanceof java.lang.Enum)) {
                jla.invokeFinalize(finalizee);

                /* Clear stack slot containing this variable, to decrease
                   the chances of false retention with a conservative GC */
                finalizee = null;
            }
        } catch (Throwable x) { }
        super.clear();
    }

 
 
     
  
  1. finalizee至少两次GC回收才可能被回收？
     第一次GC把finalizee对应的Finalizer reference加入referenceQueue等待FinalizerThread来执行finalize方法。第二次GC才有可能释放finalizee对象本身，前提是FinalizerThread已经执行完finalize方法了，并把Finalizer reference从Finalizer静态unfinalized链表中剔除，因为这个链表和Finalizer reference对finalizee构成的是一个强引用。
    2.  
  
  2. Finalizer 机制导致JVM Full GC 频繁，stop-the-world延长？
    3.  
 
 
 
因为如果finalizee上的finalize方法体执行过程耗时比较长，会导致对象一直堆积，多次GC仍不能释放，冲进old区，造成Old区GC过程延长，暂停时间增加，可能频繁触发Full GC。
 
 
小结
 
 
通过对SoftReference，WeakReference，PhantomReference，FinalReference 的介绍，可以看出JDK提供这些类型的reference 主要是用来和GC交互的，根据reference的不同，让JVM采用不同策略来进行对对象的回收(reclaim)。softly-reachable的referent在保证在OutOfMemoryError之前回收对象，weakly-reachable的referent在发生GC时就会被回收，finalizer型的reference 主要提供GC前对referent进行finalize执行机制。同时这些reference和referenceQueue在一起提供通知机制，PhantomReference的作用就是仅仅就是提供对象回收通知机制，Finalizer借助这种机制实现referent的finalize执行，SoftReference、WeakReference也可以配合referenceQueue使用，实现对象回收通知机制。
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(彻底理解 java Reference)

        

            

                
    
                    
  • element实现动态路由+面包屑
                        软件技术NINI
vue案例vue.js前端
                        
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
    
                    
    • 
                    
  • 理解Gunicorn：Python WSGI服务器的基石
                        范范0825
ipythonlinux运维
                        
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
    
                    
    • 
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • 绘本讲师训练营【24期】8/21阅读原创《独生小孩》
                        1784e22615e0

                        
    24016-孟娟《独生小孩》图片发自App今天我想分享一个蛮特别的绘本，讲的是一个特殊的群体，我也是属于这个群体，80后的独生小孩。这是一本中国绘本，作者郭婧，也是一个80厚。全书一百多页，均为铅笔绘制，虽然为黑白色调，但并不显得沉闷。全书没有文字，犹如“默片”，但并不影响读者对该作品的理解，反而显得神秘，梦幻，給读者留下想象的空间。作者在前蝴蝶页这样写到：“我更希望父母和孩子一起分享这本书，使他
    
                    
    • 
                    
  • LLM 词汇表
                        落难Coder
LLMsNLP大语言模型大模型llama人工智能
                        
    Contextwindow“上下文窗口”是指语言模型在生成新文本时能够回溯和参考的文本量。这不同于语言模型训练时所使用的大量数据集，而是代表了模型的“工作记忆”。较大的上下文窗口可以让模型理解和响应更复杂和更长的提示，而较小的上下文窗口可能会限制模型处理较长提示或在长时间对话中保持连贯性的能力。Fine-tuning微调是使用额外的数据进一步训练预训练语言模型的过程。这使得模型开始表示和模仿微调数
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 深入理解 MultiQueryRetriever：提升向量数据库检索效果的强大工具
                        nseejrukjhad
数据库python
                        
    深入理解MultiQueryRetriever：提升向量数据库检索效果的强大工具引言在人工智能和自然语言处理领域，高效准确的信息检索一直是一个关键挑战。传统的基于距离的向量数据库检索方法虽然广泛应用，但仍存在一些局限性。本文将介绍一种创新的解决方案：MultiQueryRetriever，它通过自动生成多个查询视角来增强检索效果，提高结果的相关性和多样性。MultiQueryRetriever的工
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • 如何成为段子手
                        欣雅阅读

                        
    我是一个尬聊大师，与朋友聊天经常把话题聊死，留我一个人在群里，望着自己打下的最后一句话无语凝噎。看到风趣幽默的朋友与人聊天，很是艳羡，觉得自己何时才能成为这样的段子手呢？一、段子是什么？“段子”一词在百度百科上的解释：本是相声中的一个艺术术语，指的是相声作品中一节或一段艺术内容。我的理解：段子就是一些搞笑的故事或者笑话。二、为什么要会说段子？不知道大家有没有这样的朋友，本来很无趣的聚会，只要有他参
    
                    
    • 
                    
  • 回溯算法-重新安排行程
                        chirou_
算法数据结构图论c++图搜索
                        
    leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
    
                    
    • 
                    
  • 心有蓝天白云，爱情便会晴空万里，然后有花香有鸟鸣有美好的未来
                        曹十二吖

                        
    丁南的婚姻，来自于一场她对生命的对比。她曾经说过，当她最爱的母亲用生命去逼迫她结婚的时候，她曾一度不理解到愤怒，甚至于想过用轻生来对抗母亲的不理智。庆幸的是，丁南是一个自我调节能力非常强的人，她想如果我连死亡都不怕，还怕不能经营好一段婚姻吗？抱着这样的念头，24年没有谈过恋爱的她，用短短三个月的时间，完成了少女到女人的蜕变。她曾经说过：“我要把自己最珍贵的东西留给自己命中注定的那个人。”闺蜜几人中
    
                    
    • 
                    
  • Redis系列：Geo 类型赋能亿级地图位置计算
                        Ly768768
redisbootstrap数据库
                        
    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
    
                    
    • 
                    
  • 简介Shell、zsh、bash
                        zhaosuningsn
Shellzshbashshelllinuxbash
                        
    Shell是Linux和Unix的外壳，类似衣服，负责外界与Linux和Unix内核的交互联系。例如接收终端用户及各种应用程序的命令，把接收的命令翻译成内核能理解的语言，传递给内核，并把内核处理接收的命令的结果返回给外界，即Shell是外界和内核沟通的桥梁或大门。Linux和Unix提供了多种Shell，其中有种bash，当然还有其他好多种。Mac电脑中不但有bash，还有一个zsh，预装的，据说
    
                    
    • 
                    
  • 如何选择最适合你的项目研发管理软件？TAPD卓越版全面解析
                        北京云巴巴信息技术有限公司
产品经理需求分析
                        
    在当今快速发展的科技时代，项目研发管理软件已成为企业不可或缺的重要工具。面对市场上琳琅满目的产品，如何选择一款适合自己团队的项目研发管理软件呢？本文将围绕项目研发管理软件的选择标准，重点介绍TAPD卓越版的特点、优势以及使用体验，让你更好地理解和选择适合自己的项目研发管理软件。项目研发管理软件的选择标准在选择项目研发管理软件时，我们需要考虑以下几个方面的因素：功能全面性：软件是否覆盖了从需求管理、
    
                    
    • 
                    
  • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    
                    
    • 
                    
  • STM32中的计时与延时
                        lupinjia
STM32stm32单片机
                        
    前言在裸机开发中，延时作为一种规定循环周期的方式经常被使用，其中尤以HAL库官方提供的HAL_Delay为甚。刚入门的小白可能会觉得既然有官方提供的延时函数，而且精度也还挺好，为什么不用呢？实际上HAL_Delay中有不少坑，而这些也只是HAL库中无数坑的其中一些。想从坑里跳出来还是得加强外设原理的学习和理解，切不可只依赖HAL库。除了延时之外，我们在开发中有时也会想要确定某段程序的耗时，这就需要
    
                    
    • 
                    
  • 简单了解 JVM
                        记得开心一点啊
jvm
                        
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    
                    
    • 
                    
  • 关于Mysql 中 Row size too large (＞ 8126) 错误的解决和理解
                        秋刀prince
mysqlmysql数据库
                        
    提示：啰嗦一嘴，数据库的任何操作和验证前，一定要记得先备份！！！不会有错；文章目录问题发现一、问题导致的可能原因1、页大小2、行格式2.1compact格式2.2Redundant格式2.3Dynamic格式2.4Compressed格式3、BLOB和TEXT列二、解决办法1、修改页大小（不推荐）2、修改行格式3、修改数据类型为BLOB和TEXT列4、其他优化方式（可以参考使用）4.1合理设置数据
    
                    
    • 
                    
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
    
                    
    • 
                    
  • Java企业面试题3
                        马龙强_
java
                        
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
    
                    
    • 
                    
  • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    
                    
    • 
                    
  • 如何在心上用功？
                        余超林AIA财富管家

                        
    思考：如何在心上用功？学习心得：心-道-德-事的理解心-道-德-事这四部曲，本质上就是一个人的思维智慧的四个层面：事是最底层，这是所有人在这个社会谋求生存的基础，一个人能够把事情彻底做好，保质保量的完成，才会有真正的结果，但是这个层面要获得真正成功很困难，因为会做事的人很多，最终会出现恶性竞争；德是第三层，如果说整个社会做事的竞争激烈程度为100%，那么上升到德上的竞争激烈程度降低为80%，德是一
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • 戴容容 中原焦点团队.网络初级第33期,坚持分享第19天 2022年3月9日
                        TessDai

                        
    《每个人眼中的世界都是不同的》“一千个人眼里有一千个哈姆雷特”世界是多元的,每个人都有自己的道理,人人按照自己的理解去看待这个世界的人和物.我们如此,其他人也是如此.因此,任何事情,我们要放下自己以为的真理,去理解他人认为的真理,只有同频方能共振.孩子在慢慢长大的过程中慢慢学会独立,甚至对抗.尤其当孩子处于青春期的时候,他们开始有很多自己独立的想法,和一些特立独行的做法,家长常常会觉得不可思议,觉
    
                    
    • 
                    
  • 白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    
                    
    • 
                                
  • mondb入手
                                    木zi_鸣
mongodb
                                    
    windows 启动mongodb  编写bat文件， 
 
mongod --dbpath D:\software\MongoDBDATA 
mongod --help  查询各种配置 
配置在mongob 
 
打开批处理，即可启动，27017原生端口，shell操作监控端口  扩展28017，web端操作端口 
 
启动配置文件配置， 
 
数据更灵活 
    
                                
    • 
                                
  • 大型高并发高负载网站的系统架构
                                    bijian1013
高并发负载均衡
                                    
            扩展Web应用程序 
一.概念 
        简单的来说，如果一个系统可扩展，那么你可以通过扩展来提供系统的性能。这代表着系统能够容纳更高的负载、更大的数据集，并且系统是可维护的。扩展和语言、某项具体的技术都是无关的。扩展可以分为两种： 
        1.
    
                                
    • 
                                
  • DISPLAY变量和xhost(原创)
                                    czmmiao
display
                                    
    DISPLAY 
在Linux/Unix类操作系统上, DISPLAY用来设置将图形显示到何处. 直接登陆图形界面或者登陆命令行界面后使用startx启动图形, DISPLAY环境变量将自动设置为:0:0, 此时可以打开终端, 输出图形程序的名称(比如xclock)来启动程序, 图形将显示在本地窗口上, 在终端上输入printenv查看当前环境变量, 输出结果中有如下内容:DISPLAY=:0.0
    
                                
    • 
                                
  • 获取B/S客户端IP
                                    周凡杨
java编程jspWeb浏览器
                                    
       最近想写个B/S架构的聊天系统，因为以前做过C/S架构的QQ聊天系统，所以对于Socket通信编程只是一个巩固。对于C/S架构的聊天系统，由于存在客户端Java应用，所以直接在代码中获取客户端的IP，应用的方法为： 
   String ip = InetAddress.getLocalHost().getHostAddress(); 
然而对于WEB
    
                                
    • 
                                
  • 浅谈类和对象
                                    朱辉辉33
编程
                                    
        类是对一类事物的总称，对象是描述一个物体的特征，类是对象的抽象。简单来说，类是抽象的，不占用内存，对象是具体的， 
占用存储空间。 
    类是由属性和方法构成的，基本格式是public  class 类名{ 
 
 //定义属性 
 private/public 数据类型 属性名； 
 
 //定义方法 
 publ
    
                                
    • 
                                
  • android activity与viewpager+fragment的生命周期问题
                                    肆无忌惮_
viewpager
                                    
    有一个Activity里面是ViewPager，ViewPager里面放了两个Fragment。 
第一次进入这个Activity。开启了服务，并在onResume方法中绑定服务后，对Service进行了一定的初始化，其中调用了Fragment中的一个属性。 
		super.onResume();
		bindService(intent, conn, BIND_AUTO_CREATE);

    
                                
    • 
                                
  • base64Encode对图片进行编码
                                    843977358
base64图片encoder
                                    
    /**
	 * 对图片进行base64encoder编码
	 * 
	 * @author mrZhang
	 * @param path
	 * @return
	 */
	public static String encodeImage(String path) {
		BASE64Encoder encoder = null;
		byte[] b = null;
		I
    
                                
    • 
                                
  • Request Header简介
                                    aigo
servlet
                                    
    当一个客户端(通常是浏览器)向Web服务器发送一个请求是，它要发送一个请求的命令行，一般是GET或POST命令，当发送POST命令时，它还必须向服务器发送一个叫“Content-Length”的请求头(Request   Header)   用以指明请求数据的长度，除了Content-Length之外，它还可以向服务器发送其它一些Headers，如：    
    
                                
    • 
                                
  • HttpClient4.3 创建SSL协议的HttpClient对象
                                    alleni123
httpclient爬虫ssl
                                    
    public class HttpClientUtils
{
	public static CloseableHttpClient createSSLClientDefault(CookieStore cookies){
		SSLContext sslContext=null;
		
		try
		{
			sslContext=new SSLContextBuilder().l
    
                                
    • 
                                
  • java取反 -右移-左移-无符号右移的探讨
                                    百合不是茶
位运算符 位移
                                    
    取反：
		在二进制中第一位，1表示符数，0表示正数
		byte a = -1;
		原码：10000001
		反码：11111110
		补码：11111111
      //异或: 00000000
		byte b = -2;
		原码：10000010
		反码：11111101
		补码：11111110
      //异或: 00000001
		
	
    
                                
    • 
                                
  • java多线程join的作用与用法
                                    bijian1013
java多线程
                                    
            对于JAVA的join，JDK 是这样说的：join public final void join （long millis ）throws InterruptedException Waits at most millis milliseconds for this thread to die. A timeout of 0 means t
    
                                
    • 
                                
  • Java发送http请求(get 与post方法请求)
                                    bijian1013
javaspring
                                    
    PostRequest.java 
package com.bijian.study;

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURL
    
                                
    • 
                                
  • 【Struts2二】struts.xml中package下的action配置项默认值
                                    bit1129
struts.xml
                                    
    在第一部份，定义了struts.xml文件，如下所示： 
  
<!DOCTYPE struts PUBLIC
        "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
        "http://struts.apache.org/dtds/struts
    
                                
    • 
                                
  • 【Kafka十三】Kafka Simple Consumer
                                    bit1129
simple
                                    
    代码中关于Host和Port是割裂开的，这会导致单机环境下的伪分布式Kafka集群环境下，这个例子没法运行。 
实际情况是需要将host和port绑定到一起， 
  
package kafka.examples.lowlevel;

import kafka.api.FetchRequest;
import kafka.api.FetchRequestBuilder;
impo
    
                                
    • 
                                
  • nodejs学习api
                                    ronin47
nodejs api
                                    
    NodeJS基础 什么是NodeJS 
JS是脚本语言，脚本语言都需要一个解析器才能运行。对于写在HTML页面里的JS，浏览器充当了解析器的角色。而对于需要独立运行的JS，NodeJS就是一个解析器。 
每一种解析器都是一个运行环境，不但允许JS定义各种数据结构，进行各种计算，还允许JS使用运行环境提供的内置对象和方法做一些事情。例如运行在浏览器中的JS的用途是操作DOM，浏览器就提供了docum
    
                                
    • 
                                
  • java-64.寻找第N个丑数
                                    bylijinnan
java
                                    
    


public class UglyNumber {

	/**
	 * 64.查找第N个丑数
具体思路可参考 [url] http://zhedahht.blog.163.com/blog/static/2541117420094245366965/[/url]
	 * 
题目：我们把只包含因子
2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14
    
                                
    • 
                                
  • 二维数组（矩阵）对角线输出
                                    bylijinnan
二维数组
                                    
    

/**
二维数组 对角线输出 两个方向
例如对于数组：
{ 1, 2, 3, 4 }, 
{ 5, 6, 7, 8 },
{ 9, 10, 11, 12 }, 
{ 13, 14, 15, 16 },

slash方向输出：
1 
5 2 
9 6 3 
13 10 7 4 
14 11 8 
15 12 
16 

backslash输出：
4 
3
    
                                
    • 
                                
  • [JWFD开源工作流设计]工作流跳跃模式开发关键点(今日更新)
                                    comsci
工作流
                                    
       既然是做开源软件的,我们的宗旨就是给大家分享设计和代码,那么现在我就用很简单扼要的语言来透露这个跳跃模式的设计原理 
 
   大家如果用过JWFD的ARC-自动运行控制器,或者看过代码,应该知道在ARC算法模块中有一个函数叫做SAN(),这个函数就是ARC的核心控制器,要实现跳跃模式,在SAN函数中一定要对LN链表数据结构进行操作,首先写一段代码,把
    
                                
    • 
                                
  • redis常见使用
                                    cuityang
redis常见使用
                                    
    redis 通常被认为是一个数据结构服务器，主要是因为其有着丰富的数据结构 strings、map、 list、sets、 sorted sets 
 
引入jar包 jedis-2.1.0.jar  (本文下方提供下载) 
 
package redistest; 
 
import redis.clients.jedis.Jedis; 
 
public class Listtest
    
                                
    • 
                                
  • 配置多个redis
                                    dalan_123
redis
                                    
    配置多个redis客户端 
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi=&quo
    
                                
    • 
                                
  • attrib命令
                                    dcj3sjt126com
attr
                                    
         
attrib指令用于修改文件的属性.文件的常见属性有:只读.存档.隐藏和系统.      
  只读属性是指文件只可以做读的操作.不能对文件进行写的操作.就是文件的写保护.  
 
  存档属性是用来标记文件改动的.即在上一次备份后文件有所改动.一些备份软件在备份的时候会只去备份带有存档属性的文件.  
 
    
                                
    • 
                                
  • Yii使用公共函数
                                    dcj3sjt126com
yii
                                    
    在网站项目中，没必要把公用的函数写成一个工具类，有时候面向过程其实更方便。   在入口文件index.php里添加   require_once('protected/function.php');   即可对其引用，成为公用的函数集合。   function.php如下：   
   <?php   /**     * This is the shortcut to D
    
                                
    • 
                                
  • linux 系统资源的查看（free、uname、uptime、netstat）
                                    eksliang
netstatlinux unamelinux uptimelinux free
                                    
    linux 系统资源的查看 
转载请出自出处：http://eksliang.iteye.com/blog/2167081 
  
http://eksliang.iteye.com 一、free查看内存的使用情况 
语法如下： 
  
free [-b][-k][-m][-g] [-t]
参数含义
-b:直接输入free时，显示的单位是kb我们可以使用b(bytes),m
    
                                
    • 
                                
  • JAVA的位操作符
                                    greemranqq
位运算JAVA位移<<>>>
                                    
    最近几种进制，加上各种位操作符，发现都比较模糊，不能完全掌握，这里就再熟悉熟悉。 
  
1.按位操作符 ： 
   按位操作符是用来操作基本数据类型中的单个bit,即二进制位，会对两个参数执行布尔代数运算，获得结果。 
   与（&）运算： 
   1&1 = 1, 1&0 = 0, 0&0 &
    
                                
    • 
                                
  • Web前段学习网站
                                    ihuning
Web
                                    
      
Web前段学习网站 
菜鸟学习：http://www.w3cschool.cc/ 
  
JQuery中文网：http://www.jquerycn.cn/ 
  
内存溢出：http://outofmemory.cn/#csdn.blog 
  
http://www.icoolxue.com/ 
  
http://www.jikexue
    
                                
    • 
                                
  • 强强联合：FluxBB 作者加盟 Flarum
                                    justjavac
r
                                    
    原文：FluxBB Joins Forces With Flarum作者：Toby Zerner译文：强强联合：FluxBB 作者加盟 Flarum译者：justjavac  
FluxBB 是一个快速、轻量级论坛软件，它的开发者是一名德国的 PHP 天才 Franz Liedke。FluxBB 的下一个版本(2.0)将被完全重写，并已经开发了一段时间。FluxBB 看起来非常有前途的，
    
                                
    • 
                                
  • java统计在线人数（session存储信息的）
                                    macroli
javaWeb
                                    
    这篇日志是我写的第三次了 前两次都发布失败！郁闷极了！ 
  
由于在web开发中常常用到这一部分所以在此记录一下，呵呵，就到备忘录了！ 
我对于登录信息时使用session存储的，所以我这里是通过实现HttpSessionAttributeListener这个接口完成的。 
1、实现接口类，在web.xml文件中配置监听类，从而可以使该类完成其工作。 
public class Ses
    
                                
    • 
                                
  • bootstrp carousel初体验 快速构建图片播放
                                    qiaolevip
每天进步一点点学习永无止境bootstrap纵观千象
                                    
    img{
			border: 1px solid white;
			box-shadow: 2px 2px 12px #333;
			_width: expression(this.width > 600 ? "600px" : this.width + "px");
			_height: expression(this.width &
    
                                
    • 
                                
  • SparkSQL读取HBase数据，通过自定义外部数据源
                                    superlxw1234
sparksparksqlsparksql读取hbasesparksql外部数据源
                                    
    关键字：SparkSQL读取HBase、SparkSQL自定义外部数据源 
  
  
前面文章介绍了SparSQL通过Hive操作HBase表。 
  
SparkSQL从1.2开始支持自定义外部数据源(External DataSource)，这样就可以通过API接口来实现自己的外部数据源。这里基于Spark1.4.0，简单介绍SparkSQL自定义外部数据源，访
    
                                
    • 
                                
  • Spring Boot 1.3.0.M1发布
                                    wiselyman
spring boot
                                    
        Spring Boot 1.3.0.M1于6.12日发布，现在可以从Spring milestone repository下载。这个版本是基于Spring Framework 4.2.0.RC1,并在Spring Boot 1.2之上提供了大量的新特性improvements and new features。主要包含以下： 
  
1.提供一个新的sprin
    
                                
    •