Central Topic

迭代器通过构造方法初始化会记录数组大小
modCount集合大小
expectedModCount需要遍历多少次
通过checkForComodification()检查，如果不相等则抛出异常

1、数组+链表，初始容量16
2、采用头插法，在并发的情况下容易发生死链
3、put值，根据key键,hashCode取值,在经过二次hash，二次hash是为了让数据分布更均匀，最后在根据位运算&(容量(capacity )-1)

1、数组+链表+红黑树，初始容量16
2、采用尾插法
3、put值，根据key键,hashCode取值,在经过二次hash，二次hash是为了让数据分布更均匀，最后在根据位运算&(容量(capacity )-1)

1.7和1.8区别
1、链表插入节点时，1.7 是头插法，1.8 是尾插法
2、1.7 是大于等于阈值且没有空位时才扩容，而 1.8 是大于阈值就扩容
3、1.8 在扩容计算 Node 索引时，会优化(红黑树)

public class Singleton {
    private Singleton() {
        System.out.println("private Singleton()");
    }

    private static final Singleton INSTANCE = new Singleton();

    public static Singleton getInstance() {
        return INSTANCE;
    }
}

缺点

public class Singleton implements Serializable {
    private Singleton() {
        System.out.println("private Singleton()");
    }

    private static final Singleton INSTANCE = new Singleton();

    public static Singleton getInstance() {
        return INSTANCE;
    }

    public Object readResolve() {
        return INSTANCE;
    }
}

防止被序列化破坏

public class Singleton implements Serializable {
    private Singleton() {
        if (INSTANCE != null) {
            throw new RuntimeException("单例对象不能重复创建");
        }
        System.out.println("private Singleton()");
    }

    private static final Singleton INSTANCE = new Singleton();

    public static Singleton getInstance() {
        return INSTANCE;
    }

    public Object readResolve() {
        return INSTANCE;
    }
}

防止被构造破坏

public enum Singleton2 {
    INSTANCE;

    private Singleton2() {
        System.out.println("private Singleton2()");
    }

    @Override
    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

    public static Singleton2 getInstance() {
        return INSTANCE;
    }
   
}

枚举饿汉式能天然防止反射、反序列化破坏单例

public class Singleton3 implements Serializable {
    private Singleton3() {
        System.out.println("private Singleton3()");
    }

    private static Singleton3 INSTANCE = null;

    // Singleton3.class
    public static synchronized Singleton3 getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new Singleton3();
        }
        return INSTANCE;
    }

    public static void otherMethod() {
        System.out.println("otherMethod()");
    }

}

同步锁结合static 锁的是当前Class

public class Singleton4 implements Serializable {
    private Singleton4() {
        System.out.println("private Singleton4()");
    }

    /*
     * * `INSTANCE = new Singleton4()` 不是原子的，分成 3 步：创建对象、调用构造、给静态变量赋值，其中后两步可能被指令重排序优化，变成先赋值、再调用构造
     * 如果线程1 先执行了赋值，线程2 执行到第一个 `INSTANCE == null` 时发现 INSTANCE 已经不为 null，此时就会返回一个未完全构造的对象
     * */
    private static volatile Singleton4 INSTANCE = null; // 可见性，有序性

    public static Singleton4 getInstance() {
        if (INSTANCE == null) {
            synchronized (Singleton4.class) {
                if (INSTANCE == null) {
                    INSTANCE = new Singleton4();
                }
            }
        }
        return INSTANCE;
    }

    public static void otherMethod() {
        System.out.println("otherMethod()");
    }
}

public class Singleton5 implements Serializable {
    private Singleton5() {
        System.out.println("private Singleton5()");
    }

    private static class Holder {
        static Singleton5 INSTANCE = new Singleton5();
    }

    public static Singleton5 getInstance() {
        return Holder.INSTANCE;
    }

    public static void otherMethod() {
        System.out.println("otherMethod()");
    }
}

* Runtime 体现了饿汉式单例
* Console 体现了双检锁懒汉式单例
* Collections 中的 EmptyNavigableSet 内部类懒汉式单例
* ReverseComparator.REVERSE_ORDER 内部类懒汉式单例
* Comparators.NaturalOrderComparator.INSTANCE 枚举饿汉式单例

7大核心参数

1、RUNNING：运行状态，线程池新建或调用execute()方法后，处于运行状态，能够接受新的任务
   
2、SHUTDOWN：关闭状态，调用shutdown()方法后，变为关闭状态，不在接受新的任务，但会执行已提交的等待队列中的任务
   
3、STOP：停止状态，调用shutdownNow()方法后，变为stop状态，不在接受新的任务，并且会中断正在处理的任务
   
4、TIDYING：当线程池处于Shutdown或Stop状态时，如果等待队列中还有未执行的任务，则线程池将执行整理操作，将等待队列中的未执行任务移除，并保存到一个列表中
   
5、TERMINATED：当线程池处于Shutdown状态，并且等待队列中的任务全部执行完毕，或者在Stop状态下，线程池内部的所有线程都已经终止时，线程池进入Terminated状态

锁升级过程

核心：轻量级锁，会去使用CAS不断自旋获取锁，目的是为了避免频繁地将现场在用户态和内核态之间切换，从而减少操作系统介入的开销

public class AddAndSubtract {

    static volatile int balance = 10;

    public static void subtract() {
        int b = balance;
        b -= 5;
        balance = b;
    }

    public static void add() {
        int b = balance;
        b += 5;
        balance = b;
    }

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(2);
        new Thread(() -> {
            subtract();
            latch.countDown();
        }).start();
        new Thread(() -> {
            add();
            latch.countDown();
        }).start();
        latch.await();
        System.out.println(balance);
    }
}

// 可见性例子
// -Xint
//在JDK编译器中有个 jit组件，会根据热点代码优化，因为在0.1秒钟，可以执行很多次超过阈值，默认把stop变量直接替换成了false,所以会导致foo方法停不下来，其他线程能正常的感知到stop变量变为true
//或者禁用jit组件使用 -Xint,但是不可能为了一个变量去禁用一个组件
public class ForeverLoop {
    static  volatile boolean stop = false;

    public static void main(String[] args) {
        new Thread(() -> {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            stop = true;
            System.out.println("modify stop to true...");
        }).start();

        new Thread(() -> {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(stop);
        }).start();

        new Thread(() -> {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(stop);
        }).start();

        foo();
    }

    static void foo() {
        int i = 0;
        while (!stop) {
            i++;
        }
        System.out.println("stopped... c:" + i);
    }
}

1、读取内存地址中的当前值。
2、检查当前值是否等于期望值。
3、如果相等，则将新值写入内存地址；否则，操作失败。
4、返回操作是否成功的结果。

如果一个值原来是A，后来被改成了B，再被改回A，那么CAS操作会误认为这个值没有被改变过。为了解决这个问题，可以使用版本号或者标记来区分不同的状态

* 数据结构：`Segment(大数组) + HashEntry(小数组) + 链表`，每个 Segment 对应一把锁，如果多个线程访问不同的 Segment，则不会冲突
* 并发度：Segment 数组大小即并发度，决定了同一时刻最多能有多少个线程并发访问。Segment 数组不能扩容，意味着并发度在 ConcurrentHashMap 创建时就固定了

初始化时采用的设计模式饿汉式初始化，默认创建segment[0]容量，后续创建segment的时候 都是以原型模式去借用segment[0]的属性

* 数据结构：`Node 数组 + 链表或红黑树`，数组的每个头节点作为锁，如果多个线程访问的头节点不同，则不会冲突。首次生成头节点时如果发生竞争，利用 cas 而非 syncronized，进一步提升性能
* 并发度：Node 数组有多大，并发度就有多大，与 1.7 不同，Node 数组可以扩容
* 扩容条件：Node 数组满 3/4 时就会扩容

第一次，从根节点（如虚拟机栈中的引用、静态变量等）开始，递归地遍历所有可达对象，并标记它们
第二次，清除未标记的对象

缺点，内存碎片化太严重

第一次，从根节点（如虚拟机栈中的引用、静态变量等）开始，递归地遍历所有可达对象，并标记它们
第二次，清除未标记的对象，移动所有存活的对象，使它们在堆中连续分布

缺点，效率比较低，标记整理算法需要移动存活对象，可能会导致一定的延迟，特别是在堆中存活对象较多时

第一次，从根节点（如虚拟机栈中的引用、静态变量等）开始，递归地遍历所有可达对象，并标记它们为活动对象
第二次，将所有活动对象从当前使用的内存区域（比如 Eden 区）复制到另一个内存区域（比如 Survivor 区或者老年代）。同时，可能会进行对象的年龄提升（Promotion）操作，将存活时间较长的对象移动到老年代
第三次，清除未被标记的对象，即垃圾对象。在复制阶段之后，原来的内存区域变成了不包含存活对象的内存块，可以直接清空或者重置为可用状态

缺点，需要额外的空间作为复制目标，通常是原来空间的一半大小，移动存活对象可能会引起一定的延迟，特别是当存活对象较多时