Java重点难点一句话总结

常用的几种单例模式

懒加载线程安全
public class Manager {
    private Manager instance = null;

    Manager getIntance() {
        if (instance == null) {
            sycnronize (this) {
                if (instance == null) {
                    instance = new Manager();
                    return instance;
                }
            }
        }
        return instance;
        
    }

    private Manager(){
    }

}

饿汉模式
public class Manager {
    private static final Manager instance = new Manager();
    private Manager(){
    }

    public static void getInstance() {
        return instance;
    }

}

懒汉模式
public class Manager {
    private Manager(){
    }

    public static void getInstance() {
        return SingletonHolder.instance;
    }

    private static class SingletonHolder {
        public static final Manager instance = new Manager();
    }

}

生产者消费者模式

• semapore实现
  https://blog.csdn.net/mm_bit/article/details/50010623
  // 非满锁
  final Semaphore notFull = new Semaphore(10);
  // 非空锁
  final Semaphore notEmpty = new Semaphore(0);
  // 核心锁
  final Semaphore mutex = new Semaphore(1);

• blockingqueue无需同步锁
  https://www.cnblogs.com/fankongkong/p/7339848.html
  private BlockingQueue resourceQueue = new LinkedBlockingQueue(10);
  resourceQueue.put(1);
  resourceQueue.take();

• lock/condition/await/signalAll
  核心防冲突锁 Lock lock = new ReentrantLock();
  是否满的条件 Condition producerCondition = lock.newCondition();
  非空的条件 ondition consumerCondition = lock.newCondition();

HashMap的内部结构？ 内部原理?

https://www.cnblogs.com/stevenczp/p/7028071.html
JDK1.7中

使用一个Entry数组来存储数据，用key的hashcode取模来决定key会被放到数组里的位置，如果hashcode相同，或者hashcode取模后的结果相同（hash collision），那么这些key会被定位到Entry数组的同一个格子里，这些key会形成一个链表。
在hashcode特别差的情况下，比方说所有key的hashcode都相同，这个链表可能会很长，那么put/get操作都可能需要遍历这个链表
也就是说时间复杂度在最差情况下会退化到O(n)

JDK1.8中
使用一个Node数组来存储数据，但这个Node可能是链表结构，也可能是红黑树结构
如果插入的key的hashcode相同，那么这些key也会被定位到Node数组的同一个格子里。
如果同一个格子里的key不超过8个，使用链表结构存储。
如果超过了8个，那么会调用treeifyBin函数，将链表转换为红黑树。
那么即使hashcode完全相同，由于红黑树的特点，查找某个特定元素，也只需要O(log n)的开销
也就是说put/get的操作的时间复杂度最差只有O(log n)