线程死锁_hashMap参数

多线程

1、模拟一个线程死锁

package com.m.sort;



public class Test2 {
    private static final Object obj1 = new Object();
    private static final Object obj2 = new Object();
    public static void main(String[] args) {
        new Thread(()->{
            synchronized (obj1){
                try {
                    Thread.sleep(1000);
                    new A().test(obj1);
                    synchronized (obj2){
                        new A().test(obj2);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

//解决死锁        
//        try {
//            Thread.sleep(2000);
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
        /*
            A:java.lang.Object@4f7a3a41
            A:java.lang.Object@41bdddde
            B:java.lang.Object@41bdddde
            B:java.lang.Object@4f7a3a41
         */
        new Thread(()->{
            synchronized (obj2){
                new A().test(obj2);
                synchronized (obj1){
                    new A().test(obj1);
                }
            }
        },"B").start();
    }
}

class A{
    void test(Object obj){
        System.out.println(Thread.currentThread().getName()+":"+obj.toString());
    }
}

2、HashMap的put()与get();

• 根据6大参数说明put()或者putAll()干了什么

  1、16表示数组的默认长度，使用时创建，与StringBuilder对比，StringBuilder是构造函数创建默认长度
  
  2、1<<30就是2是30次方，数组的最大长度
  
  3、0.75f是负载因子，数组要不要扩容，就看当前数组的长度n*0.75f，在数组添加元素时，当前的Entry<K,V>的size是否大于threshold = loadFactor*当前数组的容量，是就resize()[例如:从16扩容到32]
  
  
  if (++size > threshold)
    		resize();	
          
  
  
  4、8 是 链表长度到达8之后转红黑树的临界条件，在数组长度大于64的基础上生效。
  
  5、6 是 红黑叔转链表的临界条件
  
  6、64是最小树容量，就是链表在转成红黑树时，如果数组的长度<64，就优先扩容数组resize()，本次不转红黑树了
  

    /**
     * The default initial capacity - MUST be a power of two.
     */
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

    /**
     * The maximum capacity, used if a higher value is implicitly specified
     * by either of the constructors with arguments.
     * MUST be a power of two <= 1<<30.
     */
    static final int MAXIMUM_CAPACITY = 1 << 30;

    /**
     * The load factor used when none specified in constructor.
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /**
     * The bin count threshold for using a tree rather than list for a
     * bin.  Bins are converted to trees when adding an element to a
     * bin with at least this many nodes. The value must be greater
     * than 2 and should be at least 8 to mesh with assumptions in
     * tree removal about conversion back to plain bins upon
     * shrinkage.
     */
    static final int TREEIFY_THRESHOLD = 8;

    /**
     * The bin count threshold for untreeifying a (split) bin during a
     * resize operation. Should be less than TREEIFY_THRESHOLD, and at
     * most 6 to mesh with shrinkage detection under removal.
     */
    static final int UNTREEIFY_THRESHOLD = 6;

    /**
     * The smallest table capacity for which bins may be treeified.
     * (Otherwise the table is resized if too many nodes in a bin.)
     * Should be at least 4 * TREEIFY_THRESHOLD to avoid conflicts
     * between resizing and treeification thresholds.
     */
    static final int MIN_TREEIFY_CAPACITY = 64;

3、Collections.synchronizedMap(new HashMap<String,Object>());

1、这个方法主要是对堆当中的new HashMap的
1、final是线程安全类
2、synchronized(this)代码块处理

public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) {
    return new SynchronizedMap<>(m);
}

    /**
     * @serial include
     */
private static class SynchronizedMap<K,V>
    implements Map<K,V>, Serializable {
    private static final long serialVersionUID = 1978198479659022715L;

    private final Map<K,V> m;     // Backing Map
    final Object      mutex;        // Object on which to synchronize

    SynchronizedMap(Map<K,V> m) {
        this.m = Objects.requireNonNull(m);
        mutex = this;
    }

    SynchronizedMap(Map<K,V> m, Object mutex) {
        this.m = m;
        this.mutex = mutex;
    }

    public V get(Object key) {
        synchronized (mutex) {return m.get(key);}
    }

    public V put(K key, V value) {
        synchronized (mutex) {return m.put(key, value);}
    }

计数排序

public static void countSort(int [] arr) {
    //1、找到数组最大值
    int max = Integer.MIN_VALUE;
    for(int i:arr){
        if(i > max){
            max = i;
        }
    }
    int [] count = new int[max+1];
    //对arr [] 进行操作
    for(int i = 0;i<arr.length;i++){
        count[arr[i]]++;
    }

    int [] sorted = new int[arr.length];
    int index = 0;
    //[0, 1, 1, 0, 0, 0, 2, 1]
    for(int i = 0;i<count.length;i++){
        for (int j = 0; j < count[i]; j++) {
            sorted[index++] = i;
        }
    }
    System.out.println(Arrays.toString(sorted));
}

下一回发个redis，RPC的模拟的小项目，底层是网络编程的套接字，主要是心跳检测机制的模拟。

ConcurrentHashMap的原理机制与HasnMap大差不差，不同的是前者的内部锁机制，内部是分段加锁，锁的粒度更细了，没有对整个方法加锁的操作。