piaoslowly
piaoslowly

java集合-WeakHashMap(五)

Date: 2017-01-14 10:10:12

java集合-WeakHashMap与ThreadLocal(五)

前面两篇文章《HashMap源码分析》，《Java基础-强，弱，软引用》已经把WeakHashMap用到的技术都讲完了。这篇文章也就没啥好讲的了。

WeakHashMap就是一个HashMap，只不过它的key继承了WeakReference表示key是一个弱引用，在GC时就会被回收。就这么简单。

WeakHashMap定义（转载）

  • WeakHashMap 继承于AbstractMap，实现了Map接口。
  • 和HashMap一样，WeakHashMap 也是一个散列表，它存储的内容也是键值对(key-value)映射，而且键和值都可以是null。
  • 不过WeakHashMap的键是“弱键”。在 WeakHashMap 中，当系统发起GC后，key就会被回收了。更精确地说，对于一个给定的键，其映射的存在并不阻止垃圾回收器对该键的丢弃，这就使该键成为可终止的，被终止，然后被回收。某个键被终止时，它对应的键值对也就从映射中有效地移除了。

实现步骤：

  1. 新建WeakHashMap，将“键值对”添加到WeakHashMap中。
    实际上，WeakHashMap是通过数组table保存Entry(键值对)；每一个Entry实际上是一个单向链表，即Entry是键值对链表。
  2. 当某“弱键”不再被其它对象引用，并被GC回收时。在GC回收该“弱键”时，这个“弱键”也同时会被添加到ReferenceQueue(queue)队列中。
  3. 当下一次我们需要操作WeakHashMap时，会先同步table和queue。table中保存了全部的键值对，而queue中保存被GC回收的键值对；同步它们，就是删除table中被GC回收的键值对。
    这就是“弱键”如何被自动从WeakHashMap中删除的步骤了。

源码分析

Entry的定义

//Entry里面没看到K的定义哦，跑哪里去了？
private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V> {
        V value;
        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;
        }
}

key跑哪里去了？
看super(key,queue);
 |
 |  
 V
--------------- 
WeakReference.java里面哦。  
public WeakReference(T referent) {
        super(referent);
    }
看super(referent);    
---------------
 |
 |  
 V  
---------------
Reference.java里面哦。   
private T referent;    
Reference(T referent) {
        this(referent, null);
    }
-----------------     
  
解说：可以看到key直接被定义为弱引用了。 
 定义为弱引用之后，GC就可以随意回收它了。呵呵
 
  
expungeStaleEntries的定义
 
  
expungeStaleEntries监控queue队列，当key被回收时，queue里面会接受到GC发送过来的回收消息，expungeStaleEntries这个监控到queue不为空时，就把对应的value也置为空，这样value也就可以被回收了。
 
  
WeakHashMap和HashMap基本一样，所以不细看其他部分的源码，主要是这个expungeStaleEntries方法里面。
 
  
//WeakHashMap里面定义了一个成员变量queue，GC在回收key之后会发送通知，key被回收了。发送的通知会放到queue。
private final ReferenceQueue queue = new ReferenceQueue<>();

//这个方法是干什么的呢？
//我们上面说了key是弱引用，但是value是强引用啊，所以这个方法的作用是回收value。
//如果key被回收了，则将value=null，这样就可以让GC把value也回收了。
private void expungeStaleEntries() {
        //queue里面的数据时GC主动往里面添加的，所以在WeakHashMap代码里面我们是看不到queue的赋值的。
        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;
                }
            }
        }
    } 
  
在《java基础-强，软，弱引用》中我们讲了弱引用的相关信息，但是别和这里的混淆哦，所以这里在讲解一下。 
 private static WeakHashMap
 
  
实战分析一下GC回收
 
  
vm参数：-verbose:gc -Xms20M -Xms20M -Xmn10M -XX:SoftRefLRUPolicyMSPerMB=0 -XX:+PrintGCDetails -XX:SurvivorRatio=8 
 堆内存大小20M，年轻带堆内存10M。
 
  
 
  
在未执行到 byte[] a = new byte[1024 * 1024 * 2]这里的时候，堆内存还有足够空间，没有做回收操作， 
 当执行了 byte[] a = new byte[1024 * 1024 * 2]后 
 开始触发GC垃圾回收了，由于内存严重不够，所以连同触发了FULL GC。 
 回收后，对内存里面还剩下eden space 8192K, 27% used 
 什么问题，因为a引用的对象没有被回收，a是一个强引用。
 
  
图中为什我要在a前后都获取一次呢？为了测试value有没有被回收掉。 
 在WeakHashMap中，不管是get，还是put，还是size，几乎所有操作都会先去调用一下expungeStaleEntries这个方法，先把被GC回收掉的key从WeakHashMap中移除，同时把key所对应的value置为null帮助GC回收。
 
  
java集合-WeakHashMap(五)_第1张图片
 
  
在图中，先添加了8M的对象在caches，并没有出发GC回收，当执行a对象时才触发GC操作，GC也只是回收key，而并不会主动回收value，那么问题来了，我并没有调用get，put，size操作啊，按道理是不会执行WeakHashMap里面的expungeStaleEntries这个方法的，因为只有操作了put，get等操作时才会进入expungeStaleEntries这个方法。但是打印出来的heap(堆）信息确告诉我，value也被回收了，那只能说明GC去调用了exp这个方法了。
 
  
上面图中，我故意使用两组做测试，第一组在GC后不做任何操作，第二组GC后，调用一下WeakHashMap个get操作，就是让他主动出发一下expungeStaleEntries，这样做就会让GC把value也回收了，但是两组对比后发现堆里面的大小是一样的，从而证明了GC回收key之后会调用一次exp这个方法。
 
  
为什么我要做这个对比呢？因为ThreadLocal这个类，它的操作和WeakHashMap是很相像的，但是ThreadLocal需要主动去清理value的。 
 key是弱引用，GC会帮我回收它，但是value确一直存在着，这就会导致内存泄漏了。
 
  
ThreadLocal
 
  
首先，ThreadLocal 不是用来解决共享对象的多线程访问问题的，一般情况下，通过ThreadLocal.set() 到线程中的对象是该线程自己使用的对象，其他线程是不需要访问的，也访问不到的。各个线程中访问的是不同的对象。 
 另外，说ThreadLocal使得各线程能够保持各自独立的一个对象，并不是通过ThreadLocal.set()来实现的，而是通过每个线程中的new 对象 的操作来创建的对象，每个线程创建一个，不是什么对象的拷贝或副本。通过ThreadLocal.set()将这个新创建的对象的引用保存到各线程的自己的一个map中，每个线程都有这样一个map，执行ThreadLocal.get()时，各线程从自己的map中取出放进去的对象，因此取出来的是各自自己线程中的对象，ThreadLocal实例是作为map的key来使用的。
 
  
查看ThreadLocal源码：在Thread类中保有ThreadLocal.ThreadLocalMap的引用，即在一个Java线程栈中指向了堆内存中的一个ThreadLocal.ThreadLocalMap的对象，此对象中保存了若干个Entry，每个Entry的key(ThreadLocal实例)是弱引用，value是强引用（这点类似于WeakHashMap）。用到弱引用的只是key，每个key都弱引用指向threadLocal，当把threadLocal实例置为null以后，没有任何强引用指向threadLocal实例，所以threadLocal将会被gc回收，但是value却不能被回收，因为其还存在于ThreadLocal.ThreadLocalMap的对象的Entry之中。只有当前Thread结束之后，所有与当前线程有关的资源才会被GC回收。所以，如果在线程池中使用ThreadLocal，由于线程会复用，而又没有显示的调用remove的话的确是会有可能发生内存泄露的问题。
 
  
其实在ThreadLocal.ThreadLocalMap的get或者set方法中会探测其中的key是否被回收（调用expungeStaleEntry方法），然后将其value设置为null，这个功能几乎和WeakHashMap中的expungeStaleEntries()方法一样。因此value在key被gc后可能还会存活一段时间，但最终也会被回收，但是若不再调用get或者set方法时，那么这个value就在线程存活期间无法被释放。
 
  
ThreadLocal的key也是弱引用，为什么它的value会导致内存泄漏呢？
 
  
来看两组数据 
 设置堆栈大小：-verbose:gc -Xmx20M -Xms20M -Xmn10M -XX:SoftRefLRUPolicyMSPerMB=0 -XX:+PrintGCDetails -XX:SurvivorRatio=8
 
  
对照组WeakHashMap
 
  
public class ThreadLockDome {
    private static class ThreadMap implements Runnable {
        private WeakHashMapbyte[]> a = new WeakHashMapbyte[]>();
        public void run() {
            try {
                a.put(Thread.currentThread().getName(),new byte[1024 * 1024 * 3]);
                TimeUnit.SECONDS.sleep(3);
                if(a.get(Thread.currentThread().getName())!=null){
                    System.out.println("a==11111");
                }else{
                    System.out.println("a=====null null");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 5; i++) {
            ThreadMap map = new ThreadMap();
            Thread t = new Thread(map);
            t.start();
        }
        Thread.sleep(5000);
        byte[] c = new byte[1024 * 1024 * 2];
        System.out.println("---c---");
    }
}
输出日志：
[GC [PSYoungGen: 7799K->432K(9216K)] 7799K->6576K(19456K), 0.0071480 secs] [Times: user=0.00 sys=0.01, real=0.01 secs] 
[Full GC [PSYoungGen: 432K->0K(9216K)] [ParOldGen: 6144K->6446K(10240K)] 6576K->6446K(19456K) [PSPermGen: 2848K->2847K(21504K)], 0.0135840 secs] [Times: user=0.02 sys=0.00, real=0.01 secs] 
[Full GC [PSYoungGen: 6774K->3073K(9216K)] [ParOldGen: 6446K->9508K(10240K)] 13220K->12581K(19456K) [PSPermGen: 2855K->2855K(21504K)], 0.0080190 secs] [Times: user=0.01 sys=0.00, real=0.00 secs] 
a==11111
a=====null null
a==11111
a==11111
a=====null null
[Full GC [PSYoungGen: 6554K->0K(9216K)] [ParOldGen: 9508K->303K(10240K)] 16062K->303K(19456K) [PSPermGen: 3039K->3039K(21504K)], 0.0098200 secs] [Times: user=0.02 sys=0.00, real=0.01 secs] 
---a---
Heap
 PSYoungGen      total 9216K, used 2148K [0x00000007ff600000, 0x0000000800000000, 0x0000000800000000)
  eden space 8192K, 26% used [0x00000007ff600000,0x00000007ff8192c8,0x00000007ffe00000)
  from space 1024K, 0% used [0x00000007ffe00000,0x00000007ffe00000,0x00000007fff00000)
  to   space 1024K, 0% used [0x00000007fff00000,0x00000007fff00000,0x0000000800000000)
 ParOldGen       total 10240K, used 303K [0x00000007fec00000, 0x00000007ff600000, 0x00000007ff600000)
  object space 10240K, 2% used [0x00000007fec00000,0x00000007fec4bf28,0x00000007ff600000)
 PSPermGen       total 21504K, used 3046K [0x00000007f9a00000, 0x00000007faf00000, 0x00000007fec00000)
  object space 21504K, 14% used [0x00000007f9a00000,0x00000007f9cf9b58,0x00000007faf00000)
 
  
可以看到我开启了5个线程，每个线程里面存储了3M的数据。 
 a.put(Thread.currentThread().getName(),new byte[1024 * 1024 * 3]); 
 注意这里TimeUnit.SECONDS.sleep(3); 
 我让每个线程停留3秒种，如果不停留线程执行太快，线程执行完毕后就会立即释放内存，也就可能看不出3*5=15M内存的情况了。 
 当5个线程都执行到a.put的时候，它们接下来都需要等待3秒钟，也就是说占用的内存不会立即释放了，它们现在占用的内存为3*5=15M哦。 
 GC看到a是一个弱引用，发生GC时就会直接回收它，所以我们看到本来应该是5个a====1111，现在的结果是有两个a==null null。 
 说明被回收了。 
 接下来c又存入了2M的对象在堆里面，也没问题了，前面有部分堆内存被回收了，现在有足够的内存来容纳c了。
 
  
上面的日志不一定哦，因为是多线程，也有可能WeakHashMap里面还没回收呢就执行到了 
 byte[] c = new byte[1024 * 1024 * 2];就会导致c对象内存溢出，也就是主线程内存溢出。
 
  
把a里面put入4M的对象。 
 a.put(Thread.currentThread().getName(),new byte[1024 * 1024 * 4]);
 
  
结果：
[GC-- [PSYoungGen: 5915K->5915K(9216K)] 14107K->14107K(19456K), 0.0017590 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
[Full GC [PSYoungGen: 5915K->4404K(9216K)] [ParOldGen: 8192K->8192K(10240K)] 14107K->12596K(19456K) [PSPermGen: 2956K->2955K(21504K)], 0.0136470 secs] [Times: user=0.02 sys=0.01, real=0.01 secs] 
[GC-- [PSYoungGen: 4404K->4404K(9216K)] 12596K->12596K(19456K), 0.0015570 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC [PSYoungGen: 4404K->4404K(9216K)] [ParOldGen: 8192K->8192K(10240K)] 12596K->12596K(19456K) [PSPermGen: 2955K->2955K(21504K)], 0.0070020 secs] [Times: user=0.02 sys=0.00, real=0.01 secs] 
[GCException in thread "Thread-3" -- [PSYoungGen: 4652K->4652K(9216K)] 12844K->12844K(19456K), 0.0019940 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC [PSYoungGen: 4652K->4404K(9216K)] [ParOldGen: 8192K->8192K(10240K)] 12844K->12596K(19456K) [PSPermGen: 2955K->2955K(21504K)], 0.0089340 secs] [Times: user=0.01 sys=0.00, real=0.01 secs] 
[GC-- [PSYoungGen: 4404K->4404K(9216K)] 12596K->12596K(19456K), 0.0018320 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC [PSYoungGen: 4404K->4404K(9216K)] [ParOldGen: 8192K->8192K(10240K)] 12596K->12596K(19456K) [PSPermGen: 2955K->2955K(21504K)], 0.0090810 secs] [Times: user=0.01 sys=0.00, real=0.01 secs] 
Exception in thread "Thread-4" java.lang.OutOfMemoryError: Java heap space
    at cn.collection.ThreadLockDome$ThreadMap.run(ThreadLockDome.java:33)
    at java.lang.Thread.run(Thread.java:745)
java.lang.OutOfMemoryError: Java heap space
    at cn.collection.ThreadLockDome$ThreadMap.run(ThreadLockDome.java:33)
    at java.lang.Thread.run(Thread.java:745)
a=====null null
a=====null null
a=====null null
---c---
Heap
 PSYoungGen      total 9216K, used 7162K [0x00000007ff600000, 0x0000000800000000, 0x0000000800000000)
  eden space 8192K, 87% used [0x00000007ff600000,0x00000007ffcfe940,0x00000007ffe00000)
  from space 1024K, 0% used [0x00000007fff00000,0x00000007fff00000,0x0000000800000000)
  to   space 1024K, 0% used [0x00000007ffe00000,0x00000007ffe00000,0x00000007fff00000)
 ParOldGen       total 10240K, used 8192K [0x00000007fec00000, 0x00000007ff600000, 0x00000007ff600000)
  object space 10240K, 80% used [0x00000007fec00000,0x00000007ff400020,0x00000007ff600000)
 PSPermGen       total 21504K, used 3071K [0x00000007f9a00000, 0x00000007faf00000, 0x00000007fec00000)
  object space 21504K, 14% used [0x00000007f9a00000,0x00000007f9cffd80,0x00000007faf00000)
 
  
三个a被回收了，另外两个a在回收时直接抛出了堆栈溢出了。
 
  
实验组ThreadLocal：
 
  
public class ThreadLockDome {
    private static class ThreadMap implements Runnable {
        private ThreadLocal<byte[]> b = new ThreadLocal<byte[]>();

        public void run() {
            try {
                b.set(new byte[1024 * 1024 * 3]);
                TimeUnit.SECONDS.sleep(3);
                if (b.get() != null) {
                    System.out.println(Thread.currentThread().getName()+"=====111111");
                } else {
                    System.out.println(Thread.currentThread().getName()+"====null null null");
                } 
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ThreadMap map = new ThreadMap();
        for (int i = 0; i < 5; i++) {
            Thread t = new Thread(map);
            t.start();
        }
        Thread.sleep(5000);
        byte[] c = new byte[1024 * 1024 * 2];
        System.out.println("---c---");
    }
}
输出结果：
[GC [PSYoungGen: 7635K->416K(9216K)] 7635K->6560K(19456K), 0.0040800 secs] [Times: user=0.01 sys=0.01, real=0.01 secs] 
[Full GC [PSYoungGen: 416K->0K(9216K)] [ParOldGen: 6144K->6445K(10240K)] 6560K->6445K(19456K) [PSPermGen: 2849K->2848K(21504K)], 0.0132550 secs] [Times: user=0.01 sys=0.00, real=0.01 secs] 
[Full GC [PSYoungGen: 6624K->3073K(9216K)] [ParOldGen: 6445K->9507K(10240K)] 13069K->12580K(19456K) [PSPermGen: 2855K->2855K(21504K)], 0.0067770 secs] [Times: user=0.01 sys=0.00, real=0.01 secs] 
Thread-2=====111111
Thread-4=====111111
Thread-3=====111111
Thread-1=====111111
Thread-0=====111111
[Full GC [PSYoungGen: 6612K->0K(9216K)] [ParOldGen: 9507K->303K(10240K)] 16120K->303K(19456K) [PSPermGen: 3040K->3040K(21504K)], 0.0070590 secs] [Times: user=0.01 sys=0.00, real=0.01 secs] 
---c---
Heap
 PSYoungGen      total 9216K, used 2162K [0x00000007ff600000, 0x0000000800000000, 0x0000000800000000)
  eden space 8192K, 26% used [0x00000007ff600000,0x00000007ff81c9f8,0x00000007ffe00000)
  from space 1024K, 0% used [0x00000007ffe00000,0x00000007ffe00000,0x00000007fff00000)
  to   space 1024K, 0% used [0x00000007fff00000,0x00000007fff00000,0x0000000800000000)
 ParOldGen       total 10240K, used 303K [0x00000007fec00000, 0x00000007ff600000, 0x00000007ff600000)
  object space 10240K, 2% used [0x00000007fec00000,0x00000007fec4bfa0,0x00000007ff600000)
 PSPermGen       total 21504K, used 3047K [0x00000007f9a00000, 0x00000007faf00000, 0x00000007fec00000)
  object space 21504K, 14% used [0x00000007f9a00000,0x00000007f9cf9c38,0x00000007faf00000)
 
  
从日志可以看到虽然发生了GC和Full GC，但是ThreadLocal里面并没有被回收了，5个线程的值都不为null。
 
  
这句：[Full GC [PSYoungGen: 6612K->0K(9216K)]说明什么，当线程执行完毕后，内存就立马释放了。
 
  
改为4M后：
 
  
[GC-- [PSYoungGen: 5423K->5423K(9216K)] 13615K->13615K(19456K), 0.0039000 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
[Full GC [PSYoungGen: 5423K->4395K(9216K)] [ParOldGen: 8192K->8192K(10240K)] 13615K->12587K(19456K) [PSPermGen: 2811K->2810K(21504K)], 0.0163100 secs] [Times: user=0.02 sys=0.01, real=0.01 secs] 
[GC-- [PSYoungGen: 4395K->4395K(9216K)] 12587K->12587K(19456K), 0.0018300 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GCException in thread "Thread-3"  [PSYoungGen: 4395K->4395K(9216K)] [ParOldGen: 8192K->8192K(10240K)] 12587K->12587K(19456K) [PSPermGen: 2810K->2810K(21504K)], 0.0077320 secs] [Times: user=0.01 sys=0.00, real=0.01 secs] 
[GC-- [PSYoungGen: 5056K->5056K(9216K)] 13248K->13248K(19456K), 0.0020430 secs] [Times: user=0.01 sys=0.00, real=0.01 secs] 
[Full GC [PSYoungGen: 5056K->4387K(9216K)] [ParOldGen: 8192K->8192K(10240K)] 13248K->12579K(19456K) [PSPermGen: 2817K->2817K(21504K)], 0.0125060 secs] [Times: user=0.01 sys=0.00, real=0.01 secs] 
[GC-- [PSYoungGen: 4387K->4387K(9216K)] 12579K->12579K(19456K), 0.0014050 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC [PSYoungGen: 4387K->4387K(9216K)] [ParOldGen: 8192K->8192K(10240K)] 12579K->12579K(19456K) [PSPermGen: 2817K->2817K(21504K)], 0.0182230 secs] [Times: user=0.01 sys=0.00, real=0.02 secs] 
Exception in thread "Thread-4" java.lang.OutOfMemoryError: Java heap space
    at cn.collection.ThreadLockDome$ThreadMap.run(ThreadLockDome.java:24)
    at java.lang.Thread.run(Thread.java:745)
java.lang.OutOfMemoryError: Java heap space
    at cn.collection.ThreadLockDome$ThreadMap.run(ThreadLockDome.java:24)
    at java.lang.Thread.run(Thread.java:745)
Thread-2=====111111
Thread-0=====111111
Thread-1=====111111
---c---
Heap
 PSYoungGen      total 9216K, used 7198K [0x00000007ff600000, 0x0000000800000000, 0x0000000800000000)
  eden space 8192K, 87% used [0x00000007ff600000,0x00000007ffd07928,0x00000007ffe00000)
  from space 1024K, 0% used [0x00000007fff00000,0x00000007fff00000,0x0000000800000000)
  to   space 1024K, 0% used [0x00000007ffe00000,0x00000007ffe00000,0x00000007fff00000)
 ParOldGen       total 10240K, used 8192K [0x00000007fec00000, 0x00000007ff600000, 0x00000007ff600000)
  object space 10240K, 80% used [0x00000007fec00000,0x00000007ff400020,0x00000007ff600000)
 PSPermGen       total 21504K, used 3071K [0x00000007f9a00000, 0x00000007faf00000, 0x00000007fec00000)
  object space 21504K, 14% used [0x00000007f9a00000,0x00000007f9cffe78,0x00000007faf00000)
 
  
可以看到前3个线程 
 Thread-2=====111111 
 Thread-0=====111111 
 Thread-1=====111111 
 没有被GC回收，导致后了后2个进来后就直接抛堆空间异常了。 
 这行日志“—c—”之所以能打印出来，就是因为5个线程执行结束后内存直接回收了，所以这样c在创建2M大小的对象时也是没有问题的。
 
  
总结：
 
  
可以看到WeakHashMap的key是弱引用，ThreadLocal的key也是用的弱引用，但是WeakHashMap在被GC回收时value也会被回收了，而ThreadLocal则不会，ThreadLocal必须显示的调用一下remove方法才能将value的值给清空。 
 在两个的源码中可以看到，ThreadLocal里面并没有一个接受对象被GC回收后通知的ReferenceQueue，所以就算key被回收了，value也是存在的，并不会和WeakHashMap一样，在key被清空后，可以使用ReferenceQueue这个队列接受被GC的通知，然后把value也自己给清空。
 
  
ThreadLocal源码分析
 
  
讲完了上面的再来讲源码终于明白了ThreadLocal的原理和他是用来干嘛的了，之前一直半懂半不懂的。
 
  
set方法
 
  
public void set(T value) {
        //看到了吗？t是个当前线程，不懂Thread.currentThread这个的可以去看看，不然真不能理解ThreadLocal
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

//获取当前线程的ThreadLocalMap，要知道“每个线程“里面都有一个ThreadLocalMap哦！ 
ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
}

//如果ThreadLocalMap这个为null则创建一个
void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
}

//如果ThreadLocalMap这个已经存在了，则往里面添加值ThreadLocalMap就像一个WeakHashMap
private void set(ThreadLocal key, Object value) {

            Entry[] tab = table;
            int len = tab.length;
            int i = key.threadLocalHashCode & (len-1);

            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                ThreadLocal k = e.get();

                if (k == key) {
                    e.value = value;
                    return;
                }

                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }

            tab[i] = new Entry(key, value);
            int sz = ++size;
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }

//可以看到key为弱引用哦，可以参看WeakHashMap观看哦！
static class Entry extends WeakReference {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal k, Object v) {
                super(k);
                value = v;
            }
        }        
 
  
TheadLocal就像一个SetHashMap， 
 ThreadLocalMap就像一个WeakHashMap。
 
  
SetHashMap是利用HashMap的key来做去重的，HashMap的key虽然可以重复，但是后进来的会覆盖先进来的， 
 put(1,”2”); 
 put(1,”3”); 
 最后存入的是put(1,”3”); 
 put(1,”2”)会被覆盖， 
 这样SetHashMap就利用key来做去重。set(1),set(1)最后遍历的时候只会有一个set(1).
 
  
ThreadLocal存数据也是set(1).他和setHashMap正好反着来。使用value做value，那么key呢？key使用的是this，表示当前线程的ThreadLocal。
 
  
接着最上面的实例分析：
 
  

private static class ThreadMap implements Runnable {
         private WeakHashMapbyte[]> a = new WeakHashMapbyte[]>();
        private ThreadLocal<byte[]> b = new ThreadLocal<byte[]>();

        public void run() {
            try {
                b.set(new byte[1024 * 1024 * 1]);
                a.put("1",new byte[1024 * 1024 * 1]);
                TimeUnit.SECONDS.sleep(3);
                if (b.get() != null) {
                    System.out.println(Thread.currentThread().getName()+"=====111111");
                } else {
                    System.out.println(Thread.currentThread().getName()+"====null null null");
                } 
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
}


public static void main(String[] args) throws InterruptedException {
        ThreadMap map = new ThreadMap();
        for (int i = 0; i < 5; i++) {
            Thread t = new Thread(map);
            t.start();
        }
        Thread.sleep(5000);
        byte[] c = new byte[1024 * 1024 * 2];
        System.out.println("---c---");
    }
 
  
分析： 
 先来看ThreadMap这个类里面有两个成员变量，a，b，他们有什么区别呢？ 
 b.set(new byte[1024 * 1024 * 1]); 
 a.put(“1”,new byte[1024 * 1024 * 1]);
 
  
先是5个线程拥有同一个对象map。 
 java集合-WeakHashMap(五)_第2张图片 
 为什么b是一个公共变量，存入的数据却是每个线程独立拥有的呢？ 
 就看源码了呗！
 
  
public void set(T value) {
        //看到了吗？t是个当前线程，不懂Thread.currentThread这个的可以去看看，不然真不能理解ThreadLocal
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
}

void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
}
 
  
Thread.currentThread();看到这个了嘛，这个表示当前线程，只和线程有关。 
 Thread t = new Thread(map);这里new了5个线程，那么就有5个Thread.currentThread();
 
  
来，我们尝试一下改变WeakHashMap变的和ThreadLocal差不多的功能。 
 a.put(Thread.currentThread().getName(),new byte[1024 * 1024 * 1]); 
 这样就OK了吗，每个线程进来用当前线程的名字做为key。 
 获取的时候使用a.get(Thread.currentThread().getName())就OK了啊。这样是不是更能理解ThreadLocal了。
 
  
参考地址
 
  
 
   
http://www.cnblogs.com/skywang12345/p/3311092.html 
 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Java集合源码分析)

        

            

                
    
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • JVM源码分析之堆外内存完全解读
                        HeapDump性能社区

                        
    概述广义的堆外内存说到堆外内存，那大家肯定想到堆内内存，这也是我们大家接触最多的，我们在jvm参数里通常设置-Xmx来指定我们的堆的最大值，不过这还不是我们理解的Java堆，-Xmx的值是新生代和老生代的和的最大值，我们在jvm参数里通常还会加一个参数-XX:MaxPermSize来指定持久代的最大值，那么我们认识的Java堆的最大值其实是-Xmx和-XX:MaxPermSize的总和，在分代算法
    
                    
    • 
                    
  • Golang Channel
                        PandaSkr
golang
                        
    Channel解析1.Channel源码分析1.1Channel数据结构typehchanstruct{qcountuint//channel的元素数量dataqsizuint//channel循环队列长度bufunsafe.Pointer//指向循环队列的指针elemsizeuint16//元素大小closeduint32//channel是否关闭0-未关闭elemtype*_type//元素类
    
                    
    • 
                    
  • Java集合类框架源码分析 之 RoleList源码解析 【6】
                        yunzhonghefei
Java集合类源码分析RoleList源码解析
                        
    该类继承于ArrayList，针对Role进行了一些扩展。其他方法和ArrayList中基本相同，源码不做针对性分析：看一下类简介：/***代表了一个roles的列表，作为方法setRoles()的参数，去创建一个关联关系，并且尝试在同一个关系中设置多个角色。*ARoleListrepresentsalistofroles(Roleobjects).Itisusedas*parameterwhen
    
                    
    • 
                    
  • 【鸿蒙OH-v5.0源码分析之 Linux Kernel 部分】004 - Kernel 启动引导代码head.S 源码逐行分析
                        "小夜猫&小懒虫&小财迷"的男人
鸿蒙OH-v5.0源码分析之Uboot+Kernel部分harmonyoslinux华为
                        
    【鸿蒙OH-v5.0源码分析之LinuxKernel部分】004-Kernel启动引导代码head.S源码逐行分析系列文章汇总：《鸿蒙OH-v5.0源码分析之Uboot+Kernel部分】000-文章链接汇总》本文链接：《【鸿蒙OH-v5.0源码分析之LinuxKernel部分】004-Kernel启动引导代码head.S源码逐行分析》head.S主要工作如下：保存内核启动参数,无效化处理器缓存(
    
                    
    • 
                    
  • 互联网 Java 工程师面试题（Java 面试题四）
                        苹果酱0567
面试题汇总与解析java中间件开发语言springboot后端
                        
    下面列出这份Java面试问题列表包含的主题多线程，并发及线程基础数据类型转换的基本原则垃圾回收（GC）Java集合框架数组字符串GOF设计模式SOLID抽象类与接口Java基础，如equals和hashcode泛型与枚举JavaIO与NIO常用网络协议Java中的数据结构和算法正则表达式JVM底层Java最佳实JDBCDate,Time与CalendarJava处理XMLJUnit编程现在是时候给
    
                    
    • 
                    
  • Java高并发编程详解系列-深入理解Thread构造
                        nihui123
高并发Java高并发Java高并发
                        
    上篇分享中主要是对线程的基本概念和基本操作做了一个分享，同时提出了两种常用的创建多线程的方法，当然在后期的分享中也会提及到更多的创建线程的方式，到后期的分享的时候再说。这次主要是深入的理解一下Thread的构造函数，通过构造函数对于Thread有一个更加深入的了解。这里首先提供一个JDK1.6的ThreadAPI截图线程命名规范  从源码分析可以看到在Thread类中默认提供了线程的命名方式，这个
    
                    
    • 
                    
  • 【QT教程】QT6硬件图形界面编程 QT硬件编程
                        QT性能优化QT原理源码QT界面美化
qtqt6.3qt5c++QT教程
                        
    QT6硬件图形界面编程使用AI技术辅助生成QT界面美化视频课程QT性能优化视频课程QT原理与源码分析视频课程QTQMLC++扩展开发视频课程免费QT视频课程您可以看免费1000+个QT技术视频免费QT视频课程QT统计图和QT数据可视化视频免费看免费QT视频课程QT性能优化视频免费看免费QT视频课程QT界面美化视频免费看1QT6硬件图形界面编程概述1.1QT6硬件图形界面编程简介1.1.1QT6硬件
    
                    
    • 
                    
  • Jetpack LiveData源码分析
                        xiangxiongfly915
#AndroidJetpack系列JetpackLiveData源码分析
                        
    文章目录JetpackLiveData源码分析前提源码分析注册订阅流程LiveData#observe()LifecycleRegistry#addObserver()ObserverWithState#dispatchEvent()LiveData#removeObserver()LiveData$LifecycleBoundObserver类LifecycleBoundObserver#sho
    
                    
    • 
                    
  • ExoPlayer架构详解与源码分析（17）——TrackSelector
                        山雨楼
ExoPlayer架构android音视频ExoPlayerMedia3源码
                        
    系列文章目录ExoPlayer架构详解与源码分析（1）——前言ExoPlayer架构详解与源码分析（2）——PlayerExoPlayer架构详解与源码分析（3）——TimelineExoPlayer架构详解与源码分析（4）——整体架构ExoPlayer架构详解与源码分析（5）——MediaSourceExoPlayer架构详解与源码分析（6）——MediaPeriodExoPlayer架构详解与
    
                    
    • 
                    
  • ExoPlayer架构详解与源码分析（12）——Cache
                        山雨楼
ExoPlayer架构android音视频ExoPlayerMedia3源码
                        
    系列文章目录ExoPlayer架构详解与源码分析（1）——前言ExoPlayer架构详解与源码分析（2）——PlayerExoPlayer架构详解与源码分析（3）——TimelineExoPlayer架构详解与源码分析（4）——整体架构ExoPlayer架构详解与源码分析（5）——MediaSourceExoPlayer架构详解与源码分析（6）——MediaPeriodExoPlayer架构详解与
    
                    
    • 
                    
  • ExoPlayer架构详解与源码分析（7）——SampleQueue(4)
                        2401_83740189
程序员架构
                        
    long[]newSourceIds=newlong[newCapacity];long[]newOffsets=newlong[newCapacity];long[]newTimesUs=newlong[newCapacity];int[]newFlags=newint[newCapacity];int[]newSizes=newint[newCapacity];CryptoData[]newC
    
                    
    • 
                    
  • 【HarmonyOS】- 常见算法简单写法
                        数的羊都睡了
HarmonyOSArkTS鸿蒙
                        
    文章目录知识回顾前言源码分析1.冒泡排序2.二分法查找拓展知识时间、空间复杂度总结知识回顾前言常见算法简单写法源码分析1.冒泡排序functionbubbleSort(arr:number[]):number[]{constn=arr.length;for(leti=0;iarr[j+1]){//交换元素consttemp=arr[j];arr[j]=arr[j+1];arr[j+1]=temp;
    
                    
    • 
                    
  • [ docker-ce源码分析系列 ] 修改resolv.conf文件被还原的原因
                        nangonghen
dockerdocker
                        
    1概述：1.1环境版本信息如下：a、操作系统：centos7.6，amd64b、服务器docker版本：v18.09.22resolv.conf文件被还原的现象：容器中的/etc/resolv.conf文件，是由宿主机/var/lib/docker/containers/xxxx/resolv.conf文件挂载。在dockerrestart容器之前，手动修改了/var/lib/docker/con
    
                    
    • 
                    
  • ☕【Java技术指南】「Java8技术盲区」在奔向Java13的同时，也让我们仔细研究一下Stream的学习认知！
                        洛神灬殇

                        
    Java8的功能之最要说到Java8的技术体系中，最让人难以忘怀的功能，那非Lambda和Stream莫属了。两者结合操作，达成天作之合，有点势不可挡。它主要用于补充集合类，它的强大，相信用过它的朋友，能明显的感受到，不用使用for循环就能对集合作出很好的操作。Stream使用一种类似用SQL语句从数据库查询数据的直观方式来提供一种对Java集合运算和表达的高阶抽象。这种风格将要处理的元素集合看作
    
                    
    • 
                    
  • dispatch_once源码分析
                        福伟_Y

                        
    GCD里的单例函数dispatch_once是我们经常会用到的，今天我们来稍做深入分析一下。GCD的源码都在libdispatch.dylib库里，这个库在libSystem_initializer被初始化，可理解为在dyld里被加载和初始化的(之前的文章有分析过)。dispatch_once作为单例的使用入口，通过分析得到它是一个宏定义，_dispatch_once函数在libdispatch.
    
                    
    • 
                    
  • java----TreeMap
                        qq_44766305
数据结构
                        
    TreeMap.TreeMap跟TreeSet底层原理一样，都是红黑树结构的.由键决定特性：不重复、无索引、可排序.可排序:对键进行排序.注意:默认按照键从小到大进行排序,也可以按照自己规定键的排序规则代码书写两种排序规则:1.实现Comparable接口,指定比较规则2.创建集合时传递Compartor比较器对象，指定比较规则Comparable接口是Java集合框架的一部分，它允许对象定义它们
    
                    
    • 
                    
  • jQuery Easyui 源码分析之combo组件
                        90后北京程序员
前端-easyuieasyui之combobox
                        
    /***jQueryEasyUI1.3.1*该源码完全由压缩码翻译而来，并非网络上放出的源码，请勿索要。*/(function($){functionsetSize(target,width){varopts=$.data(target,"combo").options;varcombo=$.data(target,"combo").combo;varpanel=$.data(target,"co
    
                    
    • 
                    
  • html5carousel图片轮播,全面解析Bootstrap中Carousel轮播的使用方法
                        RemusrickCat

                        
    本文实例为大家全面的解析了Bootstrap中Carousel的使用方法，供大家参考，具体内容如下源码文件：Carousel.scssCarousel.js实现原理：隐藏所有要显示的元素，然后指定当前要显示的为block，宽、高自适应源码分析：1、Html结构：主要分为以四个部分1.1、容器：最外层div，需要一个data-ride=”carousel”来指定为轮播放插件，并且提供一个Id，方便圆
    
                    
    • 
                    
  • 深入理解 Java 中 Map 和 Set 接口的高级用法
                        项目笔记与工具库
java开发语言
                        
    Java中的Map和Set接口是两个非常重要的数据结构，它们在日常开发中被广泛使用。本文将深入探讨这两个接口的高级用法，特别是如何自定义键的比较方式以及实现高效的集合操作。这些技巧能够帮助开发者更好地应对复杂的数据处理场景，并提升程序的性能。一、Map接口的高级用法Map接口用于存储键值对，是Java集合框架中最常用的数据结构之一。在某些场景下，默认的键比较方式可能不满足需求，因此了解如何自定义键
    
                    
    • 
                    
  • Java集合-----List接口及其实现类：ArrayList、LinkedList、Vector
                        Colourful．
Java集合java集合
                        
    文章目录List接口概述List接口的常用方法List接口的实现类ArrayList源码分析类继承关系ArrayList中的属性：ArrayList构造函数：ArrayList中常用方法添加操作：add()删除操作：remove()获取元素：get()ArrayList是如何实现序列化的？ArrayList的总结LinkedList源码分析类继承关系类成员属性类构造器LinkedList的List
    
                    
    • 
                    
  • React Native通讯原理
                        zbl_zbl
androidReactNativ
                        
    之前写过一篇文章ReactNativeAndroid源码分析，在此文章的基础上分析和总结下RN与Native的通讯流程。本文基于Android代码分析，iOS实现原理类似。1.通讯框架图先来解析下各个模块的角色与作用：Java层，这块的实现在ReactAndroid中-ReactContext:Android上下文子类，包含一个CatalystInstance实例，用于获取NativeModule
    
                    
    • 
                    
  • [linux 驱动]增加一个文件节点控制led灯亮灭
                        嵌入式成长家
linux内核的系统实战linux驱动linux驱动led灯驱动
                        
    目录1修改设备树2修改驱动3驱动源码3.1驱动源码3.2设备树节点3.3驱动源码分析3.3.1##解释3.3.2class_create解释3.3.3class_create_file解释3.3.4of_get_named_gpio_flags解释3.3.5devm_gpio_request解释3.3.6platform_driver_register解释3.3.7platform_driver_
    
                    
    • 
                    
  • 【QT教程】QT6对话框编程
                        QT性能优化QT原理源码QT界面美化
qtqt6.3qt5c++QT教程
                        
    QT6对话框编程使用AI技术辅助生成QT界面美化视频课程QT性能优化视频课程QT原理与源码分析视频课程QTQMLC++扩展开发视频课程免费QT视频课程您可以看免费1000+个QT技术视频免费QT视频课程QT统计图和QT数据可视化视频免费看免费QT视频课程QT性能优化视频免费看免费QT视频课程QT界面美化视频免费看1QT6对话框编程基础1.1QT6对话框简介1.1.1QT6对话框简介QT6对话框简介
    
                    
    • 
                    
  • 鸿蒙轻内核M核源码分析系列十二 事件Event
                        OpenHarmony_小贾
OpenHarmonyHarmonyOS鸿蒙开发harmonyosopenharmony鸿蒙内核鸿蒙开发移动开发嵌入式硬件驱动开发
                        
    事件（Event）是一种任务间通信的机制，可用于任务间的同步。多任务环境下，任务之间往往需要同步操作，一个等待即是一个同步。事件可以提供一对多、多对多的同步操作。本文通过分析鸿蒙轻内核事件模块的源码，深入掌握事件的使用。本文中所涉及的源码，以OpenHarmonyLiteOS-M内核为例，均可以在开源站点https://gitee.com/openharmony/kernel_liteos_m获取
    
                    
    • 
                    
  • 鸿蒙轻内核M核源码分析系列四 中断Hwi
                        OpenHarmony_小贾
鸿蒙开发OpenHarmonyHarmonyOSharmonyos单片机OpenHarmony嵌入式硬件鸿蒙开发移动开发鸿蒙内核
                        
    在鸿蒙轻内核源码分析系列前几篇文章中，剖析了重要的数据结构。本文，我们讲述一下中断，会给读者介绍中断的概念，鸿蒙轻内核的中断模块的源代码。本文中所涉及的源码，以OpenHarmonyLiteOS-M内核为例。1、中断概念介绍中断是指出现需要时，CPU暂停执行当前程序，转而执行新程序的过程。当外设需要CPU时，将通过产生中断信号使CPU立即中断当前任务来响应中断请求。在剖析中断源代码之前，下面介绍些
    
                    
    • 
                    
  • 鸿蒙轻内核M核源码分析系列五 时间管理
                        OpenHarmony_小贾
HarmonyOSOpenHarmony鸿蒙开发harmonyosopenharmony鸿蒙开发NAPI鸿蒙内核移动开发嵌入式
                        
    在鸿蒙轻内核源码分析上一篇文章中，我们剖析了中断的源码，简单提到了Tick中断。本文会继续分析Tick和时间相关的源码，给读者介绍鸿蒙轻内核的时间管理模块。本文中所涉及的源码，以OpenHarmonyLiteOS-M内核为例，均可以在开源站点https://gitee.com/openharmony/kernel_liteos_m获取。时间管理模块以系统时钟为基础，可以分为2部分，一部分是SysT
    
                    
    • 
                    
  • 鸿蒙轻内核M核源码分析系列六 任务及任务调度（1）任务栈
                        OpenHarmony_小贾
鸿蒙开发OpenHarmonyHarmonyOSHarmonyOSopenharmony鸿蒙开发移动开发鸿蒙内核驱动开发嵌入式硬件
                        
    继续分析鸿蒙轻内核源码，我们本文开始要分析下任务及任务调度模块。首先，我们介绍下任务栈的基础概念。任务栈是高地址向低地址生长的递减栈，栈指针指向即将入栈的元素位置。初始化后未使用过的栈空间初始化的内容为宏OS_TASK_STACK_INIT代表的数值0xCACACACA，栈顶初始化为宏OS_TASK_MAGIC_WORD代表的数值0xCCCCCCCC。一个任务栈的示意图如下，其中，栈底指针是栈的最
    
                    
    • 
                    
  • 鸿蒙轻内核M核源码分析系列三 数据结构-任务排序链表
                        OpenHarmony_小贾
HarmonyOSOpenHarmony鸿蒙开发数据结构harmonyos移动开发OpenHarmony鸿蒙内核鸿蒙开发嵌入式硬件
                        
    在鸿蒙轻内核源码分析系列一和系列二，我们分析了双向循环链表、优先级就绪队列的源码。本文会继续给读者介绍鸿蒙轻内核源码中重要的数据结构：任务排序链表TaskSortLinkAttr。鸿蒙轻内核的任务排序链表，用于任务延迟到期/超时唤醒等业务场景，是一个非常重要、非常基础的数据结构。本文中所涉及的源码，以OpenHarmonyLiteOS-M内核为例。1任务排序链表我们先看下任务排序链接的数据结构。任
    
                    
    • 
                    
  • 鸿蒙轻内核A核源码分析系列七 进程管理 (2)
                        OpenHarmony_小贾
HarmonyOS鸿蒙开发OpenHarmonyharmonyosOpenHarmony移动开发驱动开发鸿蒙内核LiteOS-A内核进程通信
                        
    本文先熟悉下进程管理的文件kernel\base\core\los_process.c中的内部接口，读读代码，做些记录。1、LiteOS-A内核进程全局变量⑴是进程池，存放各个进程控制块LosProcessCB的信息。⑵处开始的g_freeProcess是空闲进程链表，挂载各个空闲进程控制块；g_processRecycleList是待回收进程控制块链表，挂载各个等待回收的进程控制块。⑶处开始的g
    
                    
    • 
                                
  • LeetCode[位运算] - #137 Single Number II
                                    Cwind
javaAlgorithmLeetCode题解位运算
                                    
    原题链接：#137 Single Number II  
要求： 
给定一个整型数组，其中除了一个元素之外，每个元素都出现三次。找出这个元素 
注意：算法的时间复杂度应为O(n)，最好不使用额外的内存空间 
  
难度：中等 
  
分析： 
与#136类似，都是考察位运算。不过出现两次的可以使用异或运算的特性 n XOR n = 0, n XOR 0 = n，即某一
    
                                
    • 
                                
  • 《JavaScript语言精粹》笔记
                                    aijuans
JavaScript
                                    
    0、JavaScript的简单数据类型包括数字、字符创、布尔值（true/false）、null和undefined值，其它值都是对象。 
1、JavaScript只有一个数字类型，它在内部被表示为64位的浮点数。没有分离出整数，所以1和1.0的值相同。 
2、NaN是一个数值，表示一个不能产生正常结果的运算结果。NaN不等于任何值，包括它本身。可以用函数isNaN(number)检测NaN,但是
    
                                
    • 
                                
  • 你应该更新的Java知识之常用程序库
                                    Kai_Ge
java
                                    
    在很多人眼中，Java 已经是一门垂垂老矣的语言，但并不妨碍 Java 世界依然在前进。如果你曾离开 Java，云游于其它世界，或是每日只在遗留代码中挣扎，或许是时候抬起头，看看老 Java 中的新东西。 
Guava 
Guava[gwɑ:və]，一句话，只要你做Java项目，就应该用Guava（Github）。 
guava 是 Google 出品的一套 Java 核心库，在我看来，它甚至应该
    
                                
    • 
                                
  • HttpClient
                                    120153216
httpclient
                                    
    /**
 * 可以传对象的请求转发，对象已流形式放入HTTP中
 */
public static Object doPost(Map<String,Object> parmMap,String url)
	{
		Object object = null;
		HttpClient hc = new HttpClient();
		
		String fullURL 
    
                                
    • 
                                
  • Django model字段类型清单
                                    2002wmj
django
                                    
    Django 通过 models 实现数据库的创建、修改、删除等操作，本文为模型中一般常用的类型的清单，便于查询和使用： AutoField：一个自动递增的整型字段，添加记录时它会自动增长。你通常不需要直接使用这个字段；如果你不指定主键的话，系统会自动添加一个主键字段到你的model。(参阅自动主键字段)  BooleanField：布尔字段,管理工具里会自动将其描述为checkbox。  Cha
    
                                
    • 
                                
  • 在SQLSERVER中查找消耗CPU最多的SQL
                                    357029540
SQL Server
                                    
    返回消耗CPU数目最多的10条语句 
 
SELECT TOP 10 
   total_worker_time/execution_count AS avg_cpu_cost, plan_handle, 
   execution_count, 
   (SELECT SUBSTRING(text, statement_start_of
    
                                
    • 
                                
  • Myeclipse项目无法部署，Undefined exploded archive location
                                    7454103
eclipseMyEclipse
                                    
    做个备忘！ 
 
错误信息为： 
      Undefined exploded archive location 
 
 
原因： 
          在工程转移过程中，导致工程的配置文件出错； 
 
 
解决方法： 
   
    
                                
    • 
                                
  • GMT时间格式转换
                                    adminjun
GMT时间转换
                                    
    普通的时间转换问题我这里就不再罗嗦了，我想大家应该都会那种低级的转换问题吧，现在我向大家总结一下如何转换GMT时间格式，这种格式的转换方法网上还不是很多，所以有必要总结一下，也算给有需要的朋友一个小小的帮助啦。 
1、可以使用 
SimpleDateFormat SimpleDateFormat    
EEE-三位星期 
d-天 
MMM-月 
yyyy-四位年 

    
                                
    • 
                                
  • Oracle数据库新装连接串问题
                                    aijuans
oracle数据库
                                    
    割接新装了数据库，客户端登陆无问题，apache/cgi-bin程序有问题，sqlnet.log日志如下： 
Fatal NI connect error 12170. 
  VERSION INFORMATION:         TNS for Linux: Version 10.2.0.4.0 - Product
    
                                
    • 
                                
  • 回顾java数组复制
                                    ayaoxinchao
java数组
                                    
    在写这篇文章之前，也看了一些别人写的，基本上都是大同小异。文章是对java数组复制基础知识的回顾，算是作为学习笔记，供以后自己翻阅。首先，简单想一下这个问题：为什么要复制数组？我的个人理解：在我们在利用一个数组时，在每一次使用，我们都希望它的值是初始值。这时我们就要对数组进行复制，以达到原始数组值的安全性。java数组复制大致分为3种方式：①for循环方式 ②clone方式 ③arrayCopy方
    
                                
    • 
                                
  • java web会话监听并使用spring注入
                                    bewithme
Java Web
                                    
      
      在java web应用中，当你想在建立会话或移除会话时，让系统做某些事情，比如说，统计在线用户，每当有用户登录时，或退出时，那么可以用下面这个监听器来监听。 
       
import java.util.ArrayList;
import java.ut
    
                                
    • 
                                
  • NoSQL数据库之Redis数据库管理(Redis的常用命令及高级应用)
                                    bijian1013
redis数据库NoSQL
                                    
    一 .Redis常用命令 
        Redis提供了丰富的命令对数据库和各种数据库类型进行操作，这些命令可以在Linux终端使用。 
        a.键值相关命令 
        b.服务器相关命令 
1.键值相关命令 
      &
    
                                
    • 
                                
  • java枚举序列化问题
                                    bingyingao
java枚举序列化
                                    
    对象在网络中传输离不开序列化和反序列化。而如果序列化的对象中有枚举值就要特别注意一些发布兼容问题: 
 
 
1.加一个枚举值 
新机器代码读分布式缓存中老对象，没有问题，不会抛异常。 
 
老机器代码读分布式缓存中新对像，反序列化会中断，所以在所有机器发布完成之前要避免出现新对象，或者提前让老机器拥有新增枚举的jar。 
 
 
 
  2.删一个枚举值 
新机器代码读分布式缓存中老对象，反序列
    
                                
    • 
                                
  • 【Spark七十八】Spark Kyro序列化
                                    bit1129
spark
                                    
    当使用SparkContext的saveAsObjectFile方法将对象序列化到文件，以及通过objectFile方法将对象从文件反序列出来的时候，Spark默认使用Java的序列化以及反序列化机制，通常情况下，这种序列化机制是很低效的，Spark支持使用Kyro作为对象的序列化和反序列化机制，序列化的速度比java更快，但是使用Kyro时要注意，Kyro目前还是有些bug。 
 
 Spark
    
                                
    • 
                                
  • Hybridizing OO and Functional Design
                                    bookjovi
erlanghaskell
                                    
      推荐博文：
Tell Above, and Ask Below - Hybridizing OO and Functional Design  
文章中把OO和FP讲的深入透彻，里面把smalltalk和haskell作为典型的两种编程范式代表语言，此点本人极为同意，smalltalk可以说是最能体现OO设计的面向对象语言，smalltalk的作者Alan kay也是OO的最早先驱，
    
                                
    • 
                                
  • Java-Collections Framework学习与总结-HashMap
                                    BrokenDreams
Collections
                                    
            开发中常常会用到这样一种数据结构，根据一个关键字，找到所需的信息。这个过程有点像查字典，拿到一个key，去字典表中查找对应的value。Java1.0版本提供了这样的类java.util.Dictionary(抽象类)，基本上支持字典表的操作。后来引入了Map接口，更好的描述的这种数据结构。 
 &nb
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-职责链模式-Chain Of Responsibility
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 
 
 




/**
 * 业务逻辑：项目经理只能处理500以下的费用申请，部门经理是1000，总经理不设限。简单起见，只同意“Tom”的申请
 * bylijinnan
 */
abstract class Handler {
	/* 
    
                                
    • 
                                
  • Android中启动外部程序
                                    cherishLC
android
                                    
    1、启动外部程序 
引用自： 
http://blog.csdn.net/linxcool/article/details/7692374 
 
//方法一
Intent intent=new Intent();
//包名 包名+类名（全路径）
intent.setClassName("com.linxcool", "com.linxcool.PlaneActi
    
                                
    • 
                                
  • summary_keep_rate
                                    coollyj
SUM
                                    
    
BEGIN  
      /*DECLARE  minDate varchar(20) ;
      DECLARE  maxDate varchar(20) ;*/
      DECLARE  stkDate varchar(20) ;

      DECLARE done int default -1; 
			/* 游标中 注册服务器地址 */  
      DE
    
                                
    • 
                                
  • hadoop hdfs 添加数据目录出错
                                    daizj
hadoophdfs扩容
                                    
    由于原来配置的hadoop data目录快要用满了，故准备修改配置文件增加数据目录，以便扩容，但由于疏忽，把core-site.xml, hdfs-site.xml配置文件dfs.datanode.data.dir 配置项增加了配置目录，但未创建实际目录，重启datanode服务时，报如下错误： 
 
2014-11-18 08:51:39,128 WARN org.apache.hadoop.h
    
                                
    • 
                                
  • grep 目录级联查找
                                    dongwei_6688
grep
                                    
           在Mac或者Linux下使用grep进行文件内容查找时，如果给定的目标搜索路径是当前目录，那么它默认只搜索当前目录下的文件，而不会搜索其下面子目录中的文件内容，如果想级联搜索下级目录，需要使用一个“-r”参数： 
grep -n -r "GET" . 
  
上面的命令将会找出当前目录“.”及当前目录中所有下级目录
    
                                
    • 
                                
  • yii 修改模块使用的布局文件
                                    dcj3sjt126com
yiilayouts
                                    
    方法一：yii模块默认使用系统当前的主题布局文件，如果在主配置文件中配置了主题比如:  'theme'=>'mythm',   那么yii的模块就使用 protected/themes/mythm/views/layouts 下的布局文件；   如果未配置主题，那么 yii的模块就使用  protected/views/layouts 下的布局文件， 总之默认不是使用自身目录 pr
    
                                
    • 
                                
  • 设计模式之单例模式
                                    come_for_dream
设计模式单例模式懒汉式饿汉式双重检验锁失败无序写入
                                    
                    今天该来的面试还没来，这个店估计不会来电话了，安静下来写写博客也不错，没事翻了翻小易哥的博客甚至与大牛们之间的差距，基础知识不扎实建起来的楼再高也只能是危楼罢了，陈下心回归基础把以前学过的东西总结一下。 
  
*********************************
    
                                
    • 
                                
  • 8、数组
                                    豆豆咖啡
二维数组数组一维数组
                                    
      
一、概念 
  
    数组是同一种类型数据的集合。其实数组就是一个容器。 
  
二、好处 
  
    可以自动给数组中的元素从0开始编号，方便操作这些元素 
  
三、格式 
  
//一维数组
1,元素类型[] 变量名 = new 元素类型[元素的个数]
int[] arr =
    
                                
    • 
                                
  • Decode Ways
                                    hcx2013
decode
                                    
    A message containing letters from A-Z is being encoded to numbers using the following mapping: 
'A' -> 1
'B' -> 2
...
'Z' -> 26
 
Given an encoded message containing digits, det
    
                                
    • 
                                
  • Spring4.1新特性——异步调度和事件机制的异常处理
                                    jinnianshilongnian
spring 4.1
                                    
    目录 
Spring4.1新特性——综述 
Spring4.1新特性——Spring核心部分及其他 
Spring4.1新特性——Spring缓存框架增强 
Spring4.1新特性——异步调用和事件机制的异常处理 
Spring4.1新特性——数据库集成测试脚本初始化 
Spring4.1新特性——Spring MVC增强 
Spring4.1新特性——页面自动化测试框架Spring MVC T
    
                                
    • 
                                
  • squid3(高命中率)缓存服务器配置
                                    liyonghui160com

                                    
      
  
系统:centos 5.x 
  需要的软件:squid-3.0.STABLE25.tar.gz 
1.下载squid 
wget http://www.squid-cache.org/Versions/v3/3.0/squid-3.0.STABLE25.tar.gz 
tar zxf squid-3.0.STABLE25.tar.gz &&
    
                                
    • 
                                
  • 避免Java应用中NullPointerException的技巧和最佳实践
                                    pda158
java
                                    
    1) 从已知的String对象中调用equals()和equalsIgnoreCase()方法，而非未知对象。   　　总是从已知的非空String对象中调用equals()方法。因为equals()方法是对称的，调用a.equals(b)和调用b.equals(a)是完全相同的，这也是为什么程序员对于对象a和b这么不上心。如果调用者是空指针，这种调用可能导致一个空指针异常 
Object unk
    
                                
    • 
                                
  • 如何在Swift语言中创建http请求
                                    shoothao
httpswift
                                    
      
 概述：本文通过实例从同步和异步两种方式上回答了”如何在Swift语言中创建http请求“的问题。  
   
如果你对Objective-C比较了解的话，对于如何创建http请求你一定驾轻就熟了，而新语言Swift与其相比只有语法上的区别。但是，对才接触到这个崭新平台的初学者来说，他们仍然想知道“如何在Swift语言中创建http请求？”。 
在这里,我将作出一些建议来回答上述问题。常见的
    
                                
    • 
                                
  • Spring事务的传播方式
                                    uule
spring事务
                                    
    传播方式：  
      新建事务 
      required 
      required_new   - 挂起当前 
  
      非事务方式运行 
      supports 
  &nbs
    
                                
    •