面试常见手撕代码题

Sun, 06 Oct 2019 00:00:00 +0000

常见排序算法的实现
链表
二叉树
- 二叉树的递归遍历以及（前中后序）非递归遍历
- 二叉树的层序遍历（使用/不使用额外的数据结构）
图（矩阵）的深度优先和广度优先遍历
动态规划
实现一个LRU的Cache
- 1. 使用Java自带的LinkedHashMap
- 2. 仅使用Java中的HashMap和Deque
实现一个阻塞队列
实现生产者/消费者模型
实现两个线程交替打印
文件的输入和输出
字符串转整型

常见排序算法的实现

堆排序

https://www.jianshu.com/p/11655047ab58

（升序排序）整体思路是：

初始数组表示一个未排序的原始堆
构造一个最大堆
依次将堆顶元素交换到堆尾，调整使其保持最大堆，堆尾指针前移，直到所有元素有序（堆中之剩下堆顶元素）

快速排序

快排的核心部分在于partition的实现。partition需要找到一个元素的正确位置，将其移动到这个位置，并返回这个位置。

归并排序

https://www.cnblogs.com/chengxiao/p/6194356.html

归并排序的核心在于分治。分就是把原数组一分为二，然后再分，直到每一部分只剩下最多一个元素；并就是把结果合并，当每一部分最多有一个元素的时候可以直接交换，而多于一个元素的时候可以将有序的两部分从头到尾比较排序。

在合并的时候会用到额外的空间，因此可以在一开始就定义一块和原数组相同大小的空间用于合并，避免递归过程中频繁开辟新的空间。

链表

反转链表（递归和非递归）

https://leetcode-cn.com/problems/reverse-linked-list/

非递归（头插法）

public ListNode reverseList(ListNode head) {
    ListNode newHead = null;
    while(head!=null){
        ListNode t = head.next;
        head.next = newHead;
        newHead = head;
        head = t;
    }
    return newHead;
}

递归（头插法）

public ListNode reverseList(ListNode head) {
    return reverse(null, head);
}

public ListNode reverse(ListNode newHead, ListNode head) {
    if(head==null){
        return newHead;
    }
    else{
        ListNode t = head.next;
        head.next = newHead;
        newHead = head;
        return reverse(newHead, t);
    }
}

倒数第K个节点

使用双指针的时候要注意链表的长度，要考虑第二个指针在第一次前进k个节点时出现null的情况。

检测环

使用快慢指针。

引申问题1：为什么快指针的步长是2，而不是3、4、5…？

https://blog.csdn.net/xgjonathan/article/details/18034825

结论：

无论步长为多少，快慢指针在环里都能相遇
步长设置为2能最快确定有环

引申问题2：如何确定环的入口？

s：从起始点到环入口的距离

cl：环长度

当慢指针刚好进入环中，也就是慢指针走了 s 步之后，快指针走了 2s 步，所以快指针在环中走了 2s - s = s 步；由于存在 s > cl 的情况，我们记快指针超出 ks（k为自然数）的距离是 s % cl ；此时，快指针需要追及慢指针的距离是 cl - s % cl；因此，当慢指针在环中走了cl - s % cl 步后，快指针追上了慢指针；

所以，相遇之后的慢指针距离 ks 的距离是 cl - (cl - s % cl) = s % cl 。因为有环的存在，我们可以把这个距离看成 s + M * cl，M 是正整数。所以相遇时的慢指针距离环的起始结点ks 是 s 。这时，我们再设置另一个指针从单向链表的头开始，以步长为 1 移动，移动 s 步后相遇，而这个相遇结点正好就是环的起始结点。

二叉树

二叉树的递归遍历以及（前中后序）非递归遍历

https://www.cnblogs.com/dolphin0520/archive/2011/08/25/2153720.html

二叉树的层序遍历（使用/不使用额外的数据结构）

https://blog.csdn.net/m0_37925202/article/details/80796010

图（矩阵）的深度优先和广度优先遍历

https://blog.csdn.net/jeffleo/article/details/53309286

动态规划

最长公共子串

https://segmentfault.com/a/1190000002641054

最长递增子序列

https://blog.csdn.net/u013178472/article/details/54926531

最长回文串

https://blog.csdn.net/kangroger/article/details/37742639

实现一个LRU的Cache

设计一个类LRUCache，满足以下条件：

这个类的构造函数应该传入一个int类型的参数size，表示最多可容纳多少个元素
包含方法put、get。put是放入新元素，get是获取某一个元素
当LRUCache满了之后删除最近最久未使用的元素。

1. 使用Java自带的LinkedHashMap

这种方法比较简单，就是维护一个LinkedHashMap，重写它的removeEldestEntry方法。

LinkedHashMap的三个构造参数分别表示初始大小、扩张因子、使用accessOrder排序。如果不指定第三个参数，则会按照添加的顺序排序。

public class LRUCache {
    private LinkedHashMap<String,String> cache;
    private int maxsize;
    public LRUCache(int maxsize){
        this.maxsize = maxsize;
        this.cache = new LinkedHashMap<String,String>(16,0.75f,true){
            @Override
            protected boolean removeEldestEntry(Map.Entry<String,String> eldest) {
                return this.size()>maxsize;
            }
        };
    }
    public void put(String key,String value){
        cache.put(key,value);
    }
    public String get(String key){
        return cache.get(key);
    }
}

2. 仅使用Java中的HashMap和Deque

本质上LRUCache就是一个HashMap，只不过需要使元素之间维持一定的顺序。LinkedHashMap实现了这个功能。如果不使用LinkedHashMap的话，则需要使用与其类似的思路，使用HashMap存储键值对，然后使用一个双端队列来记录访问顺序。这样效率很低，因为查询的时候需要先从队列中找到对应的key，完成一系列出队、入队操作最后再将这个key入队。

public class LRUCache {
    private HashMap<String,String> cache;
    private Deque<String> orderQueue;
    private int maxsize;

    public LRUCache(int maxsize){
        this.maxsize = maxsize;
        this.orderQueue = new ArrayDeque<>();
        this.cache = new HashMap<>();
    }
    public void put(String key,String value){
        if(cache.size()>=maxsize){
            String eldestKey = orderQueue.poll();
            cache.remove(eldestKey);
        }
        cache.put(key,value);
        orderQueue.offer(key);
    }
    public String get(String key){
        if(cache.size()<1||!cache.containsKey(key)){
            return null;
        }
        Deque<String> stack = new ArrayDeque<String>();
        String e = null;
        while(!(e=orderQueue.poll()).equals(key)){
            stack.push(e);
        }
        while(!stack.isEmpty()){
            orderQueue.offerFirst(stack.pop());
        }
        orderQueue.offer(e);
        return cache.get(key);
    }
}

实现一个阻塞队列

阻塞队列的实现需要保证多线程围绕队满/队空这两个条件来协作。当队满时，添加元素的线程应当阻塞；当队空时，获取元素的线程应当阻塞。

public  class  MyBlockingQueue<T>{
    private volatile List<T> queue;
    private int size;

    public MyBlockingQueue(int size){
        queue = new ArrayList<>();
        this.size = size;
    }

    public synchronized void put(T element) throws InterruptedException {
        while(queue.size()>=size){
            wait();
        }
        if(queue.size()==0){
            // 如果为0，则可能有其他线程在阻塞get，因此调用notifyAll
            notifyAll();
        }
        queue.add(element);
    }
    public synchronized T get() throws InterruptedException {
        while(queue.isEmpty()){
            wait();
        }
        if(queue.size()>=size){
            // 如果为size，则可能有其他线程在阻塞put，因此调用notifyAll
            notifyAll();
        }
        return queue.remove(0);
    }
}

实现生产者/消费者模型

使用上面的阻塞队列实现：

public class ProducerConsumer{
    private static MyBlockingQueue<Integer> queue;
    static class Producer extends Thread{
        private MyBlockingQueue<Integer> queue;

        public Producer(MyBlockingQueue<Integer> queue){
            super();
            this.queue = queue;
        }

        @Override
        public void run(){
            Random rnd = new Random();
            for(int i=0;i<100;i++) {
                try {
                    queue.put(i);
                    System.out.println("Producing "+i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    static class Consumer extends Thread{
        private MyBlockingQueue queue;

        public Consumer(MyBlockingQueue<Integer> queue){
            super();
            this.queue = queue;
        }

        @Override
        public void run(){
            while(true){
                try {
                    System.out.println("Consuming "+queue.get());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public static void main(String[] args){
        MyBlockingQueue<Integer> queue = new MyBlockingQueue<>(10);
        Producer p = new Producer(queue);
        Consumer c = new Consumer(queue);
        p.start();
        c.start();
    }
}

实现两个线程交替打印

两个线程围绕一个合作变量flag进行合作。

需要将flag声明为volatile，否则程序会卡住，这跟JMM有关系。理论上说，每次工作线程修改了flag都迟早会同步到主内存，但是如果while循环体为空的话，访问flag会太频繁导致JVM来不及将修改后的值同步到主内存，这样一来程序就会一直卡在一个位置。

如果不使用volatile也是可以的，将循环体里面加上一句System.out.print("")就行了，这样可以降低访问flag的频率，从而使JVM有空将工作内存中的flag和主内存中的flag进行同步。

public class PrintAlternately {
    static volatile int flag = 0;
    static class EvenThread extends Thread{
        @Override
        public void run(){
            for(int i=0;i<101;i+=2){
                while(flag!=0){}
                System.out.println(i);
                flag = 1;
            }
        }
    }
    static class OddThread extends Thread{
        @Override
        public void run(){
            for(int i=1;i<100;i+=2){
                while(flag!=1){}
                System.out.println(i);
                flag = 0;
            }
        }
    }
    public static void main(String[] args){
        EvenThread e = new EvenThread();
        OddThread o = new OddThread();
        e.start();
        o.start();
    }
}

文件的输入和输出

最长见的方法是使用BufferedReader逐行（字符流）读取文件，使用FileWriter或者BufferedWriter（字符流）写文件，区别是后者提供了方法newLine来写换行符，而前者需要手动写入\n或者\r\n来换行。

如果要求写文件的时候是在文件末尾添加，而不是整体覆盖，则FileWriter构造函数需要传入第二个参数true（表示使用append模式）。

public class WriterReader {
    public static void main(String[] args){
        try(BufferedReader reader = new BufferedReader(new FileReader("from.txt"));
            BufferedWriter writer = new BufferedWriter(new FileWriter("to.txt"));){
            String line = null;
            while((line=reader.readLine())!=null){
                writer.write(line);
                writer.newLine();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

字符串转整型

思路：应该尽快调试出来一个转化的程序，然后再考虑各种情况。面试时手撕代码时间非常有限，所以优先使代码能工作，而不是所有情况都考虑全了，发现时间不够或者疯狂调bug。

先是一个合法字符串转正整数的方法：

public int transform(String str){
    int res = 0;
    int base = 1;
    for(int i=str.length()-1;i>-1;i--){
        char ch = str.charAt(i);
        res = res + base*(ch-'0');
        base *= 10;
    }
    return res;
}

然后再考虑下面这些情况：

正负号
小数点
溢出
非法字符

考虑所有问题后，写出来的参考代码为：

public class Solution {
    public static int transform(String str) throws Exception{
        String input = str;
        
        // 先判断是否合法
        if(!valid(str)){
            throw new Exception("Invalid input string!");
        }

        // 判断正负
        boolean isNegative = false;
        if(str.charAt(0)=='-'){
            isNegative = true;
            input = input.substring(1,input.length());
        }

        // 去掉前面的0
        int t = 0;
        while(input.charAt(t)=='0'){
            t += 1;
            if(t>input.length()-1){
                return 0;
            }
        }
        input = input.substring(t, input.length());

        // 去掉小数点
        int pointIndex = getPointIndex(input);
        int extra = 0;
        if(pointIndex>-1){
            if(pointIndex==input.length()-1){
                input = input.substring(0, input.length()-1);
            }else if(input.charAt(pointIndex+1)>'4'){
                extra = 1;
                input = input.substring(0, pointIndex);
            }else{
                input = input.substring(0, pointIndex);
            }
        }

        // 第一个字符是小数点，则输出只能是0或1
        if(input.length()<1){
            return extra;
        }
        
        // 溢出判断
        String MAXPOS = Integer.MAX_VALUE+"";
        String MAXNEG = Integer.MIN_VALUE+"";
        if(isNegative){
            String temp = '-'+input;
            if(temp.length()>MAXNEG.length()){
                throw new Exception("Overflow error!");
            }else if(temp.length()==MAXNEG.length()){
                if(temp.compareTo(MAXNEG)>0){
                    throw new Exception("Overflow error!");
                }else if(temp.compareTo(MAXNEG)==0&&extra>0){
                    throw new Exception("Overflow error!");
                }
            }
        }else{
            if(input.length()>MAXPOS.length()){
                throw new Exception("Overflow error!");
            }else if(input.length()==MAXPOS.length()){
                if(input.compareTo(MAXPOS)>0){
                    throw new Exception("Overflow error!");
                }else if(input.compareTo(MAXPOS)==0&&extra>0){
                    throw new Exception("Overflow error!");
                }
            }
        }

        //当前的字符串为合法的，无符号的，只包含数字的字符串，可以直接转化为数字（按需要添加负号）
        int res = 0;
        int base = 1;
        for(int i=input.length()-1;i>-1;i--){
            char ch = input.charAt(i);
            res = res + base*(ch-'0');
            base *= 10;
        }
        return res*(isNegative?-1:1);
    }

    public static int getPointIndex(String str){
        for(int i=0;i<str.length();i++){
            if(str.charAt(i)=='.'){
                return i;
            }
        }
        return -1;
    }

    public static boolean valid(String str){
        if(str.charAt(0)=='-'&&str.length()>1){
            return valid(str.substring(1, str.length()));
        }
        int nPoint = 0;
        for(char ch:str.toCharArray()){
            if(ch=='.'){
                nPoint += 1;
                if(nPoint>1){
                    return false;
                }
            }else if(ch>'9'||ch<'0'){
                return false;
            }
        }
        return true;
    }

    public static void main(String args[]){
        //-2147483648 ~ 2147483647
        String[] strs = new String[]{
            "-2147483648.6", //Overflow error!
            "2147483647.1", //2147483647
            "0.67", //1
            "adfasdf", //Invalid input string!
            "2147483648", //Overflow error!
            "1.1.5", //Invalid input string!
            "123.", //123
            ".67" //1
        };
        for(String s:strs){
            try{
                System.out.println(transform(s));
            }catch(Exception e){
                System.out.println(e.getMessage());
            }
            
        }
    }
}

Note of java programming logic

Thu, 01 Aug 2019 00:00:00 +0000

第1章编程基础

数据基本类型有：

整数类型：byte/short/int/long，分别占1、2、4、8个字节
小数类型：float/double，分别占4、8字节
字符类型：char，占2个字节，使用常量字符串初始化时使用单引号括起来
布尔类型：boolean

基本数据类型都有对应的数组类型。

数组在存储的时候使用到了两块空间，一块存储内容本身，一块存储内容的位置，因此在赋值的时候只改变引用即可。

Java中的逻辑运算包括：

与&
或|
非!
异或^
短路与&&
短路或||

短路的意义在于，可以通过前一个表达式的值得到结果，就不会再去看后一个表达式的值。

Java中的函数有两类特殊类型的参数：数组和可变长度的参数。基本数据类型作为参数时，对其修改不会影响它本身的值，但是对数组的修改会影响原数组内容。可变长度参数int max(int min, int ... a)实际上会将这多个参数转化成数组来处理。可变长度参数必须是参数列表中的最后一个。

void函数也是可以使用return的，只不过不带值，表示提前结束函数执行：return;

第2章数据背后的二进制

整数

整数使用补码进行表示，因此正整数的表示方式与原码相同，负整数表示方式为绝对值按位取反加一。

对于byte类型，整数最大表示是01111111，即127，负数最小表示为10000000，即-128，其他类型的整数也类似，负数能多表示一个数。

位运算包括：

左移<<，右边的低位补0，高位舍弃。左移一位相当于乘以2
无符号右移>>>，右边的舍弃，左边补0
有符号右移>>，右边舍弃，左边补什么取决于最高位是什么，原来是1就补1，是0就补0.右移一位相当于除以2

逻辑运算包括：

按位与&
按位或|
按位取反~
按位异或^

小数

Java中的float类似是32位的，double类型是64位的。

在32位格式中，1位表示符号23位表示尾数，8位表示指数。

在64位格式中，1位表示符号，52位表示尾数，11位表示指数。

字符的编码

ASCII码中最高位设置为0，用剩下的7位表示字符，因此可以表示128个字符（0~127）。

GB2312用两个字节表示汉字。两个字节的最高为都是1（0表示这是一个ASCII字符）。

GBK兼容GB2312，但是低位字节最高位可能是0，因为这个编码规定汉字固定使用两个字节表示，因此都是两个两个处理，不考虑低位。

Unicode是统一编码方式，有多种方案，包括UTF-32，UTF-16和UTF-8：

UTF-32：用4个字节表示一个字符，根据最高位是第一个字节还是最后一个字节可以分为大端字节序（UTF-32-BE）和小端字节序（UTF-32LE）
UTF-16：用变长字节表示。常用字符用两个字节表示，增补字符用4个字节表示
UTF-8：用变长字节表示，编号小的使用的字节就少，编号大的使用的字节就多，位1~4不等。

在Java中，可以使用public byte[] getBytes(String charsetName)来获取一个字符串的给定编码格式的二进制形式；使用public String(byte bytes[], String charsetName)可以按照指定编码格式解读一个二进制数组位字符串。

char

char可以表示英文字符和中文字符，并且可以进行算术运算和比较，原因是char在Java中是用UTF-16BE表示的。

char本质上是一个固定占用两个字节的无符号正整数，这个正整数对应于Unicode编号，用于表示那个Unicode编号对应的字符

第3章类的基础

每个类都要有一个构造方法，如果没有定义，Java会自动生成一个默认构造方法。一旦定义了，就不会生成默认构造方法。

Java编译和运行时，都需要指定一个classpath，即类路径。类路径可以有多个，对于直接的class文件，路径就是class文件的根目录；对于jar包，路径是jar包的完整名称（包括路径和jar包名）。在windows系统中，多个路径使用分号分隔，在其他系统中，以冒号分隔。

Java运行时，会根据类的完全限定名寻找并加载类，寻找的方式就是在类路径中寻找，如果是class文件的根目录，则直接查看是否有对应的子目录及文件，如果是jar文件，则现在内存中解压文件，然后再查看是否有对应的类。

第4章类的继承

动态绑定

子类可以重写父类的非private方法，当调用的时候会动态绑定，执行子类的方法。

静态绑定

如果子类的实例变量、静态方法和静态变量与父类重名，

当通过b（静态类型Base）访问时，访问的是Base的变量和方法，当通过c（静态类型Child）访问时，访问的是Child的变量和方法，这称之为静态绑定，即访问绑定到变量的静态类型。静态绑定在程序编译阶段即可决定，而动态绑定则要等到程序运行时。实例变量、静态变量、静态方法、private方法，都是静态绑定的。

当有多个重名函数的时候，在决定要调用哪个函数的过程中，首先是按照参数类型进行匹配的，换句话说，寻找在所有重载版本中最匹配的，然后才看变量的动态类型，进行动态绑定。

一个父类的变量能不能转换为一个子类的变量，取决于这个父类变量的动态类型（即引用的对象类型）是不是这个子类或这个子类的子类。

第15章并发基础知识

15.1 线程的基本概念

线程表示一条单独的执行流，有自己的程序执行计数器，有自己的栈。在Java中有两种方式创建线程：一种是继承Thread，另一种是实现Runnable接口。不管哪种方式，最后都应该通过调用Thread的start方法来启动线程（实现Runnable接口后，应该将此Runnable对象作为参数构造一个Thread对象）。直接调用run方法并不会启动一条单独的执行流，而是会将其作为一个普通方法在主线程中执行。

使用Thread的静态方法currentThread可以返回当前执行的线程对象。

线程有以下基本属性和方法：

id和name：id是递增的整数，name可以通过setName设置；
优先级：优先级只是一种建议，而非强制；
状态：包含NEW, TERMINATED, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING；
是否为daemon线程：当程序中只剩下daemon线程时，程序会退出。垃圾回收线程也是daemon线程；
sleep方法：睡眠期间，该线程会让出CPU。睡眠期间可以被中断，抛出InterruptedException；
yield方法：静态方法，建议让其他线程运行，并非强制；
join方法：如果在线程A中调用B.join()，那么线程A会等待线程B执行完再继续执行。

竞态条件：当多个线程访问和操作同一个对象时，最终执行结果与执行时序有关，可能正确也可能不正确。

内存可见性问题：因为数据会被存储到内存、CPU的寄存器以及各级缓存中，所以当一个线程访问一个变量的时候，访问到的不一定是最新的值（主要是多处理器会有多个缓存，他们一般会周期性同步）。

解决内存可见性的方法一般是：

使用volatile关键字
使用synchronized关键字或显式锁同步

15.2 理解synchronized

synchronized有三种使用方法：实例方法、静态方法和代码块。

实例方法

synchronized实例方法实际保护的是同一个对象的方法调用，因此多个线程可以执行同一个synchronized实例方法，只要他们属于不同对象。

同一个对象中的不同synchronized方法是不能同时执行的，但是非synchronized方法可以和synchronized方法同时执行，所以，一般在保护变量时，需要在所有访问该变量的方法上加上synchronized。

静态方法

synchronized修饰的静态方法同样保护的是一个对象，只不过是类对象。因此synchronized修饰的静态方法和实例方法保护的是不同的对象，他们可以同时执行。

代码块

synchronized代码块可以传入参数指定保护哪一个对象，比如synchronized(this){//code block}。

synchronized有三个特性：可重入性、内存可见性和可能出现死锁。

可重入性

可重入性表示：对同一个线程，它在获得了锁之后，如果要调用其他需要同样锁的代码，可以直接调用。并不是所有锁都是可重入的。

可重入是通过记录锁的持有线程和持有数量来实现的。

当调用被synchronized保护的代码时，检查对象是否已被锁，如果是，再检查是否被当前线程锁定，如果是，增加持有数量，如果不是被当前线程锁定，才加入等待队列，当释放锁时，减少持有数量，当数量变为 0 时才释放整个锁。

马俊昌. Java编程的逻辑 (Java核心技术系列) (Kindle 位置 8524-8526). 北京华章图文信息有限公司. Kindle 版本.

内存可见性

synchronized能保证内存可见性，在释放锁时，所有写入都会写回内存，而获得锁后，都会从内存读最新数据。

不过如果只是为了保证内存可见性，synchronized成本过高，可以直接使用关键字volatile修饰变量，保证读写到内存的最新值，而非缓存的值。

死锁

如果两个线程分别请求相同的两个锁，但是请求顺序相反，那么就可能出现死锁（相互等待对方释放锁）。为了避免死锁，应该：

尽量避免在持有一个锁的同时去申请另一个锁
如果要申请多个锁，所有代码都应该按照相同的顺序去申请锁

使用jstack可以检查是否发生了死锁，以及死锁的情况。

类Collection的一些方法可以返回线程安全的同步容器，比如synchronizedCollection、synchronizedList、synchronizedMap，他们是给所有容器方法都加上synchronized来实现安全的，因此性能比较低，一般使用下面这些容器类来实现线程安全：

CopyOnWriteArrayList
ConcurrentHashMap
ConcurrentLinkedQueue
ConcurrentSkipListSet

15.3 线程的基本协作机制

wait/notify

wait方法和notify方法都是Object类定义的方法。

因为wait/notify方法是围绕某一个协作变量工作的，容易出现竞态条件，所以一般只能在synchronized代码块内被调用。如果调用wait/notify时，当前线程没有持有锁，会抛出异常。

每个对象除了有一把锁和等待队列，还有一个条件队列用于线程间的协作。当调用wait方法时，会将当前线程放到条件队列上并阻塞，表示当前线程执行不下去了，需要等待一个条件，这个条件它自己改变不了，需要其他线程去改变。当其他线程改变了条件之后，会调用这个对象的notify方法。

notify方法的作用就是从条件队列中选择一个线程，将其从队列中移除并唤醒。notifyAll方法会移除条件队列中的所有线程并全部唤醒。

一般wait的调用方式是：

synchronized(obj){
    while(条件不成立)
        obj.wait();
    ...//执行条件成立后的操作
}

其中的“条件”一般是指协作变量。

wait/notify的原理

虽然wait被synchronized保护，但是调用wait时，线程会释放对象锁。wait的过程为：

把当前线程放入条件等待队列，释放对象锁，阻塞等待，线程状态变为WAITING或TIMED_WAITING；
等待时间到或被其他线程调用notify/notifyAll时从条件队列中移除，这时要重新竞争对象锁：
1. 如果能获得锁，线程状态变为RUNNABLE，并从wait调用中返回。
2. 否则，线程进入对象锁等待队列，线程状态变为BLOCKED，只有在获得锁之后才会从wait调用中返回。

调用notify会把条件队列中等待的线程唤醒并从等待队列中移除，但是不会立即释放对象锁，只有在包含notify的synchronized代码块执行完后，等待的线程才会从wait调用中返回。

生产者/消费者模式

生产者/消费者模式围绕一个队列工作，队列满时生产者需要等待队列不满，队列空时消费者需要等待队列不空。

实现这个模式的时候应该使用notifyAll而不是notify，避免唤醒的是同类线程。

Java提供了专门的阻塞队列实现：

接口BlockingQueue和BlockingDeque；
ArrayBlockingQueue；
LinkedBlockingQueue和LinkedBlockingDeque；
PriorityBlockingQueue

同时开始

在同时开始这个模型中，所有线程都等待同一个开始信号（协作变量）。

等待结束

join()方法实际上调用的是wait，主要代码是：

while(isAlive()){
    wait(0);
}

集合点

多个线程分头行动，各自到达一个集合点，在集合点需要集齐所有线程，交换数据，然后进行下一步动作。协作的共享变量可以是线程的个数，等待条件为这个变量减为0。

15.4 线程的中断

停止一个线程的主要方法是中断（interrupt），中断不是强迫终止一个线程，它是一种协作机制，给线程传递一个信号，但是由线程来决定如何以及何时退出。

线程不同状态对interrupt的反应是不同的：

RUNNABLE：如果再运行中且没有执行IO操作，interrupt只是设置中断标志位，没有其他作用。线程应该再运行过程中合适的位置检查中断标志位，比如循环的开始处。
WAITING/TIMED_WAITING：会抛出InterruptedException，中断标志位被清空，所以抛出异常后输出isInterrupted会输出false。处理这类异常时，应该先清理，再调用interrupt设置中断标志位，告诉其他代码知道发生了中断。
BLOCKED：只会设置线程的中断标志位，而线程依然会处于BLOCKED状态。使用synchronized关键字获取锁的过程中不响应中断请求，显式锁Lock接口支持以响应中断的方式获取锁。
NEW/TERMINATE：没有任何效果，中断标志位也不会被设置。

作为线程的实现者，应该提供明确的取消/关闭方法，并用文档描述清楚其行为；作为线程的调用者，应该使用其取消/关闭方法，而不是贸然调用interrupt。

第16章并发包的基石

16.1 原子变量和CAS

原子变量包括AtomicBoolean, AtomicInteger, AtomicLong, AtomicReference，以及针对数组类型的AtomicLongArray等。

原子变量的关键在于，它包含了一些以原子方式实现组合操作的方法，比如（以AtomicInteger为例）：

int getAndSet(int newValue)
int getAndIncrement()
int getAndDecrement()
int getAndAdd(int delta)
int incrementAndGet()
int decrementAndGet()

这些方法都依赖一个方法：compareAndSet，简称CAS。CAS操作有两个参数expect和update，如果当前值等于expect，则更新为update并返回true，否则不更新并返回false。

一般原子操作的主体都是死循环，更新失败则不断循环，直到更新成功为止。

CAS是乐观的，假设有较少的冲突情况；synchronized是悲观的，假设很可能发生冲突。

使用CAS方式更新有可能出现ABA问题，这是一个与程序的逻辑有关的问题，一般不是问题。Java中解决的办法是使用AtomicStampedReference，改值的同时附加一个时间戳，只有值和时间戳都相同才修改。

Java并发包中提供了一些非阻塞容器，比如：

ConcurrentLinkedQueue和ConcurrentLinkedDeque：非阻塞并发队列
ConcurrentSkipListMap和ConcurrentSkipListSet：非阻塞并发Map和Set

16.2 显式锁

显式锁位于java.util.concurrent.locks下；锁接口Lock，主要实现类是ReentrantLock；读写锁接口ReadWriteLock，主要实现类是ReentrantReadWriteLock。

Lock中的方法有：

lock()/unlock()：普通的获取锁和释放锁，lock()会阻塞直到成功；
lockInterruptibly()：获取锁，可响应中断。如果被中断了则抛出InterruptedException；
tryLock()：非阻塞地尝试获取锁，立即返回。如果获取成功则返回true，否则返回false。
tryLock(long time, TimeUnit unit)：先尝试获取锁，如果成功则立即返回true；否则阻塞等待，最长等待时间是time；在等待的同时响应中断，会抛出InterruptedException；如果等待后获得了锁则返回true，否则返回false。
newCondition：新建一个条件，一个Lock可以关联多个条件。

使用显式锁，一定要记得调用unlock。一般将lock之后的代码包装到try语句内，在finally语句内释放锁。

使用tryLock()可以避免死锁。在持有一个锁获取另一个锁失败的时候，可以释放已持有的锁，然后重试获取所有锁。

ReentrantLock的实现原理

在最底层，ReentrantLock依赖于CAS，而在Java中首先是依赖于类LockSupport。

LockSupport类里包含这些方法：

public static void park() 
public static void parkNanos( long nanos) 
public static void parkUntil( long deadline) 
public static void unpark( Thread thread)

park使得当前线程放弃CPU，进入等待状态（WAITING），操作系统不再对它进行调度，什么时候再调度呢？有其他线程对它调用了unpark，unpark使参数指定的线程恢复可运行状态。

park是响应中断的，当有中断发生时，park会返回，中断标志位会被设置。

parkNanos可以设置最长等待时间；parkUntil可以设置等待到什么时候，是相对于纪元时的毫秒数。

LockSupport中的park/unpark方法是调用了Unsafe类中的对应方法（和CAS相同）。

ReentrantLock直接依赖的类是AQS（AbstractQueuedSynchronizer）。

AQS

ReentrantLock内部有三个类和AQS有关：

abstract static class Sync extends AbstractQueuedSynchronizer 
static final class NonfairSync extends Sync 
static final class FairSync extends Sync

ReentrantLock默认使用NonfairSync。ReentrantLock内部使用state表示是否被锁以及持有数量，如果未被锁定则立即获得锁，否则调用acquire(1)获得锁。acquire是AQS中的方法。

对比ReentrantLock和synchronized

相比synchronized，ReentrantLock可以实现与synchronized相同的语义，而且支持以非阻塞方式获取锁，可以响应中断，可以限时，更为灵活。不过，synchronized的使用更为简单，写的代码更少，也更不容易出错。

synchronized代表一种声明式编程思维，程序员更多的是表达表达一种同步声明，由Java系统负责具体实现，程序员不知道其实现细节；显式锁代表一种命令式编程思维，程序员实现所有细节。

声明式编程的好处除了简单，还在于性能，在较新版本的JVM上，ReentrantLock和synchronized的性能是接近的，但Java编译器和虚拟机可以不断优化synchronized的实现，比如自动分析synchronized的使用，对于没有锁竞争的场景，自动省略对锁获取/释放的调用。

简单总结下，能用synchronized就用synchronized，不满足要求时再考虑Reentrant-Lock。

16.3 显式条件

wait/notify与synchronized配合使用，显式条件与显式锁配合使用。

创建条件变量需要调用显示锁的newCondition()方法。

Condition是一个接口，定义为：

public interface Condition{
	void await() throws Interrupted Exception;
    void await Uninterruptibly();
    long awaitNanos(long nanosTimeout) throws InterruptedException;
    boolean await(long time,TimeUnit unit) throws InterruptedException;
    boolean awaitUntil(Date deadline) throws InterruptedException;
    void signal();
    void signalAll();
}

其中，await功能与wait类似，signal/signalAll与notify/notifyAll类似。Condition对象也是有wait和notify/notifyAll方法的，因为这些方法属于对象，但是在这里不能使用，因为wait和notify/notifyAll只能在synchronized中使用，一定不能混淆。

第17章并发容器

17.1 写时复制

写时复制的类主要有CopyOnWriteArrayList和CopyOnWriteArraySet。

写时复制的含义是：每次修改操作，都会新建一个数组，复制原数组的内容到新数组，在新数组上进行需要的修改，然后以原子方式设置内部数组的引用。所有的读操作都是拿到当前引用的数组，然后直接访问该数组，修改操作不会影响读。

CopyOnWriteArrayList特点有:

线程安全，可以被多个线程并发访问；
迭代器不支持修改；
以原子方式支持一些复合操作：addIfAbsent(E e)和addAllAbsent(Collection<? extends E> c)。

CopyOnWriteArraySet是基于CopyOnWriteArrayList实现的。

17.2 ConcurrentHashMap

HashMap中可能发生的并发问题：多个线程同时扩容哈希表的时候，可能会出现死循环。

ConcurrentHashMap实现了Map接口和ConcurrentMap接口，ConcurrentMap接口定义了一些原子复合操作：

V putIfAbsent(K key, V value)
boolean remove(Object key, Object value)
boolean replace(K key, V oldValue, V newValue)
V replace(K key, V value)

在Java 7中ConcurrentHashMap实现高并发的原因有：

分段锁
读不需要锁

内部使用了CAS实现，达到的效果是：对于写操作，需要获取锁，不能并行，但是读操作可以，多个读可以并行，写的同时可以读。

Java 8中对ConcurrentHashMap的实现进一步做了优化，首先是在哈希冲突比较严重的时候将单链表转化为平衡的排序二叉树，提高查找效率；其次是细化了锁的力度，改成了每一个哈希桶（指向一个单链表或树）都有一个单独的锁。

ConcurrentHashMap的弱一致性：创建迭代器后，会按照哈希表的结构遍历每个元素，但是在遍历中，内部元素可能会发生变化，如果变化发生在已遍历过的部分，迭代器就不会反映出来，而如果变化发生在未遍历过的部分，迭代器就会发现并反映出来。

###17.3 基于跳表的Map和Set

TreeMap/TreeSet对应的并发版本是ConcurrentSkipListMap和ConcurrentSkipListSet，其中ConcurrentSkipListSet是基于ConcurrentSkipListMap实现的。

ConcurrentSkipListMap的特点有：

没有使用锁，所有操作都是无阻塞的，所有操作都可以并行，包括写，多线程可以同时写。
弱一致性
实现了CurrentMap接口，支持一些原子复合操作
可排序，实现了SortedMap和NavigableMap接口

17.4 并发队列

并发队列包括：

类型	包含的类
无锁非阻塞并发队列	ConcurrentLinkedQueue、ConcurrentLinkedDeque
普通阻塞队列	基于数组的ArrayBlockingQueue，基于链表的LinkedBlockingQueue和LinkedBlockingDeque
优先级阻塞队列	PriorityBlockingQueue
延时阻塞队列	DelayQueue
其他阻塞队列	SynchronousQueue和LinkedTransferQueue

无锁非阻塞：不使用锁，所有操作总是可以立即执行，主要通过循环CAS实现并发安全。

阻塞队列：使用锁和条件，很多操作都需要先获取锁或满足特定条件。获取不到锁或等待条件时，会等待（阻塞），获取到锁或满足条件再返回。

这些队列迭代都不会抛出ConcurrentModificationException，都是弱一致性的。

无锁非阻塞并发队列

适用于多个线程并发使用一个队列的场合，特点有：

基于链表实现
没有限制大小

普通阻塞队列

常用于生产者/消费者模式。

ArrayBlockingQueue基于循环数组实现，有界，创建时需指定大小，且再运行过程中不会改变。

LinkedBlockingQueue基于单向链表实现，可选择指定最大长度，默认无限。

内部，两者都是使用显示锁ReentrantLock和显式条件Condition实现。

优先级阻塞队列

大部分结构都与PriorityQueue相同，包括使用堆结构，没有大小限制，要求元素实现Comparable结构或者主动提供Comparator等。

区别在于，PriorityBlockingQueue实现了BlockingQueue接口。使用ReentrantLock和Condition实现并发。

延时阻塞队列

是一种特殊的优先级队列，无界，要求每个元素都实现Delayed接口。

Delayed扩展了Comparable接口，包含一个额外的方法getDelay，用于返回再延迟多少时间，如果小于或等于0则不再延迟。

DelayQueue可以用于实现定时任务，按元素的延时时间出列，只有当元素的延时过期之后才能被拿走。

DelayQueue是基于PriorityQueue实现的。

其他阻塞队列

SynchronousQueue

LinkedTransferQueue

第18章异步任务执行服务

18.1 基本概念和原理

异步任务执行服务设计到的基本接口有：

Runnable和Callable：表示要执行的异步任务
Executor和ExecutorService：表示执行服务
Future：表示异步任务的结果

Runnable没有返回结果，而Callable有；Runnable不会抛出异常，而Callable会。

Executor表示最简单的执行服务，只包含一个void execute(Runnable command)；ExecutorService扩展了Executor，包含一系列的submit方法（返回Future）。

Future包含的方法有：

cancel：取消异步任务
get：返回异步任务的最终结果
isCancelled
isDone

get用于返回异步任务最终的结果，如果任务还未完成，会阻塞等待；另外有一个get可以设置时间，超时任务还未结束则会抛出TimeoutException。

任务最大概有三种结果：

正常完成，返回执行结果；如果是Runnable且未设置结果，返回null
任务执行抛出了异常，get方法会将异常包装位ExcecutionException重新抛出，通过异常的getCause可以获取原异常
任务被取消了，get方法会抛出异常CancellationException
调用get方法的线程被中断了，抛出InterruptedException

18.2 线程池

线程池主要由两个概念组成：任务队列和工作者线程。工作者线程主体是一个循环，循环从队列中接受任务并执行，任务队列保存待执行的任务。

线程池的优点有：

可以重用线程，避免线程创建的开销；
任务过多时，通过排队避免创建过多线程，减少系统资源消耗和竞争，确保任务有序完成。

Java并发包中线程池的实现类是ThreadPoolExecutor，它继承自AbstractExecutorService，实现了ExecutorService。

线程池的大小主要与4个参数有关：

corePoolSize：核心线程个数；
maximumPoolSize：最大线程个数；
keepAliveTime和unit：空闲线程存活时间。

ThreadPoolExcecutor要求的队列类型是阻塞队列。

ThreadPoolExecutor实现了生产者/消费者模式，工作者线程是消费者，任务提交者是生产者，线程池自己维护任务队列。当遇到类似生产者/消费者问题时，应该优先考虑直接使用线程池。

18.3 定时任务

在Java中，主要有两种方式实现定时任务：

使用java.util包中的Timer和TimerTask
使用Java并发包中的ScheduledExecutorService

Timer内部主要由任务队列和Timer线程两部分组成。任务队列是基于堆实现的优先级队列，按照下次执行的时间排优先级。一个Timer对象只有一个Timer线程。

ScheduledThreadPoolExecutor的实现思路与Timer基本类似，都有一个基于堆的优先级队列，保存待执行的定时任务，不同在于：

它的背后是线程池，可以有多个线程执行任务；
它在任务执行后在设置下次执行的时间，对于固定延时的任务更为合理；
任务执行线程会捕获任务执行过程中的所有异常，一个定时任务的异常不会影响其他定时任务，不过，发生异常的任务不会再被调度。

第19章同步和协作工具类

第21章反射

反射是在运行时，而非编译时，动态获取类型的信息，比如接口信息、成员信息、方法信息、构造方法信息等，根据这些动态获取到信息创建对象、访问/修改成员、调用方法等。

获取类对象的方法有：

使用Object类的getClass方法（基本类型不可用）
使用类名.class获取，基本类型可用
使用Class.forName方法根据类名获取类对象

反射和泛型

虽然在运行时，泛型参数会被擦除，但是类信息Class中依然有关于泛型的一些信息，可以通过反射得到：

//Class中的
public TypeVariable<Class<T>> [] getTypeParameters() 

//Field中的    
public Type GetGenericType() 

//Method中的
public Type getGenericReturnType()
public Type[] getGenericParameterTypes()
public Type[] getGenericExceptionTypes()
    
//Constructor
public Type[] getGenericParameterTypes()

反射的优点是灵活，缺点有：

更容易出现运行时错误，因为使用反射的话类型是运行时才知道的，编译器无法检查；
反射的性能更低一些，在访问字段、调用方法前，反射要先查找对应的Field/Method

因此，如果能用接口实现同样的灵活性，就不要使用反射。

第22章注解

Java的内置注解有：

注解	含义
@Override	表示重写了父类的该方法
@Deprecated	过时了，不建议使用
@SupressWarnings	压制Java的编译警告，可以指定压制哪些类型的警告

创建注解的关键字为@interface，有两个元注解@Target和@Retention。

@Target表示注解的目标，是一个ElementType的枚举值，可以有多个（用{}表示）包含：

TYPE：表示类、接口、注解或枚举声明
FIELD：字段
METHOD：方法
PARAMETER：方法参数
CONSTRUCTOR：构造方法
LOCAL_VARIABLE：本地变量
MODULE：模块（Java 9引入的）

@Target默认适用于所有类型。

@Retention表示注解信息保留到什么时候，值为RentionPolicy的枚举类型，可以是：

SOURCE：仅保留到源代码
CLASS：保留到字节码文件中
RUNTIME：保留到运行时

@Retention默认为CLASS。

注解可以设置参数，不过参数类型只能是基本类型、String、Class、枚举、注解以及这些类型的数组。

可以用反射来获取注解类型：

//获取所有注解
public Annotation[] getAnnotations();

//获取所有本元素上直接声明的注解
public Annotation[] getDeclaredAnnotations();

//获取指定类型的注解，没有返回null
public <A extends Annotation> A getAnnotation(Class<A> annotationClass);

//判断是否有指定类型的注解
public boolean isAnnotationPresent(Class<? extends Annotation> annotations)

第23章动态代理

23.1 静态代理

public class SimpleStaticProxyDemo { 
    static interface IService { 
        public void sayHello(); 
    } 
    static class RealService implements IService { 
        @Override
		public void sayHello() { 
            System. out. println(" hello"); 
        } 
    } 
    static class TraceProxy implements IService { 
        private IService realService; 
        public TraceProxy( IService realService) { 
            this. realService = realService; 
        } 
        @Override public void sayHello() { 
            System. out. println(" entering sayHello"); 
            this. realService. sayHello(); 
            System. out. println(" leaving sayHello"); 
        } 
    } 
    public static void main( String[] args) { 
        IService realService = new RealService(); 
        IService proxyService = new TraceProxy( realService); 
        proxyService. sayHello(); 
    } 
}

在上面的例子中，我们想达到的目的是在实际对象的方法调用前后加一些调试语句。为了在不修改原类的情况下达到这个目的，我们在代码中创建了一个代理类 TraceProxy，它的代码是在写程序时固定的，所以称为静态代理。

第24章类加载机制

24.1 类加载的机制和过程

运行Java程序，就是执行java这个命令，指定包含main方法的完整类名，以及一个classpath，即类路径。类路径可以有多个，对于直接的class文件，路径是class文件的根目录，对于jar包，路径是jar包的完整名称（包括路径和jar包名）。

Java运行时，会根据类的完全限定名寻找并加载类，寻找的方式基本就是在系统类和指定的类路径中寻找，如果是class文件的根目录，则直接查看是否有对应的子目录及文件；如果是jar文件，则首先在内存中解压文件，然后再查看是否有对应的类。

负责加载类的类就是类加载器，它的输入是完全限定的类名，输出是Class对象。一般类加载器有3个（Java9之前）：

启动类加载器（Bootstrap ClassLoader）：是Java虚拟机实现的一部分，负责加载Java的基础类（String、ArrayList等）；
扩展类加载器（Extension ClassLoader）：负责加载扩展类，一般是位于JAVA_HOME/lib/ext中的jar包；
应用程序类加载器（Application ClassLoader）：负责加载应程序的类，包括自己写的和引入的第三方类库，即所有在类路径中指定的类。

双亲委派模型

加载一个类的过程为：

判断是否已被加载，加载过了则直接返回Class对象，一个类只会被一个ClassLoader加载一次；
如果没有被加载，先让父ClassLoader去加载，如果加载成功，返回得到的Class对象；
在父ClassLoader没有加载成功的前提下，自己尝试加载类

双亲委派模型的好处是：避免Java类库被覆盖的问题。如果用户也定义了一个类java.lang.String，通过双亲委派，java.lang.String只会被Bootstrap ClassLoader加载，避免自定义的String覆盖Java类库中的定义。

24.2 ClassLoader和forName加载类的区别

调用Class的forName方法来加载类有两个方法：

public static Class<?> forName(String className);
public static class<?> forName(String name, boolean initialize, ClassLoader loader);

forName是可以设置是否执行初始化代码（static语句块）的，而且默认执行；而ClassLoader的loadClass不会执行类的初始化代码。

Wordlist - Harry Potter VI

Sat, 22 Jun 2019 00:00:00 +0000

Phrases
Words
- insubstantial
- duplicity
- tribute
- ★ quarry
- octave
- crescent
- graze
- forthwith
- teeming
- ★ itch
- omniscient
- henchman
- ★ obliterate
- juncture
—
- unrequited
- ★ attendant
- sap
- squire
- squalid
- ★ ado
- ★ grandeur
- blackcurrant
- oblivious
  - impart
- ★ grimace
  - forestall
- matron

Phrases

Words

insubstantial

脆弱的，不坚固的；虚幻的

The castle ghosts were there too, barely visible in the bright sunlight, discernible only when they moved, shimmering insubstantially in the gleaming air.

duplicity

口是心非，虚伪

… asked Harry, who wanted every detail of Snape’s duplicity and infamy, feverishly collecting more reasons to hate him, to swear vengeance.

tribute

赞辞，献礼

Our students should pay tribute, it is fitting.

★ quarry

猎物

Distracted by the flames, the Inferi seemed unaware that their quarry was leaving as Dumbledore led Harry back to the boat.

octave

（音）八度

‘Someone’s dead,’ said Malfoy and his voice seemed to go up an octave as he said it.

crescent

新月，弦月

… illuminated by the light of the crescent moon.

graze

v. 擦破皮

Harry wiped his grazed forarm upon the stone.

forthwith

adv. 立即，毫不拖延地

Hagrid, please tell the Heads of House - Slughorn can represent Slytherin - that I want to see them in my office forthwith.

teeming

拥挤的，热闹的

The great black lake, teeming with the dead.

★ itch

发痒；渴望

(Harry) was itching to try the charm out, but thought it best not to in front of Hermione.

omniscient

博识的，无所不知的

You are omniscient as ever, Dumbledore.

henchman

心腹

Why are you come here tonight, surrounded by henchmen, to request a job we both know you do not want?

★ obliterate

消除…的痕迹，抹除

The files were obliterated in file.

The heavy snow obliterated their footprints.

She tried to obliterate the unpleasant experiences.

juncture

时机，关头；连接处

It seemed extraordinary that Hermione’s mania for upholding rules could have abandoned her at this crucial juncture.

—

unrequited

单相思的，得不到回报的

Of course, it is also possible that her unrequited love and the attendant despair sapped her of her powers; that can happen.

★ attendant

伴随的

nuclear power, with all its attendant risks.

sap

使虚弱

squire

乡绅

You can imagine the gossip it caused when the squire’s son ran off with the tramp’s daughter Merope.

squalid

肮脏邋遢的

She was standing beside a steaming pot on a grimy black stove, and was fiddlig around with the shelf of squalid-looking pots and pans above it.

★ ado

忙乱，纷杂

Herbology, Arithmancy, Ancient Runes and Potions, and shot off to a first-period Ancient Runes class without further ado.

★ grandeur

伟大，壮观

Lack of sense coupled with a great liking for grandeur meant that the family gold was squandered several generations before Marvolo was in charge.

blackcurrant

黑加仑

Her potion already resembled the ‘smooth, blackcurrant-coloured liquid’.

oblivious

健忘的

Seemingly oblivious to the sensational nature of the news he had just imparted, Dumbledore said nothing more about staff appointments.

impart

透露，通知

★ grimace

/gri’meis/

扮鬼脸

‘When we were in Diagon Alley -‘ Harry began, but Mr Weasley forestalled with him with a grimace.

forestall

预先阻止

matron

护士长

… to visit Madam Pomfrey, the matron, …

Start Redis

Mon, 17 Jun 2019 00:00:00 +0000

Tutorial
- 开始
- 列表
- 集合
- 哈希（对象）
- 更多

Tutorial

Tutorial是 try.redis.io 中入门内容的总结。

开始

Redis使用“键值对”存储数据。Redis中的命令大小写皆可。

Redis中的String类型数据可以不加双引号。

使用SET key value存储值，使用GET key取值。

> SET server:name "fido"
OK
> GET server:name
"fido"

其他一些简单的命令：

命令	含义
INCR	使这个键对应的值增加1。如果这个键之前不存在，则设置为1（不会报错）。
DEL	删除这个键

使用INCR命令实现自增，而不使用传统的“取值->加一->设定值”，原因是这样可以保证这一操作的原子性，避免多线程读写数据可能会发生的冲突。

> GET newkey
(nil)
> INCR newkey
(integer) 1

Redis中的数据（键值对）可以通过EXPIRE设置有效时间和用TTL查看剩余时间（单位是秒）。

> SET resource:lock "demo" 
OK
> EXPIRE resource:lock 120
(integer) 1
> TTL resource:lock
(integer) 109

列表

Redis支持列表作为值，列表相关的操作有：

命令	含义
RPUSH	在列表末端添加值
LPUSH	在列表头部添加值
LRANGE	获取子列表，两端包含
LLEN	获取列表长度
LPOP	获取第一个元素并将其从列表中删除
RPOP	获取最后一个元素并将其从列表中删除

需要注意的是：

如果之前没有这个键，也是可以直接push的
不能通过GET操作来获取所有的元素，只能用LRANGE key 0 -1

> RPUSH students "Alice"
(integer) 1
> RPUSH students "Bob"
(integer) 2
> RPUSH students "Harry"
(integer) 3
> RPUSH students "Ron"
(integer) 4
> GET students
(error) WRONGTYPE Operation against a key holding the wrong kind of value
> LRANGE students 0 -1
1) "Alice"
2) "Bob"
3) "Harry"
4) "Ron"

集合

Redis支持无序集合作为值，相关的操作有：

操作	含义
SADD	添加元素
SREM	删除元素
SISMEMBER	查询集合是否包含某元素
SMEMBERS	查看集合中的所有元素
SUNION	求两个集合的并集

> SADD fruits "apple"
(integer) 1
> SADD fruits "pear"
(integer) 1
> SADD fruits "banana"
(integer) 1
> SREM fruits "apple"
1
> SMEMBERS fruits
1) "banana"
2) "pear"
> SISMEMBER fruits "apple"
(integer) 0

Redis中的无序集合可能存在一些问题，所以从1.2版本之后引入了有序集合的概念（“Sorted Sets”）。有序集合添加元素的方式为：ZADD key score value，其中key为键，score为分数（用于排序），value为值。

使用ZRANGE key begin_index end_index可以查看key对应的集合中第begin_index到第end_index的元素。

> ZADD scores 89 "math"
(integer) 1
> ZADD scores 100 "nature"
(integer) 1
> ZADD scores 33 "physics"
(integer) 1
> ZADD scores 33 "chemistry"
(integer) 1
> ZRANGE scores 0 -1
1) "chemistry"
2) "physics"
3) "math"
4) "nature"

哈希（对象）

Redis同样支持哈希数据结构（Hashes）作为值。类似于javascript中的对象类型（或者JSON），哈希结构包含多个键值对，非常适合用于存储对象。

哈希结构相关的操作有：

命令	含义
HSET	设置（或添加）属性
HGETALL	获取所有属性
HMSET	一次设置多个属性
HGET	获取一个哈希对象的某一个属性
HINCRBY	将某一个值增加一个量
HDEL	删除这个对象的某一个属性

> HSET mycomputer memory "16GB"
(integer) 1
> HSET mycomputer graphic-card "Nvidia"
(integer) 1
> HSET mycomputer hard-disk "1TB Seagate"
(integer) 1
> HGETALL mycomputer
1) "memory"
2) "16GB"
3) "graphic-card"
4) "Nvidia"
5) "hard-disk"
6) "1TB Seagate"
> HGET mycomputer graphic-card
"Nvidia"

更多内容参考：

Wordlist - Harry Potter V

Mon, 27 May 2019 00:00:00 +0000

Phrases
- trestle table
Words
- nutcase
- senile
- retaliate
- mallet
- edgy
- misshapen
- bladder
- slur
- placate
- gouge
- repressive
- drift
- moron
- swipe
- traipse
- exemplary
—
- unravel
- astrology
- blinkered & fettered
- pungent
- foolproof
- impassive
- squally
- lad
- killjoy
- otter
- gambol
- sham
- callous
- pustule
- unimpaired
- blatant
- corpulent
- manhandle
- ogle
- snag
—
- delusion
- wobble
- pandemonium
- soppy
- meadow
- quake
- exhale
- lank
- angular
- liaise
- frisk

Phrases

trestle table

台桌，在台架上铺板的桌子

… a long trestle table in front of her laden with twigs.

Words

nutcase

疯子

It’s just that before the truth could sink in, everyone went home for the summer, where they spent two months reading about how you’re a nutcase and Dumbledore’s going senile.

senile

年迈的

retaliate

反击

‘Don’t start arguing again,’ said Harry wearily, as Ron opened his mouth to retaliate.

mallet

木槌

One by one, as though hit over the head with an invisible mallet, the first-years were slumping unconscious in their seats.

edgy

急躁的，紧张不安的

Hermione stared down at her blank piece of parchment for a few seconds, then said edgily, ‘Oh, it’s no good, I can’t concentrate now. I’m going to bed.’

misshapen

畸形的

Hermione pulled out two misshapen woolly objects, placed them carefully on a table by the fireplace.

bladder

囊，囊状物

They didn’t look anything like hats to me, more like woolly bladders.

slur

诋毁

Still angry about Ron’s slur on her woolly hats, Hermione did not join them.

placate

安抚，抚慰

It is wise to have a gift of woodlice ready to distract or placate it.

gouge

戳，凿

If angered they will try to gouge at human eyes with their fingers.

repressive

抑制的，压抑的

‘Never you mind,’ said Professor Grubbly-Plank repressively, which had been her attitude last time Hagrid had failed to turn up for a class, too.

drift

大致的意思

Maybe he’s been messing with stuff that’s boo big for him, if you get my drift.

My German isn’t very good, but I got the drift of what she said.

moron

蠢人，笨蛋

So even if that overgrown moron does show up again, he’ll probably be sent packing straightaway.

swipe

猛击

Harry had gripped the Bowtruckle so hard that it had almost snapped, and it had just taken a great retaliatory swipe at his hand with its sharp fingers.

traipse

疲惫地走，拖着脚走

Together, they traipsed across the vegetable patch.

exemplary

模范的

‘Because she’ll never be as good as Hagrid,’ said Harry firmly, fully aware that he had just experienced an exemplary Care of Magic Creatures lesson and was thoroughly annoyed about it.

—

unravel

解开

Centaurs have unravelled the mysteries of these movements over centuries.

astrology

占星术

Professor Trelawney did astrology with us!

blinkered & fettered

blinkered：戴上眼罩的，蒙蔽双眼的 fettered：带上脚拷，受束缚的

’- is a human,’ said Firenze simply. ‘And is therefore blinkered and fettered by the limitations of your kind.’

pungent

刺鼻的

… and Firenze told them to look for certain shapes and symbols in the pungent fumes.

foolproof

错不了的，不会出毛病的

His priority did not seem to be to teach them what he knew, but rather to impress upon them that nothing, not even centaurs’ knowlege, was foolproof.

impassive

面无表情的，平静的

Firenze looked at Harry impassively.

squally

有狂风的

lad

小伙子，老弟

Don’t worry ablout me, Harry, just get along now, there’s a good lad.

killjoy

扫兴的人

‘Oh, don’t be such a killjoy,’ said Cho brightly.

otter

水獭

gambol

蹦蹦跳跳，嬉戏

Hermione’s Patronus, a shining silver otter, was gambolling around her.

sham

假装

The portraits of old headmasters and headmistresses were not shamming sleep tonight.

callous

无感觉的，麻木的

There was an indecent excitement in her voice, the same callous pleasure Harry had heard as she watched professor Trelawney dissolving with misery in the Entrance Hall.

pustule

脓包

… a series of closeset purple pustules that had spread across her nose and cheeks to form the word ‘SNEAK’.

unimpaired

未受损害的，未减弱的

He was heavily bandaged, it is true, but his hearing was quite unimpaired.

blatant

公然的，露骨的

‘Blatant corruption!’ roared the portrait of the corpulent, red-nosed wizard on the wall.

corpulent

肥胖的

manhandle

粗暴地对待

I cannot allow you to manhandle my students, Dolores.

ogle

挑逗地看，抛媚眼

‘Yes, shut up, Potter!’ barked Fudge, who was still ogling Dumbledore with a kind of horrified delight.

snag

障碍

‘Ah,’ said Dumbledore gently,’yes, yes, I thought we might hit that little snag.’

—

delusion

错觉

…, you seem to be labouring under the delusion that I am going to come quietly.

wobble

摇摆

Filch’s jowls wobbled with silent laughter.

pandemonium

大混乱

One floor down, pandemonium reigned.

soppy

多愁善感的

meadow

牧场，草地

/medow/

… a soppy-looking witch in the middle of a meadow.

quake

颤抖

… listening to Umbridge and Filch’s yells and quaking with suppressed mirth.

exhale

呼出，呼气

/eks’heil/

…(dragon) emitting loud bangs and exhaling flame.

lank

（头发）平直的

His hair was lank and greasy and was flopping on to the table.

angular

瘦骨嶙峋的

Round-shouldered yet angular, he walked in a twitchy manner that recalled a spider.

liaise

建立联络关系

You don’t seem to need many qualifications to liaise with Muggles.

frisk

v. 搜身

With Umbridge groping around in the fires and frisking all the owls?

Java虚拟机纲要

Sun, 26 May 2019 00:00:00 +0000

Java内存模型
垃圾回收机制
内存分配策略
类加载机制

Java内存模型

##运行时数据区域

运行时数据区域包含方法区、堆、虚拟机栈、本地方法栈以及程序计数器

程序计数器

每个线程有一个独立的程序计数器，用于保存当前程序的执行状态。字节码解释器工作时通过改变计数器的值来选取吓一跳需要执行的指令，分支、循环、跳转、异常处理、线程恢复等都依赖这个计数器。

执行Native方法时程序计数器的值为空（Undefined）。

Java虚拟机栈

同样是线程私有。虚拟机栈描述的是Java方法执行的内存模型，每个方法在执行的同时都会创建一个栈帧，用于存储局部变量表、操作数栈、动态链接、方法出口灯信息，每一个方法从调用直至执行完成的过程，就对应一个栈帧在虚拟机中入栈到出栈的过程。

本地方法栈

与虚拟机栈类似，不过只为Native方法服务。

Java堆

是所有线程共享的一块内存区域，在虚拟机启动时创建。此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。

Java堆是垃圾收集器管理的主要区域，因此也叫“GC堆”（Garbage Collector Heap）。

方法区

是所有线程共享的内存区域，用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。方法区也叫做Non-heap，和堆区区分开来。

该区域的内存回收目标主要是针对常量池的回收和对类型的卸载。

运行时常量池（Runtime Constant Pool）是方法区的一部分，用于存放编译期生成的各种字面量和符号引用。

垃圾回收机制

判断对象需要回收的方法

引用计数器法

给每一个对象分配一个计数器，记录有多少个地方引用该对象，当该计数器为0时即回收该对象。

优点为实现简单，缺点为无法解决相互引用的问题。

可达性分析算法

主流编程语言中通用的方法。

通过一系列的GC Roots作为起始点（根）向下搜索，搜索路径被称为引用链（Reference chain），当一个对象到GC Roots没有任何引用链相连接，则回收该对象。

GC Roots包括：

虚拟机栈（栈帧中本地变量表）中引用的对象
方法区中类静态属性引用的对象
方法区中常量引用的对象

引用的类型

在JDK 1.2之后，Java对引用的概念进行了扩充，将引用分成了：

强引用 Strong Reference
软引用 Soft Reference
弱引用 Weak Reference
虚引用 Phantom Reference

强引用

类似Object obj = new Object()，只要强引用还在，就永远不会被回收。

软引用

通过SoftReference类来使用软引用。在系统即将要发生内存溢出之前，会将只被软引用的对象回收。

弱引用

通过WeakReference类来使用弱引用。在下一次垃圾回收的时候，一定会回收掉只被弱引用的对象。

虚引用

通过PhantomReference类来使用虚引用。对于垃圾回收来说，虚引用等于没有引用，唯一目的就是在回收的时候会收到一个系统通知。

垃圾回收算法

标记-清除算法

最基础的垃圾收集算法，先标记出所有需要回收的对象，在标记完成后统一回收这些对象。

这个算法的不足点有：

效率低，无论是标记过程还是清除过程
空间利用率不高，因为标记清楚之后会产生大量不连续的内存碎片

复制算法

将可用内存分成容量相等的两块，先使用一块，这块用完了就把这一块上面仍然存活的对象拷贝到另一块（未使用的内存）上，同时一次性清理之前的使用过的内存。

优点是效率比标记-清除算法高；缺点是只能使用一半的内存空间。

现在的商业虚拟机都采用这种收集算法来回收新生代，但是并不是按照1：1来分配空间的，而是分成了一块较大的Eden空间和两块较小的Survivor空间，因为存活的对象一般比较少。每次使用Eden和一块Survivor，用完了将他们上面的存活对象拷贝到另一个Survivor上，清除这两块空间。

标记-整理算法

如果对象存活率较高的话，就不适合使用复制算法了。

标记-整理算法和标记-清除算法类似，不过不是直接清除被标记的内存，而是先把存活的对象向内存一端移动（整理），然后清除除此之外的内存空间。

分代收集算法

这并不是一个新的收集算法，而是根据不同内存的情况来分别处理。当前的商业虚拟机的垃圾收集都采用这一算法。

一般是把Java堆分成新生代和老年代，在新生代中每次收集时都有大量对象死去，适合用复制算法；老年代中存活率较高，使用标记-清除算法或者标记-整理算法。

内存分配策略

GC分为新生代GC和老年代GC。

新生代GC（Minor GC）是发生在新生代的垃圾收集，因为大多数Java对象都具备朝生夕灭的特性，所以Minor GC非常频繁，一般回收速度也比较快。

老年代GC（Major GC/Full GC），发生在老年代，速度一般比Minor GC慢10倍以上。

常用的内存分配策略有：

对象优先在Eden分配
大对象直接进入老年代，比如长字符串以及数组
长期存活的对象进入老年代。每一次Minor GC都会记录和修改存活对象的年龄，年龄足够大（可以通过MaxTenuringThreshold设置）的对象就会进入老年代。
动态对象年龄判定，如果在Survivor空间中相同年龄所有对象大小的总和大于Survivor空间的一半，年龄大于或等于该年龄的对象就可以直接进入老年代，无须等到MaxTenuringThreshold中要求的年龄。
空间分配担保。

类加载机制

类从加载到卸载经过的生命周期包括：加载、验证、准备、解析、初始化、使用和卸载。验证、准备和解析统称为连接。

类加载的时机

开始类加载过程第一个阶段“加载”的时机有：

使用new实例化对象的时候、读取或设置一个类的静态字段的时候，以及调用一个类的静态方法的时候；
使用java.lang.reflect包的方法对类进行反射调用的时候，如果类没有初始化，则先要触发其初始化；
当初始化一个类的时候，如果父类没有初始化，则先初始化父类；
虚拟机启动时，需要指定一个包含main()方法的主类，虚拟机会先初始化这个主类；
如果一个java.lang.invoke.MethodHandler实例最后的解析结果REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄，并且这个方法句柄所对应的类没有进行过初始化，则先触发其初始化。（？）

package org.fenixsoft.classloading;
/***被动使用类字段演示一：*通过子类引用父类的静态字段，不会导致子类初始化**/
public class SuperClass{
    static{
        System.out.println("SuperClassinit!"
    }
    public static int value=123;
}
public class SubClass extends SuperClass{
    static{
        System.out.println("SubClassinit!");
    }
}

public class ConstClass{
    static{
        System.out.println("ConstClass init!");
    }
    public static final String HELLOWORLD="hello world";
}

public class NotInitialization{
    public static void main(String[]args){
        System.out.println(SubClass.value); //1
        SuperClass[] sca = new SuperClass[10]; //2
        System.out.println(ConstClass.HELLOWORLD); //3
    }
}

假设上面的函数main()中的语句每次只执行其中一条。

只会输出“SuperClass init!”，而不会输出“SubClass init!”，因为对于静态字段，只有直接定义这个字段的类才会被初始化。SubClass.value中调用的value是父类中定义的，所以按照情况1会初始化SuperClass。
不会触发SuperClass的初始化，因为通过数组定义来引用类，不会触发此类的初始化。
不会触发ConstClass的初始化，因为经过传播优化，常量HELLOWORLD的值在编译阶段就存储到了NotInitialization类出常量池中。所有对ConstClass.HELLOWORLD的引用实际都转化成了NotInitialization自身常量池的引用。

类加载的过程

加载

加载阶段要完成的工作为：

通过一个类的全限定名来获取定义此类的二进制字节流；
将这个字节流所代表的静态存储结构转化为方法去的运行时数据；
在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据访问入口。

数组类本身不通过类加载器创建，而是有Java虚拟机直接创建。但是数组类中的Element Type最终是要用类加载器创建的。

验证

验证的目的是确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。

大致上，验证包含4个检验步骤：

文件格式验证
元数据验证：对字节码描述的信息进行语义分析，保证不存在不符合Java语言规范的元数据信息（主要是数据类型信息）。
字节码验证：通过数据流和控制流分析，确定程序语义是合法的、符合逻辑的。主要是对方法体进行校验。
符号引用验证：确保解析动作能正常执行，如果无法通过符号引用验证，可能会抛出NoSuchFieldError、NoSuchMethodError等

准备

正式为变量（类变量，即static变量）分配内存并设置变量初始值，这些变量所使用的内存都将在方法区中进行分配。

注意：准备阶段只是赋初始值，而不是定义的值，比如public static int value = 123;在准备过后value的值是0而不是123，不同类型的初始值为：

数据类型	零值
int	0
long	0L
short	(short)0
char	‘\u0000’
byte	(byte)0
boolean	false
float	0.0f
double	0.0d
reference	null

解析

虚拟机将常量池内的符号引用替换为直接引用

初始化

根据程序员通过程序制定的主观计划去初始化类变量和其他资源，或者可以说，初始化阶段是执行类构造器<clinit>()方法的过程。

<clinit>()是由编译器自动收集类中的所有类变量的赋值动作和静态语句块(static{})中的语句合并产生的。静态语句块只能访问到定义在静态语句块之前的变量，定义在它之后的变量，在前面的静态语句块可以赋值，但是不能访问。

双亲委派模型

Wordlist - Harry Potter IV

Tue, 07 May 2019 00:00:00 +0000

Phrases
- an assortment of
Words
- contagious & germ
- cactus
- bummer
- raccoon
- collude
- oppression
- gloss
- vociferous
- badger
- rind
- plait
- satin
- opal
- steed
- mast
- resurrect
- disembarking
- sleek
- unctuous
—
- crane
- imminent
- crest
- interrogate
- lousy
- reverie
- plastered
- lethal
- antenna
- harness
- enmity
- paranoid
- appal
- crude
- benign
- secretion
- riddle
- foe
- prompt
- intact
- headstone
—
- immortality
- affinity
- wasp
- sear

Phrases

an assortment of

各种各样的

Words

contagious & germ

contagious 蔓延的，有传染性的

germ 病菌

Rumours were flying from student to student like highly contagious germs.

cactus

仙人掌

… Professor McGonagall barked at the end of one particularly difficult lesson, during which Neville had accidentally transplanted his own ears onto a cactus.

bummer

扫兴，失望

What a bummer!

It’s a bummer all right, but if he won’t talk to us in person, we’ll have to send him the letter after all. Or we’ll stuff it into his hand, he can’t avoid us for ever.

raccoon

浣熊

‘I asked McGonagall how the champions are chosen but she wasn’t telling,’ said George bitterly.’She just told me to shut up and get on with Transfiguring my raccoon.’

collude

勾结，串通

‘House-elves!’ said Hermione loudly and proving Harry right. ‘Not once, in over a thousand pages, does Hogwarts: A History mention that we are all colluding in the oppression of a hundred slaves!’

oppression

压迫

gloss

n. 光彩，假象 v. 使光彩，掩盖

A Highly Biased and Selective History of Hogwarts, Which Glosses Over the Nastier Aspects of the School.

vociferous

吵闹的，叫嚣的

They seemed to have made Hermione more vociferous.

badger

n. 獾 v. 纠缠，烦扰

She had been badgering Harry and Ron ever since.

rind

（橘子等水果、干酪、熏肉等的）皮

Harry pulled off Sirius’s reply and offered Hedwig his bacon rinds.

plait

辫子

Parvati scowled and removed a large ornamental butterfly from the end of her plait.

satin

纺缎子

She was dressed from head to foot in black satin, and many magnificent opals gleamed at her throat and on her thick fingers.

opal

蛋白石

steed

骏马

My steeds require-er-forceful ‘andling.

mast

桅杆

‘It’s a mast!’ he said to Ron and Hermione.

resurrect

使复活，使再现

… as though it was resurrected wreck.

disembarking

着陆

People were disembarking; they could see their silhouettes passing the lights in the ship’s portholes.

sleek

油亮的

But the man who was leading them up to the castle was wearing furs of a different sort; sleek and silver, like his hair.

unctuous

油腻的，虚情假意的

Karkaroff had a fruity, unctuous voice.

—

crane

crane one’s neck 伸长脖子

Like everyone else in the Hall, judging by the constantly craning necks, the impatient expressions on every face, …

imminent

迫近的，即将到来的

The imminent arrival at their house of an assortment of wizards was making the Dursleys uptight and irritable.

crest

（家族）饰章

They were all wearing the same uniform; a tea-towel stamped with the Hogwarts crest…

interrogate

审问，质问

His voice, which had been so calm throughout the interrogation of Barty Crouch, shook very slightly for the first time.

lousy

令人厌恶的，糟糕的

You lousy biased scumbag, you gave Krum ten!

reverie

幻想，遐想

Mr Crouch seemed to come out of a deep reverie.

plastered

用灰泥抹

In Professor Lockhart’s day, the walls had been plastered with beaming, winking pictures of Professor Lockhart himself.

lethal

致命的

Hagrid simply loved monstrous creatures – the more lethal, the better.

antenna

触须

Look very closely, and you’ll notice the markings around her antennae are exactly like those foul glasses she wears.

harness

缰绳

Harry could see Hagrid helping Madame Maxime to back two of the giant horses into their harness.

enmity

敌意，仇恨

Lord Voldemort’s gift for spreading discord and enmity is very great.

paranoid

偏执的，多疑的

‘Talk about paranoid …’ Ron glanced nervously over his shoulder to check that Moody was definitely out of earshot, and went on, …

appal

使惊吓

They were mouthing soundlessly at Dumbledore, apparently too appalled to speak.

crude

粗糙的，天然的，未加工的

a cluster of crude stones

benign

善良的，温和的；良性的

benign tumour

There was no benign smile upon Dumbledore’s face, no twinkle in the eyes behind the spectacles.

secretion

分泌物

He could see some sort of thick, gluey secretion from the spider’s pincers on his tore robes.

riddle

谜语

Not unless you can answer my riddle.

foe

敌人

But the blood of a foe … Wormtail would have had me use any wizard, would you not, Wormtail?

prompt

迅速的，立刻的

I see you all, whole and healthy, with your powers intact - such prompt appearances! - and I ask myself … why did this band of wizards never come to (find me when I was faintest?)

intact

完整的

headstone

墓碑

It stopped beside a towering marble headstone only six feet from them.

—

immortality

不朽

What I was, even I do not know … I, who have gone further than anybody along the path that leads to immortality.

affinity

喜爱

Wormtail has a curious affinity with rats, do you not, Wormtail?

wasp

黄蜂

‘Good training for when we’re all Aurors,’ said Ron excitedly, attempting the impedient Jinx on a wasp that had buzzed into the room.

sear

灼烧

Wormtail screamed, screamed as though every nerve in his body was on fire, the screaming filled Harry’s ears as the scar on his forehead seared with pain.

Wordlist - Harry Potter III

Mon, 06 May 2019 00:00:00 +0000

Phrases
Words
- attic
- grotesque
- gag
- whine
- kneel
- ponder
- bluff
- fathomless
- caption
- fledged
- wane
- ★ haunted
- ★ derisive
- surly
- convulsive
- trance
—

Phrases

Words

attic

阁楼，顶楼

In fact, it didn’t look like a classroom at all; more like a cross between someone’s attic and an old-fashioned teashop.

grotesque

古怪的，荒谬的

He(Snape) was pulled into a standing position, head still lolling unpleasantly, like a grotesque puppet.

gag

阻塞，塞物于（口中）

Thin cords shot from Lupin’s wand this time, and next moment, Pettigrew was wriggling on the floor, bound and gagged.

whine

啜泣，哀诉

Stop whining, child!

… whined Pettigrew.

kneel

跪下，跪着

kneel-knelt-knelt

Pettigrew knelt, trembling uncontrollably, and turned his head slowly towards Harry.

ponder

仔细思考，沉思

He seemed to be pondering his answer.

bluff

欺骗，吓唬

I thought it was the perfect plan … a bluff … Voldemort would be sure to come after me, would never dream they’d use a weak, talentless thing like Pettigrew.

fathomless

深不可测的

Black’s face looked more skull-like than ever as he stared at Pettigrew with his fathomless eyes.

caption

（报刊等的）标题

And the caption said the boy would be going back to Hogwarts.

fledged

羽翼丰满的，成熟的

Before the Wolfsbane Potion was discovered, however, I became a fully fledged monster once a month.

wane

（月亮）亏

I am able to curl up in my office, a harmless wolf, and wait for the moon to wane again.

★ haunted

闹鬼的

‘No one there …'’The place is haunted!’

‘Very haunted up there, isn’t it?’

★ derisive

/diraisiv/

嘲笑的，嘲弄的

Ahead they could see Malfoy, who was walking with Crabbe and Goyle, and kept looking back, laughing derisively.

surly

/’sə:li/

脾气坏的

A bunch of surly security trolls had been hired to guard her.

convulsive

突然的，发狂的

He pointed at Black, whose face twitched convulsively.

trance

出神，恍惚

Slowly, in a kind of horrified trance, Harry, Ron and Hermione set off silently around Hagrid’s house.

—

Algorithm - Climbing Leaderboard

Mon, 22 Apr 2019 00:00:00 +0000

问题描述
解题思路
算法复杂度
代码

Problem

问题描述

Alice is playing an arcade game and wants to climb to the top of the leaderboard and wants to track her ranking. The game uses Dense Ranking, so its leaderboard works like this:

The player with the highest score is ranked number 1 on the leaderboard.
Players who have equal scores receive the same ranking number, and the next player(s) receive the immediately following ranking number.

For example, the four players on the leaderboard have high scores of 100, 90, 90 and 80. Those players will have ranks 1, 2, 2, and 3 respectively. If Alice’s scores 70, 80 and 105, her rankings after each game are 4, 3, and 1.

Complete the climbingLeaderboard function in the editor below. It should return an integer array where each element res[j] represents Alice’s rank after the jth game.

解题思路

因为相同的得分排名相同，而且不会因为得分相同导致后面的排名顺延，所以可以考虑先将初始得分数组和Alice得分数组中的相同的分数去掉。

因为初始得分是递减的，而Alice的得分是递增的，所以可以设置两个指针来比较这两个数组中的元素，其中pscore指向score数组中的第一个元素，移动方向为从前往后；palice指向alice数组中的最后一个元素，移动方向为从后往前。算法步骤为：

（0）将初始得分的数组记为scores，将Alice得分的数组记为alice；pscore = 0; palice = alice.length - 1;

（1）从pscore指向的元素开始往后找，找到第一个比alice[palice]小或者与其相等的元素，将其位置（pscore + 1，因为第一名下标为0）记录为alice[palice]的最终排名；如果找不到这样的一个元素，表示scores中所有元素都比alice[palice]大，因此alice[palice]的排名为scores.length + 1；

（2）如果palice == alice.length-1，查找完毕，执行（3）；否则palice ++，回到（1）。

（3）遍历初始的未去重alice数组，根据上面记录下的每一个分数的排名来得到数组中各个分数的排名，返回排名数组。

算法复杂度

去重部分复杂度为O(n)，查找部分复杂度为O(m+n)。

代码

import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.regex.*;

public class Solution {

    static int[] deleteDuplicate(int[] scores){
        int[] newScores = new int[scores.length];
        int newLength = 0;
        for(int i=0;i<scores.length;i++){
            if(i==0){
                newScores[i] = scores[i];
                newLength ++;
            }else{
                if(scores[i]!=scores[i-1]){
                    newScores[newLength] = scores[i];
                    newLength ++;
                }
            }
        }
        return Arrays.copyOf(newScores,newLength);
    }
    
    // Complete the climbingLeaderboard function below.
    static int[] climbingLeaderboard(int[] scores, int[] alice) {
        int[] dscore = deleteDuplicate(scores);
        int[] dalice = deleteDuplicate(alice);
        Map<Integer,Integer> map = new HashMap<>();
        int pa = dalice.length-1;
        int ps = 0;
        while(pa>=0){
            if(dalice[pa]>=dscore[ps]){
                map.put(dalice[pa],ps + 1);
                pa --;
            }else if(ps == dscore.length-1){
                map.put(dalice[pa],dscore.length+1);
                pa --;
            }else{
                ps ++;
            }
        }

        int[] rank = new int[alice.length];
        for(int i=0;i<alice.length;i++){
            rank[i] = map.get(alice[i]);
        }

        return rank;
    }

    private static final Scanner scanner = new Scanner(System.in);

    public static void main(String[] args) throws IOException {
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH")));

        int scoresCount = scanner.nextInt();
        scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");

        int[] scores = new int[scoresCount];

        String[] scoresItems = scanner.nextLine().split(" ");
        scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");

        for (int i = 0; i < scoresCount; i++) {
            int scoresItem = Integer.parseInt(scoresItems[i]);
            scores[i] = scoresItem;
        }

        int aliceCount = scanner.nextInt();
        scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");

        int[] alice = new int[aliceCount];

        String[] aliceItems = scanner.nextLine().split(" ");
        scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");

        for (int i = 0; i < aliceCount; i++) {
            int aliceItem = Integer.parseInt(aliceItems[i]);
            alice[i] = aliceItem;
        }

        int[] result = climbingLeaderboard(scores, alice);

        for (int i = 0; i < result.length; i++) {
            bufferedWriter.write(String.valueOf(result[i]));

            if (i != result.length - 1) {
                bufferedWriter.write("\n");
            }
        }

        bufferedWriter.newLine();

        bufferedWriter.close();

        scanner.close();
    }
}

Wordlist - Harry Potter II

Mon, 01 Apr 2019 00:00:00 +0000

Phrases
Words
- cuff
- frail
- wring
- incensed
- torrent
- recede
- slit
- serene
- abject, hem
- tumble
- hoodwink
- ordeal
- frame
- ★ hollow
- pillar
- skirt
- blunder
- pixie & pixy
- belch
- hearty
- volley
- venomous
- tray
- earmuff
- compost
- tuft
- tentative
- twinge
- velvet
- bloke
- compartment
- hex
- gnome
- ★ foul
- simper
- scrub
- stumble
- fishy
- haphazard
- aghast
- ★ tread
- ★ implore
- commotion
- irresolute
- acne
- ★ disperse
- chuck
- squid
- surge
- writhe
- wrinkled
- tartan
- blunt
- lilac
- whack
- morale
- trickle
- derisive
- shred
- shatter
- malevolent
- scarper
- tamper
- bait
- undaunted
- abashed
- remnants
- wheezy
- divination
- vulture
- prop
- throb
- wary
- plaque
- custard
- scalp
- tingle
- dregs
- cub
- blundering

Phrases

to the hilt

完全地，彻底地

Harry threw his whole weight behind the sword and drove it to the hilt into the roof of the serpent’s mouth.

buck up

振奋起来

“Harry, buck up there, you need a decent breakfast.”

dung beetle

屎壳郎

He knew it was only their terror that he might turn them all into dung beetles that stopped them locking him in the cupboard.

the end of one’s tether

山穷水尽

The car, however, had reached the end of its tether.

tether: 栓绳，范围

crop up

突然出现

Harry had been wondering when his name was going to crop up.

on all fours

四脚着地

Malfoy was on all fours, banging the ground with his fist.

on tenterhooks

提心吊胆，焦虑不安

He (Nearly Headless Nick) watched Harry on tenterhooks.

butt in

插嘴，插手

‘I’ll make it,’ Lockhart butted in. ‘I must have done it a hundred times.’

bee in one’s bonnet

（某人）奇思异想，头脑发热

—— Then a small voice said in his ear, ‘Bee in your bonnet, Harry Potter?’

—— ‘Er, yes,’ Harry muttered. ‘Er - sorry to bother you - I wanted to ask -‘

nip off

很快走开

—— ‘Oh, get out of the way, Percy’, said Fred. ‘Harry’s in a hurry.’

—— ‘Yeah, he’s nipping off to the Chamber of Secrets for a cup of tea with his fanged servant,’ said George, chortling.

pore over

用心研读

“It could affect our whole future,” she told Harry and Ron, as they pored over lists of new subjects, marking them with ticks.

keel over

倒下

… as the basilisk keeled over sideways and fell twitching, to the floor.

draw level with

与……比肩

Then, as he drew level with the last pair of pillars, a statue high as the chamber itself loomed in to view, standing against the back wall.

Trying to draw level with Asia in chipmaking would be futile（徒劳的）.

Words

cuff

拍打，掌击

Hagrid turning up at half past three, cuffing Harry on the shoulder.

frail

虚弱的，衰弱的

A wizened, frail-looking wizard, bald except for a few wisps of white hair, was reading a letter by candlelight.

wring

绞，拧

Justin hurried over from the Hufflepuff table to wring his hand and apologise endlessly for suspecting Harry.

incensed

极为愤怒的

With a last, incensed stare at the pair of them, he (Lucius Malfoy) swung his cloak around him and hurried out of sight.

Her ladyship was highly incensed. – Pride and Prejudice

torrent

洪流，（感情的）爆发

Ink spurted out of the diary in torrents, streaming over Harry’s hands, flooding the floor.

recede

逐渐模糊，变得渺茫

He could hear Dobby’s squeals of pain receding around the corner.

slit

缝隙，裂缝

Mr Malfoy went even paler than usual, but his eyes were still slits of fury.

serene

安详的，宁静的

serene: si’ri:n
serenity: si’reniti
serenely: si’rinli

‘Well, you see, Lucius,’ said Dumbledore, smiling serenely, ‘the other eleven goveners contacted me today.’

abject, hem

abject: 绝望无助的
hem: 边缘
crouch: 蜷伏，蹲伏

Dobby went scurrying in after him, crouching at the hem of his cloak, a look of abject terror on his face

tumble

翻跟斗，打滚

Both of the wrestlers tried to tumble the adversary with all their strength.

hoodwink

欺骗，蒙蔽

Older and wiser wizards than she have been hoodwinked by Lord Voldemort.

ordeal

严峻的考验，苦难的经历

This has been a terrible ordeal for her.

frame

设计陷害

And you framed him, didn’t you?

★ hollow

adj. 凹的，下陷的；中空的；声音空洞的；虚假的
n. 凹陷，盆地，山谷
v. 挖空

The hollow eye sockets of the stone snakes seemed to be following him.

They had reached the rim of a vast hollow, a hollow which had been cleared of trees.

pillar

柱子

towering stone pillars entwined with more carved serpents

skirt

绕过，回避

He was tired of people skirting around him in the corridors.

blunder

跌跌撞撞地走

Goyle blundered around, his hands over his eyes.

pixie & pixy

小精灵，小妖精

freshly caught Cornish pixies.

belch

打嗝

Instead he gave an almighty belch and severl slugs dribbled out of his mouth onto his lap.

hearty

（虚假地装出）热情亲切的

He gave a hearty wink and strode off.

volley

齐射，连发

‘Write home for another one,’ Harry suggested, as the wand let off a volley of bangs like a firecracker.

venomous

有毒的；恶毒的，狠毒的

tray

托盘，盘子

She pointed to a row of deep trays as she spoke and everyone shuffled forward for a better look.

earmuff

（御寒用的）耳套

About twenty pairs of different-coloured earmuffs were lying on the bench.

compost

堆肥，混合肥料

… plunged the Mandrake into it, burying him in dark, damp compost.

tuft

一簇，一束

tufts of grass

A hundred or so tufty little plants, purplish green in colour, were growing there in rows.

tentative

试探性的

I’m - I’m Colin Creevey,’ he said breathlessly, taking a tentative step forward.

twinge

剧痛，阵痛

Professor Sprouts arms were full of bandages, and with another twinge of guilt, Harry spotted the Whomping Willow in the distance,…

velvet

丝绒，天鹅绒

They entered the familiar, circular room, with its five four-posters hung with red velvet and its high, narrow windows.

bloke

人，家伙

He was asking that bloke from the Daily Prophet if he’d be able to work the fight into his report.

compartment

分隔间，单间

… with a fat pack of toffees in the glove compartment, …

hex

不祥之物，恶毒的诅咒

And old Mundungus Fletcher tried to put a hex on me when I had my back turned …

gnome

/noum/

侏儒

You’re going to de-gnome the garden for me.

★ foul

难闻的，恶臭的
肮脏的，污秽的
邪恶的，不正当的
犯规的
（天气等）恶劣的

Dudley put on a foul, simpering smile.

simper

傻笑

He simpered his explanation.

scrub

用力擦，擦亮

… (Harry) started scrubbing the kitchen clean.

stumble

绊倒

Dudley stumbled backwards at once, a look of panic on his fat face.

fishy

可疑的，靠不住的

‘Very fishy,’ said Fred finally.

haphazard

/,hap’hazard/

随意的，无计划的

Mrs Weasley was clattering around, cooking breakfast a little haphazardly, throwing dirty looks at her sons as she threw sausages into the frying pan.

aghast

吓呆的

Hermione looked aghast at the news.

★ tread

行走于；踩踏，踩碎

Harry walked over to the bed, open-mouthed, treading on a few loose pages of Travels with Trolls.

★ implore

恳求；乞求；哀求

‘I never,’ said Hagrid, looking imploringly at Dumbledore, ‘You know I never, Professor Dumbledore, sir…’

commotion

混乱；骚乱

‘What’s all this commotion?’

irresolute

犹豫不决的

Harry stood, irresolute, trying to catch the voice again, but people were now emerging from the Great Hall behind him, talking loudly.

acne

/’akni/

粉刺，痤疮

The moment their (Mandrake) acne clears up, they’ll be ready for repotting (移栽) again.

★ disperse

驱散，疏散

Percy Weasley did his best to disperse the crowd.

chuck

抛，扔

I don’t know why you don’t chuck it, Harry.

squid

鱿鱼

Maybe he got thirty O.W.Ls or saved a teacher from the giant squid.

surge

汹涌，奔腾

He put up her card with a fresh surge of guilt, thinking about Mr Weasley’s car.

writhe

/raithe/

（因痛苦）打滚

Immediately, his insides started writhing as though he’d just swallowed live snakes.

wrinkled

起皱的

Harry looked down in time to see a tiny, wrinkled, new-born bird poke its head out of the ashes.

tartan

（苏格兰高地人的）格子呢

There was thick tartan scarf bound around his head, and his nose was unusually purple.

blunt

钝的，不锋利的

Getting hit forty-five times in the neck with a blunt axe would qualify you to join the Headless Hunt.

lilac

/’lailək/

丁香花；淡紫色

Harry gave a huge jump and a large lilac blot appeared on Veronica Smethley’s letter.

whack

重打，猛击

Everyone filed out of the classroom except him and Ron, who was whacking his wand furiously on the desk.

morale

精神面貌，斗志

You know, what the school needs now is a morale-booster.

trickle

滴

Thick, pearly tears were trickling down the glossy feathers.

derisive

嘲笑的，嘲弄的

He gave a short, derisive laugh.

shred

些许，最少量（常用否定）

There is not a shred of evidence that Slytherin ever built so much as a secret broom cupboard.

shatter

使破碎，使粉碎

Cream splattered the windows and walls as the dish shattered.

malevolent

恶意的，恶毒

A bad idea, Professor Lockhart,’ said Snape, gliding overr like a large and malevolent bat.

scarper

逃走，溜掉

Ginny jumped up as though her chair had just been electrified, gave Percy a fleeting, frightened look, and scarpered away.

tamper

篡改；贿赂

‘Someone’s tampered with this Bludger,’ Fred grunted, swinging his bat with all his might at it as it launched a new attack on Harry.

bait

n. 诱饵

v. 诱惑

‘Just Muggle-baiting,’ sighed Mr Weasley.

Worms make excellent fish bait.

The open purse was a bait for the hungry young man.

undaunted

顽强的，无畏的

Undaunted, Hermione shoved her hand back into her bag and pulled out what appeared to be a bright red eraser.

abashed

难堪的，为难的，局促不安的

… said Harry under his breath, pleased to see Draco looking both abashed and angry.

remnants

They had been in the changing room so long that the sun was up properly now, although remnants of mist hung over the grass in the stadium.

wheezy

喘息的，吱吱响的

‘My subject is History of Magic,’ he said in his dry, wheezy voice.

divination

占卜术

It’s never too early to think about the future, so I’d recommend Divination.

vulture

秃鹫

Madam Pince, the librarian, was a thin, irritable woman who looked like an underfed vulture.

prop

支撑；支持

Harry and Ron sat down at the Gryffindor table next to Hermione, who had her copy of Voyages with Vampires propped open against a milk jug.

throb

抽动，抽痛；跳动

Steam was billowing from under the crumpled bonnet; Hedwig was shrieking in terror, a golf-ball-sized lump was throbbing on Harry’s head where he had hit (the tree).

wary

小心的，留神的，谨慎的

He cast a wary eye around the sleeping witches and wizards on the walls.

plaque

饰板，匾

… a small plaque on it, saying ‘Ronald’s room’.

custard

牛奶蛋糊

Come, Severus, there’s a delicious-looking custard tart I want to sample.

scalp

头皮

… it lifted the hair on Harry’s scalp and made his heart feel as though it was swelling to twice its normal size.

tingle

感到刺痛

Every nerve in Harry’s body was tingling unpleasantly.

dregs

【用作复数】渣滓，糟粕

the dregs of society

If he knew what he means to us, to the lowly, the enslaved, us dregs of the magical world!

cub

幼兽

(Tom Riddle) parentless but so brave, school prefect, model student; on the other hand, big, blundering Hagrid, in trouble every other week, trying to raise werewolf cubs.

blundering

笨拙的，愚蠢的

面试常见手撕代码题

常见排序算法的实现

堆排序

快速排序

归并排序

链表

反转链表（递归和非递归）

非递归（头插法）

递归（头插法）

倒数第K个节点

检测环

引申问题1：为什么快指针的步长是2，而不是3、4、5…？

引申问题2：如何确定环的入口？

二叉树

二叉树的递归遍历以及（前中后序）非递归遍历

二叉树的层序遍历（使用/不使用额外的数据结构）

图（矩阵）的深度优先和广度优先遍历

动态规划

最长公共子串

最长递增子序列

最长回文串

实现一个LRU的Cache

1. 使用Java自带的LinkedHashMap

2. 仅使用Java中的HashMap和Deque

实现一个阻塞队列

实现生产者/消费者模型

实现两个线程交替打印

文件的输入和输出

字符串转整型

Note of java programming logic

第1章 编程基础

第2章 数据背后的二进制

整数

小数

字符的编码

char

第3章 类的基础

第4章 类的继承

动态绑定

静态绑定

第15章 并发基础知识

15.1 线程的基本概念

15.2 理解synchronized

15.3 线程的基本协作机制

wait/notify

wait/notify的原理

生产者/消费者模式

同时开始

等待结束

集合点

15.4 线程的中断

第16章 并发包的基石

16.1 原子变量和CAS

16.2 显式锁

ReentrantLock的实现原理

对比ReentrantLock和synchronized

16.3 显式条件

第17章 并发容器

17.1 写时复制

17.2 ConcurrentHashMap

17.4 并发队列

无锁非阻塞并发队列

普通阻塞队列

优先级阻塞队列

延时阻塞队列

其他阻塞队列

第18章 异步任务执行服务

18.1 基本概念和原理

18.2 线程池

18.3 定时任务

第19章 同步和协作工具类

第21章 反射

第22章 注解

第23章 动态代理

23.1 静态代理

第24章 类加载机制

24.1 类加载的机制和过程

24.2 ClassLoader和forName加载类的区别

Wordlist - Harry Potter VI

Phrases

第1章编程基础

第2章数据背后的二进制

第3章类的基础

第4章类的继承

第15章并发基础知识

第16章并发包的基石

第17章并发容器

第18章异步任务执行服务

第19章同步和协作工具类

第21章反射

第22章注解

第23章动态代理

第24章类加载机制