Java（二十）

知识点一：HashMap源码解析

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
    // 缺省的初始容量:16
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
    // 最大容量01000000000000000000000000000000
    static final int MAXIMUM_CAPACITY = 1 << 30;
    // 缺省的加载因子, 3/4. 就是数组的使用率
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    // 变成树的门槛, 当链表中的元素超过这个值时, 就要升级成红黑树, 为了提升检索性能
    static final int TREEIFY_THRESHOLD = 8;
    // 树再变成链表的门槛, 当红黑树中的节点数小于此值时, 就要重新变回链表, 不需要再单独维护红黑树.
    static final int UNTREEIFY_THRESHOLD = 6;
    // 最小变树的数组容量, 只有数组容量大于此值时, 并且某个下标处的链表节点数大于8才真的变成红黑树.
    static final int MIN_TREEIFY_CAPACITY = 64;

    // 组成数组的元素类型, 是节点类型, 它其实就是条目
    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash; // 不允许修改的原始的键对象的哈希值
        final K key; // 不允许修改的键对象
        V value; // 值对象
        Node<K, V> next; // 用于构建链表的指针.

        Node(int hash, K key, V value, Node<K, V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }
    }

    // 是最重要, 最核心的哈希表, Node类型的数组
    transient Node<K,V>[] ;
    // 计数器, 条目数
    transient int size;
    // 控制迭代器同步的修改次数
    transient int modCount;
    // 当前哈希表的加载因子
    final float loadFactor;
    // 数组长度*加载因子的结果, 使用门槛, 计数器超过此值就会扩容.
    int threshold;

    public HashMap() { // 当前因子 = 3/4
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

    static final int hash(Object key) { // 求键对象的哈希码值.
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); // 使得低16位的数更散列.
    }

    public V put(K key, V value) { // 4
        return putVal(hash(key), key, value, false, true); // (4, 4, "four", false, true);
    }

    // 4, 4, "four", false, true
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
        Node<K,V>[] tab; // 内部哈希表
        Node<K,V> p; // 目标下标位置处的老元素
        int n; // 哈希表长度
        int i; // i是键对象要插入到哈希表的目标下标值.
        tab = table; // 哈希表
        n = tab.length; // 哈希表长度

        if (tab == null || n == 0) { // 第一次添加元素时进入.
            tab = resize(); // 调整容量. tab指向了新数组, 也指向table
            n = tab.length; // 第一次 n=16
        }

        // i就是目标下标值 : 4, 下面两行是最关键最核心代码
        i = (n - 1) & hash; // 15 & 4, 作用就是让hash落到n的范围内
        p = tab[i]; // 目标下标位置处的老元素
        if (p == null) { // 这是最好的状况, 没有下标冲突.
            tab[i] = newNode(hash, key, value, null); // 直接插入
        }
        else { // 情况不太好, 出现了下标冲突!!!, 把新元素链入链表
            Node<K,V> e; // 条目对象
            K k; // 键对象, key
            // 老元素的哈希 == 新元素的哈希, && k是老元素的键对象, 新键对象.equals(老键对象)
            if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) { // 新建对象和老键对象重复了.
                e = p; // e是冲突的老元素.
            } else if (p instanceof TreeNode) { // 如果已有的老元素是一个树结点, 说明此下标处已经变成红黑树了
                e = ((TreeNode<K, V>) p).putTreeVal(this, tab, hash, key, value); // 插入红黑树
            } else { // 链表链入
                // binCount用于统计链表中的节点数
                for (int binCount = 0; ; ++binCount) { // 循环的作用就是遍历链表, 定位尾结点
                    e = p.next; // e指向下一个元素
                    if (e == null) { // 如果p.next为空, 说明p就是尾结点
                        p.next = newNode(hash, key, value, null); // 尾部插入新结点
                        if (binCount >= TREEIFY_THRESHOLD - 1) { // 链表中的元素是否进入门槛, 如果进入
                            treeifyBin(tab, hash); // 变红黑树
                        }
                        break; // 结束查找
                    }
                    if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) { // 判断链表中的下一个元素是否和新键对象重复
                        break;
                    }
                    p = e; // p指向下一个元素
                }
            }
            if (e != null) { // 要替换的老元素如果非空!!!!, 进行替换值的操作
                V oldValue = e.value; // 老值
                if (!onlyIfAbsent || oldValue == null) {
                    e.value = value; // 老条目对象的值 被刷新为 新值
                }
                afterNodeAccess(e);
                return oldValue; // 直接返回老值, 不会修改计数器,和修改次数.
            }
        }
        ++modCount; // 调整计数器
        if (++size > threshold) { // 调整计数器, 再判断是否超过上限
            resize(); // 调整数组
        }
        afterNodeInsertion(evict);
        return null;
    }

    final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table; // oldTab是老表
        int oldCap = (oldTab == null) ? 0 : oldTab.length; // 第一次执行时, 老容量为0, 第二次是16
        int oldThr = threshold; // 老上限, 第一次执行也是0, 第2次是12
        int newCap; // 新容量
        int newThr = 0; // 新上限
        if (oldCap > 0) { // 老容量>0, 第一次不会进入, 第2次进入
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            // 新容量 = 老容量 * 2; 32
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) {
                newThr = oldThr << 1; // 新上限也 * 2 : 24
            }
        } else if (oldThr > 0) {// 第一次也不会进入,
            newCap = oldThr;
        } else { // 第一次添加元素时进入
            newCap = DEFAULT_INITIAL_CAPACITY; // 新容量 = 16
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); // 新上限 = 12;
        }
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                    (int)ft : Integer.MAX_VALUE);
        }

        threshold = newThr; // 当前上限 = 新上限 : 12, 24

        // 终于要创建哈希表了, 长度是新容量
        @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; // 32

        table = newTab; // 内部哈希表引用, 相当于创建数组成功!

        if (oldTab != null) { // 如果老表为空, 要把老表中的所有数据重新散列在新表中.
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

    // 把链表变成红黑树
    final void treeifyBin(Node<K,V>[] tab, int hash) {
        int n, index; Node<K,V> e;
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY) { // 如果老表的容量没有大于64, 不变树
            resize(); // 调整容量
        } else if ((e = tab[index = (n - 1) & hash]) != null) {
            TreeNode<K,V> hd = null, tl = null;
            do {
                TreeNode<K,V> p = replacementTreeNode(e, null);
                if (tl == null)
                    hd = p;
                else {
                    p.prev = tl;
                    tl.next = p;
                }
                tl = p;
            } while ((e = e.next) != null);
            if ((tab[index] = hd) != null)
                hd.treeify(tab);
        }
    }

}

知识点二：多线程

程序：可以执行的静态代码的文件

进程：正在内存中执行的程序，有生命周期ProcessID.

线程：进程中的子任务，有生命周期，直接被Cpu调度执行。

（1）创建并启动线程的方式

1）实现的方式

​ ①写一个具体类，实现Runable接口，并实现run方法，这个run方法就是线程体

​ ②创建这个具体类对象，并以它实参在创建Thread对象，这个对象就是线对象

​ ③调用Thread对象的start()

2）继承的方式

​ ①写一个具体的类，继承Thread类，并重run方法。不重写，父类中的run 也没做。

​ ②创建Thread子类对象，及创建了线程对象。

​ ③调用子类对象的start

可以使用同一个Runnable对象，创建多个不同的Thread对象，线程之间也是并发的。

实现 的好处

​ 1)避免了单继承的局限性

​ 2）多个线程可以共享一个同一个接口实现类 的对象，非常适合多个线程来处理同一份资源。

​ void start（）：启动线程，并执行对象的run（）方法

​ run()：线程在被调度时执行的操作

​ String getName():返回线程的名字

​ void setNmae（String name）：设置该线程的名称

​ setPriority(int newPriority):改变线程的优先级

​ getPriority():返回线程的优先级

static void sleep（long millis）：指定时间：毫秒，其令当前活动线程在指定时间段内放弃对CPU控制，使其他线程有机会被执行，时间到最后重排队。

抛出InterruptedExceotion 异常

stop（）强制线程生命周期结束

boolean isAlive（）：返回boolean，判断线程是否活着

class MyThread extends Thread {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("**" + i);
        }
    }
}

public class ThreadTest {

    public static void main(String[] args) throws InterruptedException {
        Thread myThread = new MyThread();
        myThread.start();

        myThread.join(); // 主线程阻塞, 子线程继续.

        Thread.sleep(1000);

        for (int i = 0; i < 100; i++) {
            System.out.println("++" + i);
        }
    }
}

线程生命周期：

* 线程生命周期 :
*                                  阻塞(Blocked)
*                             |自然醒, 被interrupt    | sleep(), wait(), join()
*                             |notify()              |
*new Thread()   start()       |         获取CPU       |              run()结束
* 新建-------------------就绪(Runnable) ----------- 运行(Running) ------------------ 死亡(Terminated)
*                                      丢失CPU                    正常和非正常结束
*

线程同步：多个线程“同”时修改“同”一个数据，造成的数据的不确定性。

(2)停止子线程的方式

①对子线程设置boolean型变量放到while循环里面，main方法控制

public class StopRunner implements Runnable {



    private int count = 0;
    private boolean flag = true;

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {
        while (flag) {
            System.out.println(Thread.currentThread().getName() + " : " + count++);
            if (count == 200) {
                count = 0;
            }
        }
        System.out.println("我是重要代码");
    }
}
**********************************************************
public class StopRunnerTest {

    public static void main(String[] args) {
        Runnable runner = new StopRunner();
        Thread thread = new Thread(runner);
        thread.start();

        int a = 0;
        for (int i = 0; i < 200000; i++) {
            for (int j = 0; j < 30000; j++) {
                a++;
            }
        }

        //thread.stop(); stop方法太暴力.
        ((StopRunner)runner).setFlag(false); // 以通知的方式停止.

    }
}

测试：//在main方法中创建并启动1个线程。线程循环随机打印100以内的整数，直到主线程从键盘读取了“Q”命令。

public class StopExerRunner implements Runnable {

    private boolean flag = true;

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    public boolean isFlag() {
        return flag;
    }

    @Override
    public void run() {
        while (flag) {
            System.out.println(Thread.currentThread().getName() + " : " + (int)(Math.random() * 100));
        }
        System.out.println("重要代码");
    }
}
**************************************************
public class KeyListener implements Runnable {

    private Runnable runner;

    public KeyListener(Runnable runner) {//对象关联
        this.runner = runner;
    }

    @Override
    public void run() {
        // 主线程继续监听键盘输入
        BufferedReader bufferedReader = null;
        try {
            bufferedReader = new BufferedReader(new InputStreamReader(System.in));
            String line;
            while ((line = bufferedReader.readLine()) != null) {
                if (line.equalsIgnoreCase("q")) {
                    ((StopExerRunner)runner).setFlag(false);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (bufferedReader != null) {
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
************************************************************
public class StopExerRunnerTest {

    public static void main(String[] args) {
        Runnable runner = new StopExerRunner();
        Thread thread = new Thread(runner);
        thread.start();

        Runnable runner2 = new KeyListener(runner); // 对象关联
        Thread thread1 = new Thread(runner2);
        thread1.setName("键盘监听器");
        thread1.setDaemon(true);// 必须在start前调用, 才能变成守护线程.
        thread1.start();

    }
}

（3）Sleep休眠

public class SleepRunner implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " : " + i);
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                System.out.println("在睡200毫秒时被打断");
            }
        }

        try {
            Thread.sleep(30 * 1000);
        } catch (InterruptedException e) {
            System.out.println("在睡30秒时被打断!!");
        }

        System.out.println("子线程执行完毕了");
    }
}
*************************************************************
public class SleepRunnerTest {

    public static void main(String[] args) {
        Runnable runner = new SleepRunner();
        Thread thread = new Thread(runner);
        thread.start();

        try { // 忍耐
            Thread.sleep(20500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        thread.interrupt(); // 目标是打断子线程的30秒睡眠
    }
}

Sleep升级版本

//编写程序，在main方法中创建一个线程。线程每隔一定时间（200ms以内的随机时间）
// 产生一个0-100之间的随机整数，打印后将该整数放到集合中；
//共产生100个整数，全部产生后，睡眠30秒，然后将集合内容打印输出；
//在main线程中，唤醒上述睡眠的线程，使其尽快打印集合内容
************************************************
public class SleepExerRunner implements Runnable {

    private boolean loopOver = false;

    public boolean isLoopOver() {
        return loopOver;
    }

    @Override
    public void run() {

        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            int rand = (int)(Math.random() * 100);
            System.out.println(Thread.currentThread().getName() + " : " + rand);
            list.add(rand);

            int time = (int)(Math.random() * 200);
            try {
                Thread.sleep(time);
            } catch (InterruptedException e) {
                System.out.println("在睡[" + time + "]毫秒时被打断.");
            }
        }
        loopOver = true;

        System.out.println("我要睡30秒了");
        try {
            Thread.sleep(30 * 1000);
        } catch (InterruptedException e) {
            System.out.println("在睡30秒时被打断, 严重不爽");
        }

        System.out.println("要打印集合内容了");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

    }
}
***********************************************************
public class SleepExerRunnerTest {

    public static void main(String[] args) {
        Runnable runner = new SleepExerRunner();
        Thread thread = new Thread(runner);
        thread.start();

        /*
        // 忍耐和等待
        try {
            Thread.sleep(20 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }*/
        while (!(((SleepExerRunner)runner).isLoopOver())) { // 不断地检测子线程中的for有没有执行完
            try {
                Thread.sleep(10);//一定要休眠一下
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        thread.interrupt();
    }
}

（4）线程同步

public class Counter implements Runnable {

    private int counter = 200;
    //private static Object lock = new Object();

    @Override
    //public synchronized void run() { // 这种情况下用的锁就是this对象.
    public void run() {
        //synchronized (this) { // 锁的粒度不要太大.
        for (int i = 0; i < 50; i++) {
            //synchronized (互斥锁对象) { // 只要是对象都可以作锁, 但是要保证多个线程用到的锁对象必须是同一个.
            synchronized ("") {
                // 代码块具有 原子性(不可分割性)
                counter -= 2;
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " : " + counter);
            } // 隐式的释放锁.
        }
        //}
    }
}
************************************************************************
public class CounerTest {

    public static void main(String[] args) {
        Runnable runner = new Counter();

        Thread thread1 = new Thread(runner);
        thread1.setName("线程1");
        thread1.start();

        Thread thread2 = new Thread(runner);
        thread2.setName("线程2");
        thread2.start();
    }
}

测试：柜台存钱取钱多线程同步

public class Account {

    private String name;
    private int balance;

    public Account() {}

    public Account(String name, int balance) {
        this.name = name;
        this.balance = balance;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getBalance() {
        return balance;
    }

    public void setBalance(int balance) {
        this.balance = balance;
    }

    @Override
    public String toString() {
        return "Account{" +
                "name='" + name + '\'' +
                ", balance=" + balance +
                '}';
    }
}
******************************Deposit************************************
public class Deposit implements Runnable {

    private Account account;

    public Deposit(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            synchronized ("") {
                account.setBalance(account.getBalance() + 1000);
                System.out.println(Thread.currentThread().getName() + " 存完钱后 : " + account);
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}
************************************Withdraw***************************************
public class Withdraw implements Runnable {

    private Account account;

    public Withdraw(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            synchronized ("") {
                account.setBalance(account.getBalance() - 1000);
                System.out.println(Thread.currentThread().getName() + " 取完钱后 : " + account);
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}
****************************************************************************
public class AccountTest {

    public static void main(String[] args) {
        Account account = new Account("张三", 5000);

        Runnable runner = new Deposit(account);

        Thread thread1 = new Thread(runner);
        thread1.setName("存钱柜台1");
        thread1.start();

        //Thread thread2 = new Thread(runner);
        //thread2.setName("存钱柜台2");
        //thread2.start();

        Runnable runner2 = new Withdraw(account);
        Thread thread3 = new Thread(runner2);
        thread3.setName("取钱柜台1");
        thread3.start();
    }
}