存储结构-字段

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

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

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

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

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

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

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

...

/**
 * The table, initialized on first use, and resized as
 * necessary. When allocated, length is always a power of two.
 * (We also tolerate length zero in some operations to allow
 * bootstrapping mechanics that are currently not needed.)
 */
transient Node<K,V>[] table;

/**
 * Holds cached entrySet(). Note that AbstractMap fields are used
 * for keySet() and values().
 */
transient Set<Map.Entry<K,V>> entrySet;

/**
 * The number of key-value mappings contained in this map.
 */
transient int size;

/**
 * The number of times this HashMap has been structurally modified
 * Structural modifications are those that change the number of mappings in
 * the HashMap or otherwise modify its internal structure (e.g.,
 * rehash).  This field is used to make iterators on Collection-views of
 * the HashMap fail-fast.  (See ConcurrentModificationException).
 */
transient int modCount;

/**
 * The next size value at which to resize (capacity * load factor).
 *
 * @serial
 */
// (The javadoc description is true upon serialization.
// Additionally, if the table array has not been allocated, this
// field holds the initial array capacity, or zero signifying
// DEFAULT_INITIAL_CAPACITY.)
int threshold;

/**
 * The load factor for the hash table.
 *
 * @serial
 */
final float loadFactor;

• DEFAULT_INITIAL_CAPACITY，默认 HashMap 的大小
• MAXIMUM_CAPACITY，最大的 HashMap 的大小
• DEFAULT_LOAD_FACTOR，默认的负载因子的大小
• TREEIFY_THRESHOLD，将链表升级成红黑树的 threshold
• UNTREEIFY_THRESHOLD，当 HashMap 删除元素后，红黑树退化成链表的 threshold
• MIN_TREEIFY_CAPACITY，升级成红黑树的最小容量，表示 HashMap 达到这个容量之后，一定会升级成红黑树或者 resize。 (但是我没在别人的博客里看到过这个。。我只是按照注释理解了一下。。这个东西下面没用到)
• table[]，存放数据的数组，每个元素是一个内部类 Node

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

  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; } public final K getKey() { return key; } public final V getValue() { return value; } public final String toString() { return key + "=" + value; } public final int hashCode() { return Objects.hashCode(key) ^ Objects.hashCode(value); } public final V setValue(V newValue) { V oldValue = value; value = newValue; return oldValue; } public final boolean equals(Object o) { if (o == this) return true; if (o instanceof Map.Entry) { Map.Entry<?,?> e = (Map.Entry<?,?>)o; if (Objects.equals(key, e.getKey()) && Objects.equals(value, e.getValue())) return true; } return false; } }

  • hash 就是 hash 值
  • key 是存放的 key 值
  • value 是存放的 value 值
  • next 是指向下一个 Node 的引用，生成链表时用的，如果升级成红黑树，会用 TreeNode (也是一个内部类) 代替 Node
• size，HashMap 的 size
• modCount，表示 HashMap 的 structural modified 次数 (比如，添加删除元素，或者 resize 都算，但是如果仅仅是值的改变不算) 。当迭代操作或者序列化操作时，操作前后需要比较 modCount 是否相等，不相等就 Fail-Fast，抛出 ConcurrentModificationException。
• threshold，resize 的大小，等于 (capacity * load factor) ，达到 threshold 的时候就会扩容 (会 rehash，复制数据等操作，比较消耗性能)
• loadFactor，负载因子

功能实现 - method

hash()

1
2
3
4
5
6

static final int hash(Object key) {   //jdk1.8 & jdk1.7
     int h;
     // h = key.hashCode() 为第一步 取 hashCode 值
     // h ^ (h >>> 16)  为第二步 高位参与运算
     return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

1. 取 key 的 hashCode 值
2. 高位运算
3. 取模运算

这个有一个点，就是 HashMap 中桶的个数 capacity 设计成 2 的幂次（一般都是设计成素数的）。之所以这样设计是为了在取模和扩容时做优化：

• 取模可以直接优化成了 and 位运算。
• 扩容时重新计算元素位置时取模更快了，而且扩容时可以直接根据 mask 位置上的新增位数是 0 还是 1 来确定当前元素是在【当前位置】，还是在【当前位置 * 2】的位置上。

但是这样设计也带来了一些问题，取模后的哈希值是有可能出现很差的哈希分布的，在 capacity 比较小的时候，hash 值高位 Bit 的信息完全丢失了。所以做了一个高位运算逻辑右移 >>> 16 位（逻辑右移，左边全部使用 0 填充），减少高位 Bit 信息的丢失。

put()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

• 判断当前 table 是否未初始化，未初始化就初始化一波
• 根据 hash 值定位到具体的 bin，如果这个 bin 为空，直接新建一个 bin 放入这个 Node，然后返回
• 判断 key 是否和当前结点的 key 相等，相等就直接替换 Node (或者 key 都为 null 的时候，HashMap 允许 key 为 null，顺便再插一句，HashMap 中 null 无法计算其 hash 值，默认都是放到下标为 0 的 上)
• 如果当前结点是 TreeNode 红黑树结点，就按红黑树的方法插入 (具体就不展开了)
• 如果是链表，就遍历链表，找到相同的 key 的 Node 就可以直接替换 Node，如果没找到就 newNode() (这个方法会在对应的 bin 中插入 Node)
• 统一替换 Node (即 e 不为空)
• modCount 自增
• 判断是否需要 resize

get()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

/**
* Returns the value to which the specified key is mapped,
* or {@code null} if this map contains no mapping for the key.
*
* <p>More formally, if this map contains a mapping from a key
* {@code k} to a value {@code v} such that {@code (key==null ? k==null :
* key.equals(k))}, then this method returns {@code v}; otherwise
* it returns {@code null}.  (There can be at most one such mapping.)
*
* <p>A return value of {@code null} does not <i>necessarily</i>
* indicate that the map contains no mapping for the key; it's also
* possible that the map explicitly maps the key to {@code null}.
* The {@link #containsKey containsKey} operation may be used to
* distinguish these two cases.
*
* @see #put(Object, Object)
*/
public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}

/**
* Implements Map.get and related methods
*
* @param hash hash for key
* @param key the key
* @return the node, or null if none
*/
final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        if ((e = first.next) != null) {
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            do {
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

• 判断 table 是否未初始化，未初始化或者定位到的 bin 为空的话，直接返回 null
• 判断第一个 Node/TreeNode 的值是否为查询的 key，是的话直接返回 (always check first node) ，若不匹配就下一步
• 判断为 TreeNode，查找红黑树
• 判断链表，遍历链表查找

resize()

扩容 (resize) 就是重新计算容量，向 HashMap 对象里不停的添加元素，而 HashMap 对象内部的数组无法装载更多的元素时，对象就需要扩大数组的长度，以便能装入更多的元素。当然 Java 里的数组是无法自动扩容的，方法是使用一个新的数组代替已有的容量小的数组，就像我们用一个小桶装水，如果想装更多的水，就得换大水桶。所以扩容就涉及到哈希值的重新计算，复制元素等操作，是很消耗性能的，如果能在开始就能确定好元素的个数，建议在一开始就设置好。

当插完元素后，size > threshold = capacity * Load factor，扩容就开始了。

1
2
3
4
5
6
7
8
9
10
11
12
13

void resize(int newCapacity) {   //传入新的容量
    Entry[] oldTable = table;    //引用扩容前的 Entry 数组
    int oldCapacity = oldTable.length;
    if (oldCapacity == MAXIMUM_CAPACITY) {  //扩容前的数组大小如果已经达到最大 (2^30) 了
        threshold = Integer.MAX_VALUE; //修改阈值为 int 的最大值 (2^31-1)，这样以后就不会扩容了
        return;
    }

    Entry[] newTable = new Entry[newCapacity];  //初始化一个新的 Entry 数组
    transfer(newTable);                         //！！将数据转移到新的 Entry 数组里
    table = newTable;                           //HashMap 的 table 属性引用新的 Entry 数组
    threshold = (int)(newCapacity * loadFactor);//修改阈值
}

transfer() 方法将原有 Entry 数组的元素拷贝到新的 Entry 数组里。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

void transfer(Entry[] newTable) {
    Entry[] src = table;                   //src 引用了旧的 Entry 数组
    int newCapacity = newTable.length;
    for (int j = 0; j < src.length; j++) { //遍历旧的 Entry 数组
        Entry<K,V> e = src[j];             //取得旧 Entry 数组的每个元素
        if (e != null) {
            src[j] = null;//释放旧 Entry 数组的对象引用（for 循环后，旧的 Entry 数组不再引用任何对象）
            do {
                Entry<K,V> next = e.next;
                int i = indexFor(e.hash, newCapacity); //！！重新计算每个元素在数组中的位置
                e.next = newTable[i]; //标记 [1]
                newTable[i] = e;      //将元素放在数组上
                e = next;             //访问下一个 Entry 链上的元素
            } while (e != null);
        }
    }
}

可以看出来复制的时候，链表是用头插法的方式复制的，所以原来的链表会被 revert 一下。在多线程场景，在两个线程 resize 的时候，可能会出现环形链表。

扩展问题

1. Hash 时取模一定要模质数吗？

好的 hash 算法期望是 hash 值在取模后能尽可能均匀地分布。不模 prime number 的话，很容易会有分布不均匀的情况产生。

假设需要放入长为 m 的 hash 表的数是 n，取模函数是： $f(n) = n \% m$ ， $f(n)$ 为需要放置在 hash 表中的位置的下标。

取 m 为质数的目的是：让 m 和 n 的最大公约数为 1，也就是： $gcd(m, n)=1$ 。因为在 m 为质数时，除非 n 恰好是 m 的倍数，否则他们的最大公约数都为 1。

$$ f(n) = n \% m $$

$$ \Rightarrow a \times m + f(n) = n(a = 0, 1, 2,3…) $$

$$ \Rightarrow f(n) = n - a \times m $$

$$ \Rightarrow f(n) = gcd(m, n) *( \frac{n}{gcd(m,n)} - \frac{a \times m}{gcd(m,n)}) $$

也就是我们算出来的 hash 值只可能是为 $gcd(m, n)$ 的倍数的那些值，倘若数据特别一点，全都是 gcd 的倍数，这样会让分布很不均匀。

• Hash 时取模一定要模质数吗？ - Porzy 的回答 - 知乎

2. 为什么 java 在计算 hashcode 时使用 31 作为乘数？

确实很奇怪。。感觉是个 magic number。把这个搞成了一个类似 31 进制的数字。看了很多说法，stackoverflow 上说：

The value 31 was chosen because it is an odd prime. If it were even and the multiplication overflowed, information would be lost, as multiplication by 2 is equivalent to shifting. The advantage of using a prime is less clear, but it is traditional. A nice property of 31 is that the multiplication can be replaced by a shift and a subtraction for better performance: 31 * i == (i << 5) - i. Modern VMs do this sort of optimization automatically.

是因为 31 是个奇素数，并且可以直接优化成位运算提高性能。偶数的话，相当于 shift 运算，会丢失信息，但是奇数因为在 shift 后在加上原数，所以比偶数好。之所以用素数是因为 traditional。。（我看到有的会用 33 来做，据说和 31 差不多）。

有个答案提到是根据实验得出发现 31 的，根据字典跑数据跑出的结果。（但是我看那个数据也是英文字典，ascii 字符，要是非 ascii 字符的实验结果呢？）

• Why does Java’s hashCode() in String use 31 as a multiplier? - Stack Overflow
• 为什么Java String哈希乘数为31？

参考

• Java 8 系列之重新认识 HashMap - 美团技术团队
• HashMap? ConcurrentHashMap? 相信看完这篇没人能难住你！ | crossoverJie’s Blog

References

• 數學名詞中英對照表

Locks offer two primary features: mutual exclusion and visibility.

• Mutual exclusion means that only one thread at a time may hold a given lock, and this property can be used to implement protocols for coordinating access to shared data such that only one thread at a time will be using the shard data.
• Visibility is more subtle and has to do with ensuring that change made to shared data prior to releasing a lock are made visible to another thread that subsequently acquires that lock – without the visibility guarantees provides by synchronization, thread could see stale or inconsistent values for shared variables, which could cause a host of serious problems.

Volatile

Volatile variables in the Java language can be thought of as “synchronized lite”; they require less coding to use than synchronized blocks and often have less runtime overhead, but they can only be used to do a subset of the things that synchronized can. In cases where reads greatly out number writes, volatile variables can often reduce the performance cost of synchronization compared to locking.

Volatile provides two guarantees:

• visibility. Volatile variables share the visibility features of synchronized, but none of atomicity features. This mean that threads will automatically see the most up-to-date value for volatile variables.
• establish a happen-before relationship. (In Java5 or later)

Condition for correct use of volatile

You can use volatile variables instead of locks only under a restricted set of circumstances. Both of the following criteria must be met for volatile variables to provide the desired thread-safety:

• Writes to the variables do not depend on its current value.
• The variable does not participate in invariants with other variables.

Implement volatile

Memory Barrier. More details see The JSR-133 Cookbook for Compiler Writers.

Change in JSR-133

Forbid reordering between volatile variable and normal variable.

References

• Managing volatility
• Fixing the Java Memory Model, Part 1
• Fixing the Java Memory Model, Part 2
• The Java Memory Model

In short, the queue is a Priority Queue. Using leader-follower mode to reduce followers’ dispatch.

private variable

1
2
3
4
5
6
7
8
9

private final transient ReentrantLock lock = new ReentrantLock();
private final PriorityQueue<E> q = new PriorityQueue<E>();
private Thread leader = null;
/**
* Condition signalled when a newer element becomes available
* at the head of the queue or a new thread may need to
* become leader.
*/
private final Condition available = lock.newCondition();

offer()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

/**
 * Inserts the specified element into this delay queue.
 *
 * @param e the element to add
 * @return {@code true}
 * @throws NullPointerException if the specified element is null
 */
public boolean offer(E e) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        q.offer(e);
        if (q.peek() == e) {
            // 如果新增的元素需要的延迟更小，leader置为null，唤醒线程来抢锁
            leader = null;
            available.signal();
        }
        return true;
    } finally {
        lock.unlock();
    }
}

take()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

/**
 * Retrieves and removes the head of this queue, waiting if necessary
 * until an element with an expired delay is available on this queue.
 *
 * @return the head of this queue
 * @throws InterruptedException {@inheritDoc}
 */
public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        for (;;) {
            E first = q.peek();
            if (first == null)
                // 队列是空的，就等着offer之后插进元素来唤醒
                available.await();
            else {
                long delay = first.getDelay(NANOSECONDS);
                if (delay <= 0)
                    return q.poll();
                // 防止因为这个线程一直被阻塞，但其实这个对象可能已经被take掉了，却一直拿着对象的引用而无法被垃圾回收。这个点太细了
                first = null; // don't retain ref while waiting
                if (leader != null)
                    // 有leader，follower就一直等着就好了
                    available.await();
                else {
                    // 没有leader，该线程变成leader
                    Thread thisThread = Thread.currentThread();
                    leader = thisThread;
                    try {
                        // 定时阻塞
                        available.awaitNanos(delay);
                    } finally {
                        // 什么情况下 leader != thisThread 呢？offer之后重新搞了leader，然后唤醒了别的线程抢到了leader。
                        if (leader == thisThread)
                            leader = null;
                    }
                }
            }
        }
    } finally {
        if (leader == null && q.peek() != null)
            // 如果没有leader，队列不为空的情况下，需要找个线程来当leader
            available.signal();
        lock.unlock();
    }
}

references

• oracle-docs: Class DelayQueue
• source code: DelayQueue

When the TCP client is handling two inputs at the same time: standard input and a TCP socket, we encounter a problem when the client was blocked in a call to fgets (on standard input) and the server process was killed. The server TCP correctly sent a FIN to the client TCP, but since the client process was blocked reading from standard input, it never saw the EOF until it read from the socket (possibly much later).

We want to be notified if one or more IO condition are ready (i.e., input is ready to be read, or the descriptor is capable of taking more output). The capability is called IO multiplexing and is provided by the select and poll functions, as well as a newer POSIX variation of the former, called pselect.

IO multiplexing is typically used in networking application in many scenarios. And IO multiplexing is not limited to networking programming, many nontrivial applications find a need for these techniques.

IO Models

We firstly examine the basic differences in the five IO models that are available to us under Unix:

• blocking IO
• nonblocking IO
• IO multiplexing (select and poll)
• signal driven IO
• asynchronous IO (the POSIX aio_ functions)

There are normally two distinct phases for an input operations:

1. Waiting for data to be ready. This involves waiting for data to arrive on the network. When the packet arrives, it is copied into a buffer within the kernel.
2. Copying the data from the kernel to the process. This means copying the (ready) data from the kernel’s buffer into our application buffer.

Blocking IO Model

The most prevalent model for IO is the blocking IO model. By default, all socket are blocking. The scenario is shown in the figure below:

We use UDP for this example instead of TCP because with UDP, the concept of data being “ready” to read is simple: either an entire datagram has been received or it has not. With TCP it gets more complicated, as additional variables such as the socket’s low-water mark come into play.

We also refer to recvfrom as a system call to differentiating between our application and the kernel, regardless of how recvfrom is implemented (system call on BSD and function that invokes getmsg system call on System V). There is normally a switch from running in application to running in the kernel, followed at some time later by a return to the application.

In the figure above, the process calls recvfrom and the system call does not return until the datagram arrives and is copied into our application buffer, or an error occurs. The most common error is the system call being interrupted by signal. We say that the process is blocked the entire time from when it calls recvfrom until it returns. When recvfrom return successfully, our application process the datagram.

Nonblocking IO Model

When a socket is set to be nonblocking, we are telling the kernel “When an IO operation that I request cannot be completed without putting the process to sleep, do not put the process to sleep, but return an error instead”. The figure is below:

• For the first three recvfrom, there is no data to return and the kernel immediately returns an error of EWOULDBLOCK.
• For the forth time we call recvfrom, a datagram is ready, it is copied into our application buffer, and recvfrom returns successfully. We then process the data.

When an application sits in a loop calling recvfrom on a nonblocking descriptor like this, it is called polling. The application is continually polling the kernel to see if some operation is ready. This is often a waste of CPU time, but this model is occasionally encountered, normally on systems dedicated to one function.

IO Multiplexing Model

With IO multiplexing, we call select or poll and block in one of these two system calls, instead of blocking in the actual IO system call. The figure is a summary of the IO multiplexing model:

We block in a call to select, waiting for the datagram socket to be readable. When select returns that the socket is readable, we then call recvfrom to copy the datagram into our application buffer.

Comparing blocking model:

• Disadvantage: using select requires two system call (select and recvfrom) instead of one
• Advantage: we can wait for more than one descriptor to be ready

Another closely related IO model is to use multithreading with blocking IO. That model very closely resembles the model described above, except that instead of using select to block on multiple file descriptors, the program uses multiple threads (one per file descriptor), and each thread is then free to call blocking system calls like recvfrom.

Signal-Driven IO Model

The signal-driven IO model uses signals, telling the kernel to notify us with the SIGIO signal when descriptor is ready. The figure is below:

• We first enable the socket for signal-driven IO and install a signal handler using the sigaction system call. The return from this system is immediate and our process continues; it is not blocked.
• When the datagram is ready to be read, the SIGIO signal is generated for our process. We can either:
  • read the datagram from the signal handler by calling recvfrom and then notify the main loop that data is ready to be process.
  • notify the main loop and let it read the datagram.

The advantage to this model is that we are not blocked while waiting for the datagram to arrive. The main loop can continue executing and just wait to be notified by the signal handler that either the data is ready to process or the datagram is ready to be read.

Asynchronous IO model

Asynchronous IO is defined by the POSIX specification, and various differences in the read-time function that appeared in the various standards which came together to form the current POSIX specification have been reconciled.

These functions work by telling the kernel to start the operation and to notify us when then entire operation (including the copy of the data from the kernel to our buffer) is complete. The main difference between this model and the signal-driven IO model is that with signal-driven IO, the kernel tells us when IO operation can be initiated, but asynchronous IO, the kernel tells us when an IO operation is complete. See the figure below for example:

• We call aio_read (the POSIX asynchronous IO function begin with aio_ or lio_, This system call returns immediately and our process is not blocked while waiting for the IO to complete) and pass the kernel the following:
  • descriptor, buffer pointer, buffer size (the same three arguments for read)
  • file offset (similar to lseek)
  • and how to notify us when the entire operation is complete

• We assume in this example that we ask the kernel to generate some signal when the operation is complete. This signal is not generated until the data has been copied into our application buffer, which is different from the signal-driven IO model.

Comparison of the IO models

The figure below is a comparison of the five different IO models:

The main difference between the first four models is the first phase, as the second phase in the first four models is the same: the process is blocked in a call to recvfrom while the data is copied from the kernel to the caller’s buffer. Asynchronous IO, however, handles both phases and is different from the first four.

Synchronous IO versus Asynchronous IO

POSIX defines these two terms as follows:

• A synchronous IO operation causes the requesting process to be blocked until that IO operation completes.
• An asynchronous IO operation does not cause the requesting process to be blocked.

Using these definitions, the first four IO models (blocking, nonblocking, IO complexing and signal-driven IO) are all synchronous because the actual IO operation (recvfrom) blocks the process. Only the asynchronous IO model matches the asynchronous IO definition.

References

• Chapter 6. I/O Multiplexing: The select and poll Functions
• UNP - 6.2 I/O Models

优点：

1. 高性能
2. 高并发

缺点，因为缓存可能出现的问题：

1. 缓存和数据库双写不一致
2. 缓存雪崩，缓存穿透
3. 缓存并发竞争

Redis

redis 内部使用的是文件事件处理器（file event handler），这个文件时间处理器是单线程的，所以说 redis 叫单线程模型。

Redis为什么单线程效率也这么高：

1. 纯内存操作
2. 核心是基于非阻塞的 IO 多路复用
3. 单线程避免了一些场景下频繁上下文切换的问题，预防了多线程可能产生的竞争问题

Redis过期策略

定期删除（部分） + 惰性删除

Redis内存淘汰机制

• noeviction
• allkeys-lru
• allkeys-random
• volatile-lru (volatile 表示从设置了过期时间的建空间里操作)
• volatile-random
• volatile-ttl

Redis实现高并发

主从架构

Redis实现高可用

哨兵，实现主备切换

Redis实现持久化

• RDB：周期性持久化
• AOF：对每条写入命令作为日志，以 append-only 的模式写入一个日志文件中

如果同时使用 RDB 和 AOF 两种持久化机制，那么在 redis 重启的时候，会使用 AOF 来重新构建数据，因为 AOF 中的数据更加完整。

Redis集群

• redis cluster 可以自动将数据切片，每个 master 上放一部分数据，节点之间通信用 gossip 协议（每个节点持有一份元数据）
• 分布式寻址（一致性哈希算法）
• 主从切换
  • 判断节点宕机（超过半数）
  • 过滤 slave 节点（和 master 节点断开时间超过了某时间，不配变成 master）
  • 从节点选举（超过半数）

缓存雪崩

事前：redis 高可用，主从+哨兵，redis cluster，避免全盘崩溃。
事中：本地 ehcache 缓存 + hystrix 限流&降级，避免 MySQL 被打死。
事后：redis 持久化，一旦重启，自动从磁盘上加载数据，快速恢复缓存数据。

缓存穿透

非正常请求也存一个空值到缓存里，并设置过期时间。

缓存击穿

热点数据突然失效。

1. 热点不过期
2. redis 或 zookeeper 实现互斥锁，等待第一个请求建完缓存后在释放锁

Reference

• Java 进阶扫盲

elasticsearch 是基于 lucene /luːsɪŋ/ 的搜索库，分布式的文档存储，搜索，分析，支持 PB 级数据。

下面是 ES 里的一些概念

• Near Real Time，近实时
  • 写入数据到数据可以被搜索有一个小延迟（大概是 1s）
  • 基于 es 执行搜索和分析可以达到秒级
• Cluster 集群
• Node 节点
• Document & field
  • document 是一条 record
  • field
• Index 索引，一个索引包含很多 document
• Type，一个索引里有一个或者多个 type
• shard，把一个索引中的数据切分成多个 shard
• replica，shard 分为 primary shard 和 replica shard

ES 如何实现分布式

ES shard 来实现分布式。

• 支持横向扩展
• 提高性能

ES 工作原理

写数据

• client 发送请求到 coordinating node
• coordinating node 对 document 路由，转发给对应的 primary shard
• primary 同步到 replica node，完成后响应结果

读数据

• client 发送请求到 coordinating node
• client 路由，负载均衡到相应的 node（随机轮询算法）
• node 返回到 coordinating node，完成后响应结果

es搜索

• client 发送到 coordinating node
• coordinating node 转发到所有的 shard（primary 或 replica）
• query phase：shard 返回 doc id 给 coordinating node，coordinating node 对结果合并，排序，分页等操作，产出最终结果
• fetch phase：由 coordinating node 根据 doc id 来拉取实际的 document 数据

es写数据底层原理

因此是 1s 的准实时，5s 的数据丢失。

es删除/更新数据底层原理

如果是删除操作，commit 的时候会生成一个 .del 文件，里面将某个 doc 标识为 deleted 状态，那么搜索的时候根据 .del 文件就知道这个 doc 是否被删除了。

如果是更新操作，就是将原来的 doc 标识为 deleted 状态，然后新写入一条数据。

buffer 每 refresh 一次，就会产生一个 segment file，所以默认情况下是 1 秒钟一个 segment file，这样下来 segment file 会越来越多，此时会定期执行 merge。每次 merge 的时候，会将多个 segment file 合并成一个，同时这里会将标识为 deleted 的 doc 给物理删除掉，然后将新的 segment file 写入磁盘，这里会写一个 commit point，标识所有新的 segment file，然后打开 segment file 供搜索使用，同时删除旧的 segment file。

ES 优化

1. filesystem cache
   • 加内存
   • document 太大，可以 es + hbase
2. 数据预热
3. 冷热分离，不要让冷数据冲刷掉热数据
4. 不用分页，向微博一样用 scroll

References

• Java 进阶扫盲

优点：

• 解耦，producer 无需关心 consumer
• 异步，consumer 异步写库
• 削峰，高峰期

缺点：

• 可用性降低
• 复杂度提高。重复消费，消息丢失，消息顺序性
• 一致性

高可用

HA, HighAvailability

RabbitMQ

• 单机模式
• 普通集群模式(无高可用)。数据在一台实例上，其他的同步 queue 元信息(用元信息找到存放数据的实例)
• 镜像集群模式

Kafka

写数据的时候，生产者就写 leader，然后 leader 将数据落地写本地磁盘，接着其他 follower 自己主动从 leader 来 pull 数据。一旦所有 follower 同步好数据了，就会发送 ack 给 leader，leader 收到所有 follower 的 ack 之后，就会返回写成功的消息给生产者。（当然，这只是其中一种模式，还可以适当调整这个行为）

消费的时候，只会从 leader 去读，但是只有当一个消息已经被所有 follower 都同步成功返回 ack 的时候，这个消息才会被消费者读到。

重复消费

通常由下游保证。

可靠消息

• 生产者丢了 => MQ ack
• MQ 丢了 => MQ ack until persistence completion
• consumer 丢了 => consumer ack

消费积压

• 紧急扩容，加速消费
• 大量积压快过期了，可以先批量重导

设计一个 MQ

• 可伸缩性，broker->topic->partition
• 可靠性，持久化到磁盘，顺序写
• 可用性，leader->follower

Reference

• Java 进阶扫盲
• RabbitMQ 中 exchange、route、queue 的关系

文件打开模式的选项在每个编程语言里都有（因为其实基本都只是 wrap 了 C 的 IO 模块，所以大同小异）。

source: open-built-in-function-difference-between-modes-a-a-w-w-and-r?

remove trailing spaces

移除行尾后的空格，不然有时候会污染 git 的 diff。

在 VSCode 里把 "files.trimTrailingWhitespace": true 就好了。

source: Remove trailing spaces automatically or with a shortcut

正则表达式

因为这几天正则搞得比较多。主要是 ? 的 case 的问题之前不太清晰。还寻思着过段时间把上次挖坑的 regular expression engine 写掉的。

• ^, start
• $, end
• *, {0, }
• +, {1, }
• ?, {0, 1}
• ., any character except newline
• (?:x), non-capture
• x(?=y), match x only if suffix with y
• x(?=y), match x only if not suffix with y
• x|y, or
• {}, limit times
• \d, [0-9]
• \D, [^0-9]
• \s, space
• \S, non space
• \w, [A-Za-z0-9_]
• \W, [^A-Za-z0-9_]

source: 正则表达式 - MDN

带宽（bandwidth）

1Mbps = 1M bit per second = 1024 bit per second = 128 kb/s

二项式定理（binomial theorem）

$$
(x + y)^{n} = \sum_{k=0}^{n} {n \choose k} x^{n-k} y^{k}
$$

操作系统时间线

0x3f3f3f3f

1

const int INF = 0x3f3f3f3f;

在数据范围不超过 $10^{9}$ 的情况下，可以作为无穷大使用，有两个好处：

1. INF + INF 仍然是正数
2. 可以在 memset 中使用

   1	memset(a, 0x3f, sizeof(a))

prerequisites

• POJO: plain ordinary java object
  • PO: persistent object
  • BO: business object
  • VO: value/view object
  • DTO: data Transfer object
  • DAO: data access object

编程规约

（一）命名风格

• 抽象类命名使用 Abstract 或 Base 开头 ;
• POJO 类中布尔类型的变量，都不要加 is 前缀 ，否则部分框架解析会引起序列化错误。
• 枚举类名建议带上 Enum 后缀

（二）常量定义

• 在 long 或者 Long 赋值时，数值后使用大写的 L ，不能是小写的 l ，小写容易跟数字 1 混淆，造成误解。

（三）代码格式

• 采用 4 个空格缩进，禁止使用 tab 字符。

（四）OOP 规约

• Object 的 equals 方法容易抛空指针异常，应使用常量或确定有值的对象来调用 equals 。推荐使用 java . util . Objects # equals(JDK 7 引入的工具类 )
• 关于基本数据类型与包装数据类型的使用标准如下:
  1. 【强制】所有的 POJO 类属性必须使用包装数据类型。
  2. 【强制】 RPC 方法的返回值和参数必须使用包装数据类型。
  3. 【推荐】所有的局部变量使用基本数据类型。
• 禁止在 POJO 类中，同时存在对应属性 xxx 的 isXxx() 和 getXxx() 方法。框架在调用属性 xxx 的提取方法时，并不能确定哪个方法一定是被优先调用到。
• 使用索引访问用 String 的 split 方法得到的数组时，需做最后一个分隔符后有无内容的检查，否则会有抛 IndexOutOfBoundsException 的风险。（源码的实现会舍去末尾的空字符）

  1 2 3 4 5 6 7 8 9

  // Construct result int resultSize = list.size(); if (limit == 0) { while (resultSize > 0 && list.get(resultSize - 1).length() == 0) { resultSize--; } } String[] result = new String[resultSize]; return list.subList(0， resultSize).toArray(result);

• 循环体内，字符串的连接方式，使用 StringBuilder 的 append 方法进行扩展。

（五）集合处理

• ArrayList 的 subList 结果不可强转成 ArrayList 。subList 返回的是 ArrayList 的内部类 SubList ，并不是 ArrayList 而是 ArrayList
  的一个视图，对于 SubList 子列表的所有操作最终会反映到原列表上。
• 使用集合转数组的方法，必须使用集合的 toArray(T[] array) ，传入的是类型完全一样的数组，大小就是 list.size() 。直接使用 toArray 无参方法存在问题，此方法返回值只能是 Object[] 类，若强转其它类型数组将出现 ClassCastException 错误。
• 使用工具类 Arrays . asList() 把数组转换成集合时，不能使用其修改集合相关的方法。sList 的返回对象是一个 Arrays 内部类，并没有实现集合的修改方法。 Arrays . asList 体现的是适配器模式，只是转换接口，后台的数据仍是数组。
• 泛型通配符<? extends T >来接收返回的数据，此写法的泛型集合不能使用 add 方法，而 <? super T> 不能使用 get 方法，作为接口调用赋值时易出错。扩展说一下 PECS(Producer Extends Consumer Super) 原则:第一、频繁往外读取内容的，适合用<? extends T >。第二、经常往里插入的，适合用 <? super T> 。
• 集合初始化时,指定集合初始值大小。
• 使用 entrySet 遍历 Map 类集合 KV ,而不是 keySet 方式进行遍历。
• Map 类对 null 值的处理。

集合类	Key	Value	Super	说明
Hashtable	no	no	Dictionary	thread safe
ConcurrentHashMap	no	no	AbstractMap	锁分段（JDK8: CAS）
TreeMap	no	yes	AbstractMap	thread unsafe
HashMap	yes	yes	AbstractMap	thread unsafe

（六） 并发处理

• 【强制】创建线程或线程池时请指定有意义的线程名称,方便出错时回溯。
• 【强制】线程池不允许使用 Executors 去创建,而是通过 ThreadPoolExecutor 的方式,这样的处理方式让写的同学更加明确线程池的运行规则,规避资源耗尽的风险。
  1. FixedThreadPool 和 SingleThreadPool :
     允许的请求队列长度为 Integer.MAX_VALUE ,可能会堆积大量的请求,从而导致 OOM 。
  2. CachedThreadPool 和 ScheduledThreadPool :
     允许的创建线程数量为 Integer.MAX_VALUE ,可能会创建大量的线程,从而导致 OOM 。
• 并发修改同一记录时,避免更新丢失,需要加锁。要么在应用层加锁,要么在缓存加锁,要么在数据库层使用乐观锁,使用 version 作为更新依据。如果每次访问冲突概率小于 20%,推荐使用乐观锁,否则使用悲观锁。乐观锁的重试次数不得小于 3 次。
• 多线程并行处理定时任务时, Timer 运行多个 TimeTask 时,只要其中之一没有捕获抛出的异常,其它任务便会自动终止运行,使用 ScheduledExecutorService 则没有这个问题。
• 使用 CountDownLatch 进行异步转同步操作,每个线程退出前必须调用 countDown 方法,线程执行代码注意 catch 异常,确保 countDown 方法被执行到,避免主线程无法执行至 await 方法,直到超时才返回结果。
• HashMap 在容量不够进行 resize 时由于高并发可能出现死链,导致 CPU 飙升, 在开发过程中可以使用其它数据结构或加锁来规避此风险。
• ThreadLocal 无法解决共享对象的更新问题, ThreadLocal 对象建议使用 static修饰。这个变量是针对一个线程内所有操作共享的,所以设置为静态变量,所有此类实例共享此静态变量 ,也就是说在类第一次被使用时装载,只分配一块存储空间,所有此类的对象 ( 只要是这个线程内定义的 ) 都可以操控这个变量。

（七）控制语句

• 【参考】下列情形,需要进行参数校验:
  1. 调用频次低的方法。
  2. 执行时间开销很大的方法。此情形中,参数校验时间几乎可以忽略不计,但如果因为参
     数错误导致中间执行回退,或者错误,那得不偿失。
  3. 需要极高稳定性和可用性的方法。
  4. 对外提供的开放接口,不管是 RPC / API / HTTP 接口。
  5. 敏感权限入口。
• 【参考】下列情形,不需要进行参数校验:
  1. 极有可能被循环调用的方法。但在方法说明里必须注明外部参数检查要求。
  2. 底层调用频度比较高的方法。毕竟是像纯净水过滤的最后一道,参数错误不太可能到底
     层才会暴露问题。一般 DAO 层与 Service 层都在同一个应用中,部署在同一台服务器中,所
     以 DAO 的参数校验,可以省略。
  3. 被声明成 private 只会被自己代码所调用的方法,如果能够确定调用方法的代码传入参
     数已经做过检查或者肯定不会有问题,此时可以不校验参数。

（八） 注释规约

（九）其它

• 【强制】后台输送给页面的变量必须加 $!{var} ——中间的感叹号。
• 在 JDK 8 中, 针对统计时间等场景,推荐使用 Instant 类。

异常日志

(一) 异常处理

• 【推荐】防止 NPE ,是程序员的基本修养,注意 NPE 产生的场景:
  1. 返回类型为基本数据类型, return 包装数据类型的对象时,自动拆箱有可能产生 NPE 。
  2. 数据库的查询结果可能为 null 。
  3. 集合里的元素即使 isNotEmpty ,取出的数据元素也可能为 null 。
  4. 远程调用返回对象时,一律要求进行空指针判断,防止 NPE 。
  5. 对于 Session 中获取的数据,建议 NPE 检查,避免空指针。
  6. 级联调用 obj.getA().getB().getC(); 一连串调用,易产生 NPE 。

(二) 日志规约

• 应用中不可直接使用日志系统 (Log 4 j 、 Logback) 中的 API ,而应依赖使用日志框架 SLF4J（Simple Logging Facade for Java）中的 API ,使用门面模式的日志框架,有利于维护和各个类的日志处理方式统一。

单元测试

安全规约

• 【强制】表单、 AJAX 提交必须执行 CSRF 安全验证。

MySQL 数据库

(一) 建表规约

• 【强制】表达是与否概念的字段,必须使用 is_xxx 的方式命名,数据类型是 unsigned tinyint(1 表示是,0 表示否)。
• 【强制】主键索引名为 pk_ 字段名;唯一索引名为 uk _字段名 ; 普通索引名则为 idx _字段名。
• 【强制】小数类型为 decimal ,禁止使用 float 和 double 。
• 【强制】如果存储的字符串长度几乎相等,使用 char 定长字符串类型。
• 【强制】表必备三字段: id , gmt _ create , gmt _ modified 。
• 【推荐】字段允许适当冗余,以提高查询性能,但必须考虑数据一致。冗余字段应遵循:
  1. 不是频繁修改的字段。
  2. 不是 varchar 超长字段,更不能是 text 字段。
• 【推荐】单表行数超过 500 万行或者单表容量超过 2 GB ,才推荐进行分库分表。

(二) 索引规约

• 【强制】业务上具有唯一特性的字段,即使是多个字段的组合,也必须建成唯一索引。
• 【强制】在 varchar 字段上建立索引时,必须指定索引长度,没必要对全字段建立索引,根据实际文本区分度决定索引长度即可。索引的长度与区分度是一对矛盾体,一般对字符串类型数据,长度为 20 的索引,区分度会高达 90% 以上,可以使用 count(distinct left( 列名, 索引长度 )) / count( * ) 的区分度来确定。
• 【强制】页面搜索严禁左模糊或者全模糊
• 【推荐】如果有 order by 的场景,请注意利用索引的有序性。
• 【推荐】利用覆盖索引来进行查询操作,避免回表。
• 【推荐】利用延迟关联或者子查询优化超多分页场景。
• 【推荐】建组合索引的时候,区分度最高的在最左边。

(三) SQL 语句

• 【强制】不要使用 count( 列名 ) 或 count( 常量 ) 来替代 count( ) , count( ) 是 SQL 92 定义的标准统计行数的语法,跟数据库无关,跟 NULL 和非 NULL 无关。count( * ) 会统计值为 NULL 的行,而 count( 列名 ) 不会统计此列为 NULL 值的行。
• 【强制】 count(distinct col) 计算该列除 NULL 之外的不重复行数,注意 count(distinct col 1, col 2 ) 如果其中一列全为 NULL ,那么即使另一列有不同的值,也返回为 0。
• 【强制】当某一列的值全是 NULL 时, count(col) 的返回结果为 0,但 sum(col) 的返回结果为 NULL ,因此使用 sum() 时需注意 NPE 问题。
• 【强制】使用 ISNULL() 来判断是否为 NULL 值。NULL 与任何值的直接比较都为 NULL。
• 【强制】不得使用外键与级联,一切外键概念必须在应用层解决。

(四) ORM 映射

• 【强制】 POJO 类的布尔属性不能加 is ,而数据库字段必须加 is _,要求在 resultMap 中进行字段与属性之间的映射。
• 【强制】不要用 resultClass 当返回参数,即使所有类属性名与数据库字段一一对应,也需要定义 ; 反过来,每一个表也必然有一个 POJO 类与之对应。
• 【强制】 sql. xml 配置参数使用: #{}, # param # 不要使用${} 此种方式容易出现 SQL 注入。
• 【参考】< isEqual >中的 compareValue 是与属性值对比的常量,一般是数字,表示相等时带上此条件 ; < isNotEmpty >表示不为空且不为 null 时执行 ; < isNotNull >表示不为 null 值时执行。

工程结构

(一) 应用分层

(二) 二方库依赖

• 【强制】二方库里可以定义枚举类型,参数可以使用枚举类型,但是接口返回值不允许使用枚举类型或者包含枚举类型的 POJO 对象。

(三) 服务器

• 【推荐】高并发服务器建议调小 TCP 协议的 time _ wait 超时时间。操作系统默认 240 秒。在 linux 服务器上请通过变更/ etc / sysctl . conf 文件去修改该缺省值 ( 秒 ) :

  1	net.ipv4.tcp_fin_timeout = 30

• 【推荐】调大服务器所支持的最大文件句柄数 (File Descriptor ,简写为 fd) 。
• 【推荐】给 JVM 环境参数设置- XX :+ HeapDumpOnOutOfMemoryError 参数,让 JVM 碰到 OOM 场景时输出 dump 信息。
• 【推荐】在线上生产环境, JVM 的 Xms（JVM初始分配的堆内存 ） 和 Xmx（JVM最大允许分配的堆内存，按需分配 ） 设置一样大小的内存容量,避免在 GC 后调整堆大小带来的压力。

ssh service

• useradd -m [username], -m will automatically create new user folder in /home
• passwd [username], configure password
• usermod -s /bin/bash [username], change default login shell
  • cat /etc/passwd list all users
  • cat /etc/shells list all available shells
• usermod -aG sudo pwxcoo，grant sudo privileges
  • groups check group of current user
• in client，scp id_rsa.pub [username]@[server address]:/home/[username] transfer public key to server
• back to server，mv id_rsa.pub .ssh/authorized_keys will be ok

nginx

• sudo apt update
• sudo apt install nginx
• cd /etc/nginx/conf.d (NGINX site-specific configuration files are kept in /etc/nginx/conf.d)
• simple template. example.com.conf

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

  server { listen 80; server_name example.com; #charset koi8-r; #access_log /var/log/nginx/host.access.log main; location / { root /usr/share/nginx/html; index index.html index.htm; } #error_page 404 /404.html; # redirect server error pages to the static page /50x.html # error_page 500 502 503 504 /50x.html; location = /50x.html { root /usr/share/nginx/html; } }

• test nginx configration is ok
  • sudo nginx -t
  • sudo nginx -s reload

environment variables

linux will execute /etc/profile while booting up, this script will execute all script in /etc/profile.d, so add some scripts in /etc/profile.d will be easily maintained and convenient.

like jdk.sh, it will set environment variables for Java.

1
2
3
4
5

export J2SDKDIR=/usr/lib/jvm/java-8-oracle
export J2REDIR=/usr/lib/jvm/java-8-oracle/jre
export PATH=$PATH:/usr/lib/jvm/java-8-oracle/bin:/usr/lib/jvm/java-8-oracle/db/bin:/usr/lib/jvm/java-8-oracle/jre/bin
export JAVA_HOME=/usr/lib/jvm/java-8-oracle
export DERBY_HOME=/usr/lib/jvm/java-8-oracle/db

我的 vimrc: pwxcoo/vimrc

Update vim on ubuntu

How can I get a newer version of Vim on Ubuntu

• sudo add-apt-repository ppa:jonathonf/vim
• sudo apt update
• sudo apt install vim

Use System Clipboard

• sudo apt install vim-gnome
• vim --version | grep "clipboard" 查看 clipboard 前面是否是 +

然后

• "+y 复制到系统剪切板
• "+p 粘贴

replace one by one

Vim -> 边确认边查找替换

• /{which} 开始查找
• cw {what} [ESC] 删除并替换
• n 下一个单词
• . 重复上一个操作 (删除并替换)

operate multiple rows

块操作

• C-v 开始块操作
• C-d 向下移动
• 操作
  • shift + i 插入
  • J 连结所有行 (Join)
  • > / < 左右缩进
  • = 自动缩进
• [ESC] 生效

Plugins keyboard shortcut

NERDTree

• shift + i 显示隐藏文件
• m 一系列操作
  • a 创造新文件

Tabbar

• :bd 关闭 buffer (Recommend)
• :bw 关闭并不保存

NERDCommenter

• <leader> + c + <space> 快速注释

Q: 一次 http 请求的过程？

得到自己的IP地址

(假设此时主机还未配置自己的 IP 地址。)

用 DHCP (Dynamic Host Configuration Protocol) 得到自己的 IP 地址。

1. 发送 DHCP 请求

   • 应用层: 生成一个 DHCP 请求报文
   • 传输层: 加上一个 UDP 头
     • 源端口 68
     • 目标端口 67
   • 网络层: 加上一个 IP 头
     • 源IP: 0.0.0.0
     • 目标IP: 255.255.255.255
   • 数据链路层: 封装成帧
     • 源MAC: 自己的 MAC
     • 目标MAC: FF:FF:FF:FF:FF:FF

2. DHCP 服务器 (连接在同一个交换机上) 就到请求后，返回一个 DHCP ACK 报文:

• 分配给 DHCP 请求的 IP
• DNS 服务器的 IP
• 默认网关路由器的 IP
• 子网掩码

3. 交换机收到之后，缓存一下，发给主机，主机就得到这些信息

查找默认网关的MAC地址

(刚刚配置好 DHCP 需要去找到默认网关的 MAC 地址)

请求要发给默认网关的 MAC 地址，才能把请求发到局域网外部去，相当于发给默认网关路由器后，会根据 NAT 把局域网内部的 IP 地址变成局域网的 IP 地址然后发给局域网外部。

4. 生成一个 ARP 查询报文，目标 IP 是默认网关路由器，封装成帧后是一个广播帧
5. 路由器返回一个 ARP 应答报文给主机，包含了自己的 IP 地址

DNS

6. 生成 DNS 查询报文
   • 应用层: 目的域名
   • 传输层: 目的端口 53
   • 数据链路层: 默认网关路由器 MAC 地址
7. 默认网关路由器收到后，根据路由表转发
   • 内部网关协议 (RIP，OSPF)
   • 外部网关协议 (BGP)
8. DNS 解析完了，封装成 UDP => 默认网关路由器 => 交换机 => 主机

HTTP请求

9. 生成 TCP 套接字
10. 3 次握手
11. 发送 HTTP 报文
12. 响应返回，浏览器渲染

HTTPS

有的网站是 https 的，通常会把 http 请求 301 重定向到 443 端口。

• server 发送证书和公钥给 client
• client 去 CA 验证安全性
• client 用公钥加密一个随机生成的对称密钥
• server 用私钥解密，然后之后都用这个对称密钥来加密

TCP/IP

• 数据链路层: ARP，RARP
• 网络层: IP，ICMP，IGMP
• 传输层: TCP，UDP，UGP
• 应用层: Telnet，FTP，SMTP，SNMP

OSI

• 物理层: EIA/TIA-232, EIA/TIA-499, V.35, V.24, RJ45, Ethernet, 802.3, 802.5, FDDI, NRZI, NRZ, B8ZS
• 数据链路层: Frame Relay, HDLC, PPP, IEEE 802.3/802.2, FDDI, ATM, IEEE 802.5/802.2
• 网络层: IP，IPX，AppleTalk DDP
• 传输层: TCP，UDP，SPX
• 会话层: RPC,SQL,NFS,NetBIOS,names,AppleTalk,ASP,DECnet,SCP
• 表示层:TIFF,GIF,JPEG,PICT,ASCII,EBCDIC,encryption,MPEG,MIDI,HTML
• 应用层: FTP,WWW,Telnet,NFS,SMTP,Gateway,SNMP

应用层

应用层: 为特定应用程序提供数据传输服务，例如 HTTP，DNS (port 53) 。数据单位为报文 (message) 。

1. 主要功能 : 用户接口、应用程序
   application
2. 典型设备: 网关
3. 典型协议、标准和应用: TELNET, FTP, HTTP

表示层

表示层: 数据压缩，加密以及数据描述。使得应用程序不必担心中各个主机中表示/存储内部格式的不同。

1. 主要功能 : 数据的表示、压缩和加密
   presentation
2. 典型设备: 网关
3. 典型协议、标准和应用: ASCLL、PICT、TIFF、JPEG、 MIDI、MPEG

会话层

会话层: 建立和管理会话。 (PS: 在 TCP/IP 中只有应用层，这些功能都是留给应用程序开发者处理的。)

1. 主要功能 : 会话的建立和结束
   session
2. 典型设备: 网关
3. 典型协议、标准和应用: RPC、SQL、NFS 、X WINDOWS、ASP

传输层

运输层: 提供的是进程间通用数据传输服务。TCP (报文段segment) , UDP (用户数据报 datagram) 。 (PS: segment 是因为 TCP 会切分，每个 segment 是属于某个整体的，每个 segment 的在整体中的位置是确定的，A，B，C 三个 segment 最后解析后一定是 ABC 顺序的，这是 TCP 协议所保证的，而 datagram 是 independent，每个数据报是独立的，不属于某个整体。)

1. 主要功能 : 端到端控制
   transport
2. 典型设备: 网关
3. 典型协议、标准和应用: TCP、UDP、SPX

网络层

网络层: 为主机间提供数据传输服务。把运输层传来的封装成分组 (packet)

1. 主要功能 : 路由，寻址
   network
2. 典型设备: 路由器
3. 典型协议、标准和应用: IP、IPX、APPLETALK、ICMP

数据链路层

数据链路层: 主机间可以有很多链路，链路层协议就是为同一链路的节点提供服务。把网络层传来传来的分组封装成帧 (frame) 。

1. 主要功能 : 保证误差错的数据链路
   data link
2. 典型设备: 交换机、网桥、网卡
3. 典型协议、标准和应用: 802.2、802.3ATM、HDLC、FRAME RELAY

物理层

物理层: 考虑的是怎样中传输媒体上传输数据比特流 (bit) ，而不是具体传输媒介。尽可能屏蔽传输媒体和通信手段的差异，使数据链路层感受不到这些差异。

1. 主要功能 : 传输比特流
   physical
2. 典型设备: 集线器、中继器
3. 典型协议、标准和应用: V.35、EIA/TIA-232

整个传输过程中就是应用层的数据往下传，加首部，加首部，加首部 (在链路层可能要加尾部 —— CRC 校验加了 FCS) 直到解析成比特流 (1001010…) 。然后到了目标地点，去首部尾部这样，解析成最后的数据。

物理层

• 单工通信
• 半双工通信
• 全双工通信

数据链路层

差错检测

循环冗余校验 CRC (Cyclic Redundancy Check)

信道

广播信道

一对多通信，一个节点发送的数据能够被广播信道上所有的节点接收到。

所有的节点都在同一个广播信道上发送数据，因此需要有专门的控制方法进行协调，避免发生冲突 (冲突也叫碰撞) 。

主要有两种控制方法进行协调，一个是使用信道复用技术，一是使用 CSMA/CD 协议。

CSMA/CD (Carrier Sense Multiple Access with Collision Detection) ，载波监听多点接入/碰撞检测。原理:

• 先听后发，边发边听，冲突停发，随机延迟后重发

点对点信道

一对一通信，用 PPP 协议，信息部分字节不超过 1500

信道复用技术

• 频分复用 (占用不同的频率带宽)
• 时分复用，每个主机发个时间片
• 统计时分复用，把数据集中起来组成统计时分复用帧发送
• 波分复用，光的波长
• 码分复用

MAC地址

长度 6 字节 (48位) 。

网络层

概述

• IP (Internet Protocol)
• 地址解析协议 ARP (Address Resolution Protocol)
• 网际控制报文协议 ICMP (Internet Control Message Protocol)
• 网际组管理协议 IGMP (Internet Group Management Protocol)

IP数据报格式

• 版本 (4位) : 4, 6 两个值。
• 首部长度 (4位) : 最大值 15，单位是 4 字节 (32位) ，首部固定长度 20 字节，所以最小值 5 。如果可选字段的长度不是 4 字节的整数倍，就用尾部的填充部分来填充。
• 区分服务 (8位) : 来获得更好的服务，一般情况下不使用。
• 总长度 (16位) : 包括首部长度和数据部分长度。
• 标识 (16位) : 在数据报长度过长从而发生分片的情况下，相同数据报的不同分片具有相同的标识符。
• 片偏移 (16位) : 和标志 (3位) 一起，用于标志分片的情况。标志中目前只有前两位有意义。标志字段的最低位是MF (More Fragment)。MF = 1 表示后面“还有分片”。MF = 0 表示最后一个分片。标志字段中间的一位是 DF (Don’t Fragment)。只有当 DF = 0时才允许分片。片偏移的单位为 8 字节。
• 生存时间 (8位) : TTL，防止无法交付的数据报在互联网中兜圈子。以路由器跳数为单位，TTL 为 0 时就丢弃数据报。
• 协议 (8位) 指出携带的数据应该交给那个协议来处理，例如 TCP，UDP 等。
• 首部校验和 (16位)
• 源地址 (32位)
• 目标地址 (32位)
• 可选字段 + 填充 (32位)

地址解析协议ARP

ARP 实现由 IP 地址得到 MAC 地址。每个主机都有一个 ARP 高速缓存，里面有本局域网上各主机和路由器 IP 地址到硬件地址的映射表。

网际控制报文协议ICMP

ICMP 是为了更有效地转发 IP 数据报和提高交付成功的机会。分为差错报告报文，询问报文。

1. Ping，ICMP 的一个重要应用，发送的 IP 数据报是无法交付的 UDP 用户数据报。
2. Tracroute，跟踪一个分组从源点到终点的路径。

网络地址转换NAT

将本地 IP 转换成全球 IP。

路由选择协议

• 自治系统内部的路由选择协议: RIP 和 OSPF
• 自治系统间的路由选择: BGP

RIP (Routing Information Protocol)

基于向量的路由选择协议，实现简单，开销小。但是最大使用距离为 15，限制了网络的规模。

OSPF (Open Shortest Path First)

开放最短路径优先 OSPF。相比与 RIP，OSPF 更新收敛地更快。

BGP (Border Gateway Protocol)

在每个 AS (Autonomous System) 都必须配置 BGP 发言人，通过在两个相邻 BGP 发言人之间建立 TCP 连接来交换路由信息。

运输层

提供进程间的通信。

TCP和UDP

• 用户数据报协议 UDP (User Datagram Protocol) 是无连接的，尽最大努力交付，没有拥塞控制，面向报文，支持一对一，一对多，多对一，多对多的交互通信。
• 传输控制协议 TCP (Transmission Control Protocol) 是面向连接的，提供可靠交付，有流量控制，拥塞控制，提供全双工通信，面向字节流的，每个 TCP 连接只能是点对点 (一对一的) 。

UDP

首部字段只有 8 个字节，包括源端口，目的端口，长度，检验和。12 字节的伪首部是为了计算检验和临时添加的。

TCP

TCP首部

• 序号 (32位) : 用于对字节流进行编号，例如序号为 301，表示第一个字节的编号为 301，如果携带的数据长度为 100 字节，那么下一个报文段的序号应为 401。
• 确认号 (32位) : 期望收到的下一个报文段的序号。例如 B 正确收到 A 发送来的一个报文段，序号为 501，携带的数据长度为 200 字节，因此 B 期望下一个报文段的序号为 701，B 发送给 A 的确认报文段中确认号就为 701。
• 数据偏移 (4位) : 指的是数据部分距离报文段起始处的偏移量，实际上指的是首部的长度。
• 确认 ACK (1位) : 当 ACK=1 时确认号字段有效，否则无效。TCP 规定，在连接建立后所有传送的报文段都必须把 ACK 置 1。
• 同步 SYN (1位) : 在连接建立时用来同步序号。当 SYN=1，ACK=0 时表示这是一个连接请求报文段。若对方同意建立连接，则响应报文中 SYN=1，ACK=1。
• 终止 FIN (1位) : 用来释放一个连接，当 FIN=1 时，表示此报文段的发送方的数据已发送完毕，并要求释放连接。
• 窗口 (16位) : 窗口值作为接收方让发送方设置其发送窗口的依据。之所以要有这个限制，是因为接收方的数据缓存空间是有限的。表示传送的数据字节数。

TCP握手

• 首先 B 处于 LISTEN (监听) 状态，等待客户的连接请求。
• A 向 B 发送连接请求报文段，SYN=1，ACK=0，选择一个初始的序号 x。
• B 收到连接请求报文段，如果同意建立连接，则向 A 发送连接确认报文段，SYN=1，ACK=1，确认号为 x+1，同时也选择一个初始的序号 y。
• A 收到 B 的连接确认报文段后，还要向 B 发出确认，确认号为 y+1，序号为 x+1。
• B 收到 A 的确认后，连接建立。

PS: 如果第三次 ACK 一直没收到，server 端会重传第二次握手，一定次数后会关闭连接。但此时 client 以为连接以及建立，发送请求后，server 端会在回复报文中将 RST 置为 1，client 就知道了连接未建立，重置 TCP 连接

TCP挥手

• A 发送连接释放报文段，FIN=1。
• B 收到之后发出确认，此时 TCP 属于半关闭状态，B 能向 A 发送数据但是 A 不能向 B 发送数据。
• 当 B 不再需要连接时，发送连接释放请求报文段，FIN=1。
• A 收到后发出确认，进入 TIME-WAIT 状态，等待 2 MSL 时间后释放连接。
• B 收到 A 的确认后释放连接。

客户端接收到服务器端的 FIN 报文后进入此状态，此时并不是直接进入 CLOSED 状态，还需要等待一个时间计时器设置的时间 2MSL。这么做有两个理由:

• 确保最后一个确认报文段能够到达。如果 B 没收到 A 发送来的确认报文段，那么就会重新发送连接释放请求报文段，A 等待一段时间就是为了处理这种情况的发生。
• 等待一段时间是为了让本连接持续时间内所产生的所有报文段都从网络中消失，使得下一个新的连接不会出现旧的连接请求报文段。

TCP可靠性

• 检验和
• 序列号
• ACK
• 超时重传
• 连接管理
• 流量控制
• 拥塞控制

TCP滑动窗口

窗口是缓存的一部分，用来暂时存放字节流。接收窗口只会对窗口内最后一个按序到达的字节进行确认。

TCP流量控制

流量控制是为了控制发送方发送速率，保证接收方来得及接收。

TCP拥塞控制

出现拥塞时，应当控制发送方的速率。

TCP 主要通过四种算法来进行拥塞控制: 慢开始、拥塞避免、快重传、快恢复。

发送方需要维护一个叫做拥塞窗口 (cwnd) 的状态变量，注意拥塞窗口与发送方窗口的区别: 拥塞窗口只是一个状态变量，实际决定发送方能发送多少数据的是发送方窗口。

1. 慢开始与拥塞避免: 发送的最初执行慢开始，令 cwnd=1，发送方只能发送 1 个报文段；当收到确认后，将 cwnd 加倍，因此之后发送方能够发送的报文段数量为: 2、4、8 … 注意到慢开始每个轮次都将 cwnd 加倍，这样会让 cwnd 增长速度非常快，从而使得发送方发送的速度增长速度过快，网络拥塞的可能也就更高。设置一个慢开始门限 ssthresh，当 cwnd >= ssthresh 时，进入拥塞避免，每个轮次只将 cwnd 加 1。如果出现了超时，则令 ssthresh = cwnd/2，然后重新执行慢开始。

2. 快重传与快恢复: 在接收方，要求每次接收到报文段都应该发送对已收到有序报文段的确认，例如已经接收到 M1 和 M2，此时收到 M4，应当发送对 M2 的确认。在发送方，如果收到三个重复确认，那么可以确认下一个报文段丢失，例如收到三个 M2 ，则 M3 丢失。此时执行快重传，立即重传下一个报文段。在这种情况下，只是丢失个别报文段，而不是网络拥塞，因此执行快恢复，令 ssthresh = cwnd/2 ，cwnd = ssthresh，注意到此时直接进入拥塞避免。慢开始和快恢复的快慢指的是 cwnd 的设定值，而不是 cwnd 的增长速率。慢开始 cwnd 设定为 1，而快恢复 cwnd 设定为 ssthresh。

应用层

DNS (Domain Name System) (port 53)

大多数情况下 DNS 使用 UDP 进行传输，这就要求域名解析器和域名服务器都必须自己处理超时和重传来保证可靠性。在两种情况下会使用 TCP 进行传输:

• 数据太大，用 TCP 进行传输。
• 区域传送是主域名服务器向辅助域名服务器传送变化的那部分数据，区域传送需要使用 TCP 进行传输。

FTP (File Transfer Protocol) (port 21/20)

FTP 使用 TCP 进行连接，它需要两个连接来传送一个文件:

• 控制连接: 服务器以打开端口号 21 等待客户端的连接，客户端主动建立连接后，使用这个连接将客户端的命令传送给服务器，并传回服务器的应答。
• 数据连接: 用来传送一个文件。

FTP 有主动和被动两种模式:

• 主动模式: 服务器端主动建立数据连接，其中服务器端的端口号为 20，客户端的端口号随机，但是必须大于 1024，因为 0~1023 是熟知端口号。
• 被动模式: 客户端主动建立数据连接，其中客户端的端口号由客户端自己指定，服务器端的端口号随机。

主动模式要求客户端开放端口号给服务器端，需要去配置客户端的防火墙。被动模式只需要服务器端开放端口号即可，无需客户端配置防火墙。但是被动模式会导致服务器端的安全性减弱，因为开放了过多的端口号。

Telnet(port 23)

远程登录协议

电子邮件协议

发送协议常用 SMTP (Simple Mail Transfer Protocol) ，读取协议常用 POP3 (Post Office Protocol - Version 3) 和 IMAP (Internet Mail Access Protocol) 。

• POP3 (port 110) : POP3 的特点是只要用户从服务器上读取了邮件，就把该邮件删除。
• IMAP (port 143) : IMAP 协议中客户端和服务器上的邮件保持同步，如果不去手动删除邮件，那么服务器上的邮件也不会被删除。IMAP 这种做法可以让用户随时随地去访问服务器上的邮件。
• SMTP (port 25) : SMTP 只能发送 ASCII 码，而互联网邮件扩充 MIME 可以发送二进制文件。MIME 并没有改动或者取代 SMTP，而是增加邮件主体的结构，定义了非 ASCII 码的编码规则。

DHCP (Dynamic Host Configuration Protocol)

DHCP (Dynamic Host Configuration Protocol) 提供了即插即用的连网方式，用户不再需要去手动配置 IP 地址等信息。

DHCP 工作过程如下:

• 客户端发送 Discover 报文，该报文的目的地址为 255.255.255.255:67，源地址为 0.0.0.0:68，被放入 UDP 中，该报文被广播到同一个子网的所有主机上。
• DHCP 服务器收到 Discover 报文之后，发送 Offer 报文给客户端，该报文包含了客户端所需要的信息。因为客户端可能收到多个DHCP 服务器提供的信息，因此客户端需要进行选择。
• 如果客户端选择了某个 DHCP 服务器提供的信息，那么就发送 Request 报文给该 DHCP 服务器。
• DHCP 服务器发送 Ack 报文，表示客户端此时可以使用提供给它的信息。

如果客户端和 DHCP 服务器不在同一个子网，就需要使用中继代理。

References

• Interview-Notebook/notes/计算机网络.md

因为很多题以前做过，所以做的还是比较快的。因为想熟悉一下 Java ,所以全部都用 Java 写的。leetcode 很多都是面试题，所以题目都是基本，没有什么特别难的题目，几道 hard 也没有特别难的。但是很多题目很经典，而且社区很活跃，Discuss 里很多神仙。有几道题目真的让我感觉到“还有这种操作？”的感受，因为思路太秀了。

之所以特地现在做一个中断，是因为前面 150 道比较经典，虽然很多类型的题目还没出现过，但是最新的题目我做过一些，有凸包，有最短路径什么的，而且 150-200 题之前很多 easy 和 medium，太水了，我懒得做了。我大概浏览了一下 150-200 的 hard，知道了基本的思路，然后就打算先这样中断一下，不打算最近撸了，之后如果没什么特别需要的地方，可能就每周做一下 Contest 吧。

因为有几道题目很帅，所以特地记录一下，有空可以在做一遍这几道。

leetcode32

leetcode32. Longest Valid Parentheses

可以用 DP ，也可以用栈来做。我用了 DP 。官方 Solution 很详细了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

class Solution {
    public int longestValidParentheses(String s) {
        int len = s.length();
        int[] dp = new int[len];
        int res = 0;

        for(int i = 0; i < len; i++)
        {
            if(i - 1 >= 0 && s.charAt(i) == ')')
            {
                if(s.charAt(i - 1) == '(')
                {
                    if(i >= 2) dp[i] = dp[i - 2] + 2;
                    else dp[i] = 2;
                }
                else if(s.charAt(i - 1) == ')')
                {
                    if(i - 1 - dp[i - 1] >= 0 && s.charAt(i - 1 - dp[i - 1]) == '(')
                    {
                        dp[i] = dp[i - 1] + 2;
                        if(i - 2 - dp[i - 1] >= 0) dp[i] += dp[i - 2 - dp[i - 1]];
                    }
                }
                res = Math.max(res, dp[i]);
            }
        }

        return res;
    }
}

leetcode42

leetcode42. Trapping Rain Water

用两个指针向中间收敛来维护一个变量。官方的 Solution 也很详细。也可以用 DP 或者栈来做。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

class Solution {
    public int trap(int[] height) {
        if(height.length <= 2) return 0;
        int left = 0, right = height.length - 1;
        int res = 0, level = Math.min(height[left], height[right]);

        while(left < right)
        {
            if(height[left] <= height[right])
            {
                left++;
                if(height[left] > level)
                {
                    level = Math.min(height[left], height[right]);
                }
                else
                {
                    res += level - height[left];
                }
            }
            else
            {
                right--;
                if(height[right] > level)
                {
                    level = Math.min(height[left], height[right]);
                }
                else
                {
                    res += level - height[right];
                }
            }
        }
        return res;
    }
}

leetcode69

leetcode69. Sqrt(x)

题目贴的 tag 是 binary search，想考查的是二分查找，用二分查找可以。但是一般标准库里用的是 sqrt() 用的是牛顿迭代法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

/**
 *  1. 二分查找
 */
class Solution {
    public int mySqrt(int x) {
        if (x == 0)
            return 0;
        int left = 1, right = Integer.MAX_VALUE;
        while (true) {
            int mid = left + (right - left)/2;
            if (mid > x/mid) {
                right = mid - 1;
            } else {
                if (mid + 1 > x/(mid + 1))
                    return mid;
                left = mid + 1;
            }
        }
    }
}


/**
 *  2. 牛顿迭代法
 */
class Solution {
    public int mySqrt(int x) {
        long r = x;
        while (r*r > x)
            r = (r + x/r) / 2;
        return (int) r;
    }
}

leetcode84

leetcode84. Largest Rectangle in Histogram

可以转化成最大01矩阵问题，但是会超时。当然用栈来模拟。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

class Solution {
    public int largestRectangleArea(int[] heights) {
        Stack<Integer> st = new Stack<>();
        int res = 0, cnt = 0;
        for(int i = 0; i < heights.length; i++)
        {
            if(st.empty() || heights[i] >= st.peek())
            {
                st.push(heights[i]);
            }
            else
            {
                cnt = 0;
                while(!st.empty() && heights[i] < st.peek())
                {
                    res = Math.max(res, ++cnt * st.pop());
                }
                while(cnt-- >= 0) st.push(heights[i]);
            }
        }
        cnt = 0;
        while(!st.empty())
        {
            res = Math.max(res, ++cnt * st.pop());
        }
        return res;
    }
}

leetcode132

leetcode132. Palindrome Partitioning II

两种DP。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

class Solution {
    public int minCut(String s) {
        boolean[][] isPalindrome = new boolean[s.length()][s.length()];
        int[] dp = new int[s.length() + 1];
        for(int i = 0; i <= s.length(); i++) dp[i] = s.length() - i - 1;

        for(int i = s.length() - 1; i >= 0; i --)
        {
            isPalindrome[i][i] = true;
            dp[i] = dp[i + 1] + 1;
            for(int j = i + 1; j < s.length(); j++)
            {
                if(s.charAt(i) == s.charAt(j) && (i + 1 == j || isPalindrome[i + 1][j - 1]))
                {
                    isPalindrome[i][j] = true;
                    if(dp[j + 1] + 1 < dp[i])
                    {
                        dp[i] = dp[j + 1] + 1;
                    }
                }
            }
        }
        return dp[0];
    }
}

class Solution {
    public int minCut(String s) {
        int[] dp = new int[s.length() + 1];
        for(int i = 0; i <= s.length(); i++) dp[i] = i - 1;

        for(int i = 0; i < s.length(); i++)
        {
            for(int j = 0; i - j >= 0 && i + j < s.length() && s.charAt(i - j) == s.charAt(i + j); j++) // odd
                dp[i + j + 1] = Math.min(dp[i + j + 1], dp[i - j] + 1);
            for(int j = 0; i - j - 1 >= 0 && i + j < s.length() && s.charAt(i - j - 1) == s.charAt(i + j); j++) // even
                dp[i + j + 1] = Math.min(dp[i + j + 1], dp[i - j - 1] + 1);
        }
        return dp[s.length()];
    }
}

leetcode137

leetcode137. Single Number II

感受到布尔代数的魅力了。一波位运算毁天灭地。

1
2
3
4
5
6
7
8
9
10
11

class Solution {
    public int singleNumber(int[] nums) {
        int one = 0, two = 0;
        for(int num : nums)
        {
            one = (one ^ num) & ~two;
            two = (two ^ num) & ~one;
        }
        return one;
    }
}

leetcode146

leetcode146. LRU Cache

实现一个 LRU(Least Recently Used) 的 cache 类。突然感受了一下学操作系统学到的东西，这个看起来很简单的东西，实现起来还是有点秀的。用双向链表和哈希表来实现，让查询和插入都为O(1)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

class LRUCache {

    class DLinkedNode {
        int key;
        int value;
        DLinkedNode pre;
        DLinkedNode post;
    }

    /**
     * Always add the new node right after head;
     */
    private void addNode(DLinkedNode node){
        node.pre = head;
        node.post = head.post;

        head.post.pre = node;
        head.post = node;
    }

    /**
     * Remove an existing node from the linked list.
     */
    private void removeNode(DLinkedNode node){
        DLinkedNode pre = node.pre;
        DLinkedNode post = node.post;

        pre.post = post;
        post.pre = pre;
    }

    /**
     * Move certain node in between to the head.
     */
    private void moveToHead(DLinkedNode node){
        this.removeNode(node);
        this.addNode(node);
    }

    // pop the current tail.
    private DLinkedNode popTail(){
        DLinkedNode res = tail.pre;
        this.removeNode(res);
        return res;
    }

    private Map<Integer, DLinkedNode> cache = new HashMap<Integer, DLinkedNode>();
    private int count;
    private int capacity;
    private DLinkedNode head, tail;

    public LRUCache(int capacity) {
        this.count = 0;
        this.capacity = capacity;

        head = new DLinkedNode();
        head.pre = null;

        tail = new DLinkedNode();
        tail.post = null;

        head.post = tail;
        tail.pre = head;
    }

    public int get(int key) {

        DLinkedNode node = cache.get(key);
        if(node == null){
            return -1; // should raise exception here.
        }

        // move the accessed node to the head;
        this.moveToHead(node);

        return node.value;
    }


    public void put(int key, int value) {
        DLinkedNode node = cache.get(key);

        if(node == null){

            DLinkedNode newNode = new DLinkedNode();
            newNode.key = key;
            newNode.value = value;

            this.cache.put(key, newNode);
            this.addNode(newNode);

            ++count;

            if(count > capacity){
                // pop the tail
                DLinkedNode tail = this.popTail();
                this.cache.remove(tail.key);
                --count;
            }
        }else{
            // update the value.
            node.value = value;
            this.moveToHead(node);
        }

    }
}

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache obj = new LRUCache(capacity);
 * int param_1 = obj.get(key);
 * obj.put(key,value);
 */

leetcode166

leetcode166. Fraction to Recurring Decimal

写一个除法生成分数。比较难的用无线循环小数的时候，用哈希表存储余数，key存储余数，value存储起始的位置。如果重复就在起始位置插入’(‘。

leetcode187

leetcode187. Repeated DNA Sequences

用三位就可以表示 A，C，G，T。10个的话用 30 位表示一个序列保存到哈希表中。

总结

这几道是真的很秀。我这几天的代码全在这里了。

放一张图片。

果断选择了王爽的《汇编语言 (第三版) 》。

因为是有习题的，所以把习题就顺便记录了下来。

前面 11 章的答案我都 debug 验证过了，网上的答案有很多错误。从 12 章开始，我开始瞎屁股浏览了。主要是因为前面 11 章的内容让我比较喜欢，后面的较多的理论元素和一些指令完善，我就粗略的学习了。

检测点1.1

1. 1个 CPU 的寻址能力为 8KB，那么它的地址总线的宽度为 13。 (8KB = 8 * 1024 = 2 ^ 13。 1字节为一个存储单元)
2. 1KB 的存储器有 1024个存储单元。存储单元的编号从 0 到 1023。
3. 1KB 的存储器可以存储 2^13个bit，个 1024Byte。
4. 1GB, 1MB, 1KB 分别是 2^30, 2^20, 2^10Byte。
5. 8080，8088，80286，80386 的地址总线宽度分别为 16 根， 20 根， 24 根， 32 根，则它们的寻址能力分别为: 2^6 (KB) , 1(MB), 16(MB), 4(GB)。
6. 8080， 8088， 8086， 80286， 80386 的数据总线宽度分别为 8 根， 8 根， 16 根， 16 根， 32 根。则它们一次可以传送的数据为: 1 (B), 1(B), 2(B), 2(B), 4(B)。
7. 从内存中读取 1024 字节的数据， 8086 至少要读 512 次， 80386至少要读 256 次。
8. 在存储器中， 数据和程序以 二进制形式存放。

检测点2.1

1. 写出每条汇编指令执行后相关寄存器中的值。

   1 2 3 4 5 6 7 8 9 10 11 12 13 14

   mov ax,62627 ; AX = `F4A3H` mov ah,31H ; AX = `31A3H` mov al,23H ; AX = `3123H` add ax,ax ; AX = `6246H` mov bx,826CH ; BX = `826CH` mov cx,ax ; CX = `6246H` mov ax,bx ; AX = `826CH` add ax,bx ; AX = `04D8H` mov al,bh ; AX = `0482H` mov ah,bl ; AX = `6C82H` add ah,ah ; AX = `D882H` add al,6 ; AX = `D888H` add al,al ; Ax = `D810H` mov ax,cx ; AX = `6246H`

2. 用目前学过的汇编指令，最多使用 4 条指令，编程计算 2 的 4 次方。

   1 2 3 4

   mov ax,2 add ax,ax add ax,ax add ax,ax

检测点2.2

1. 给定段地址为 0001H, 仅通过变化偏移地址寻址，CPU 的寻址范围为 00010H到 1000FH。
2. 有一数据存放在内存 20000H 单元中，现给定段地址为 SA，若想用偏移地址寻到此单元。则 SA应满足的条件是: 最小为 1001H，最大为 20000H。

检测点2.3

下面的三条指令执行后，CPU几次修改IP？都是在什么时候？最后IP中的值是多少？

1
2
3

mov ax,bx
sub ax,ax
jmp ax

检测点3.1

1. 在Debug中， 用“d 0:0 1f” 查看内存，结果如下:

   1 2	0000:0000 70 80 F0 30 EF 60 30 E2-00 80 80 12 66 20 22 60 0000:0010 62 26 E6 D6 CC 2E 3C 3B-AB BA 00 00 26 06 66 88

   下面的程序执行前，AX=0,BX=0,写出每条汇编指令执行完后相关寄存器中的值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

mov ax,1
mov ds,ax         ; 将段地址ds设置为0001
mov ax,[0000]     ; AX=`2662H`
mov bx,[0001]     ; BX=`E626H`
mov ax,bx         ; AX=`E626H`
mov ax,[0000]     ; AX=`2662H`
mov bx,[0002]     ; BX=`D6E6H`
add ax,bx         ; AX=`FD48H`
add ax,[0004]     ; AX=`2C14H`
mov ax,0          ; AX=`0000H`
mov al,[0002]     ; AX=`00E6H`
mov bx,0          ; BX=`0000H`
mov bl,[000C]     ; BX=`0026H`
add al,bl         ; AX=`000CH`

2. 内存中的情况如图3.6所示。
   各寄存器的初始值: CS=2000H， IP=0, DS=1000H, AX=0, BX=0;
   

• 写出CPU执行的指令序列 (用汇编指令写出)
• 写出CPU执行每条指令后，CS，IP和相关寄存器中的数值。

  1 2 3 4 5 6

  mov ax,6622H ; CS=2000H, IP=0003H, DS=1000H, AX=6622H, BX=0000H jmp 0ff0:0100 ; CS=0FF0H, IP=0100H, DS=1000H, Ax=6622H, BX=0000H mov ax,2000H ; CS=0FF0H, IP=0103H, DS=1000H, AX=2000H, BX=0000H mov ds,ax ; CS=0FF0H, IP=0105H, DS=2000H, Ax=2000H, BX=0000H mov ax,[0008] ; CS=0FF0H, IP=0108H, DS=2000H, AX=C389H, BX=0000H mov ax,[0002] ; CS=0FF0H, IP=010BH, Ds=2000H, Ax=EA66H, BX=0000H

• 再次体会: 数据和程序有区别吗？如何确定内存中的信息哪些是数据，哪些是程序?

没有区别。存储在数据段中就是数据，存储在程序段中就是程序。

检测点3.2

1. 补全下面的程序，使其可以将 10000H~1000FH 中的八个字，逆序复制到 20000H~2000FH 中。逆序复制的含义如图3.17所示 (图中内存里的数据均为假设) 。 (图我就不贴了。不重要)

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

   mov ax,1000H mov ds,ax mov ax,2000H mov ss,ax mov sp,0 push [0] push [2] push [4] push [6] push [8] push [A] push [C] push [E]

2. 补全下面的程序，使其可以将 10000H~1000FH 中的 8 个字，逆序复制到20000H~2000FH中。

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

   mov ax,2000H mov ds,ax mov ax,1000H mov ss,ax mov sp,0 pop [E] pop [C] pop [A] pop [8] pop [6] pop [4] pop [2] pop [0]

   检测点6.1

3. 下面的程序实现依次用内存 0:0~0:15 单元中的内容改写程序中数据，完成程序:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

assume cs:codesg

codesg segment
    dw 0123h, 0456h, 0789h, 0abch, 0defh, 0fedh, 0cbah, 0987h

start:  mov ax,0
        mov ds,ax
        mov bx,0

        mov cx,8
    s:  mov ax,[bx]

        mov cs:[bx],ax

        add bx,2
        loop s

        mov ax,4c00h
        int 21h
codesg ends
end start

2. 下面的程序实现依次用内存 0:0~0:15 单元中的内容改写程序中数据，数据的传送用栈来进行。栈空间设置在程序内。完成程序:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

assume cs:codesg

codesg segment
    dw 0123h, 0456h, 0789h, 0abch, 0defh, 0fedh, 0cbah, 0987h
    dw 0,0,0,0,0,0,0,0,0,0              ;10个字单元用作栈空间

start:  mov ax,cs
        mov ss,ax
        mov sp,36   ; (网上的答案不是36，虽然跑起来没问题，但36才是最好的)

        mov ax,0
        mov ds,ax
        mov bx,0
        mov cx,8
    s:  push [bx]

        pop cs:[bx]

        add bx,2
        loop s

        mov ax,4c00h
        int 21h
codesg ends
end start

ps:我调试的时候发现一件很骚的事情，就是调试的时候，栈空间的值会发生改变。主要是因为中断机制，中断的时候某些关键值要存在内存里。。就用了程序的栈空间。我还纳闷了半天。。

实验5

这个实验做完主要有两点总结:

• 第二题的第4小道: 16 * (N / 16 + 1)。关于内存的问题。在16位机器上，不足16字节的数据按16字节存储，意思就是17个字节，在程序中其实占的是32字节。其它机器应该可以递推。

• 编译器编译汇编文件，从上往下编译。同理，数据段要是写在代码段后面，执行加载到内存中时，在内存中的位置也在代码段的后面。

检测点9.1

1. 程序如下:

   1 2 3 4 5 6 7 8 9 10 11 12 13

   assume cs:code data segment db 8 dup(0) data ends code segment start: mov ax,data mov ds,ax mov bx,0 jmp word ptr [bx + 1] code ends end start

若要使程序中的 jmp 指令执行后， CS:IP 指向程序的第一条指令，在 data 段中应该定义哪些数据？

2. 程序如下:

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

   assume cs:code data segment dd 12345678H data ends code segment start: mov ax,data mov ds,ax mov bx,0 mov [bx],offset start mov [bx+2],cs jmp dword ptr ds:[0] code ends end start

   补全程序，使 jmp 指令执行后，CS: IP 指向程序的第一条指令。

3. 用 Debug 查看内存，结果如下:

   1	2000:1000 BE 00 06 00 00 00 ...

   则此时，CPU 执行指令:

   1 2 3

   mov ax,2000H mov es,ax jmp dword ptr es:[1000H]

   后， (CS) = 0060h， (IP) = 00BE

检测点9.2

补全程序，利用 jcxz 指令，实现在内存 2000H 段中查找第一个值为 0 的字节，找到后，将它的偏移地址存储在 dx 中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

assume cs:code
code segment
    start:  mov ax,2000H
            mov ds,ax
            mov bx,0

        s:  mov cl,[bx]
            mov ch,0    ; 注意寻找的是字节
            jcxz short ok
            inc bx

            jmp short s
        ok: mov dx,bx
            mov ax,4c00h
            int 21h
code ends
end start

检测点9.3

补全编程，利用 loop 指令，实现在内存 2000H 段中查找第一个值为 0 的字节， 找到后，将它的偏移地址存储在 dx 中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

assume cs:code
code segment
    start:  mov ax,2000H
            mov ds,ax
            mov bx,0
        s:  mov cl,[bx]
            mov ch,0

            inc cx  ; loop指令，将 cx 加一在判定是否为0

            inc bx
            loop s
        ok: dec bx
            mov dx,bx
            mov ax,4c00h
            int 21h
code ends
end start

检测点10.1

补全程序，实现从内存 1000:0000 处开始执行指令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

assume cs:code

stack segment
    db 16 dup(0)
stack ends

code segment
start:  mov ax,stack
        mov ss,ax
        mov sp,16
        mov ax,1000
        push ax
        mov ax,0000
        push ax
        retf
code ends

end start

检测点10.2

下面的程序执行后，ax 中的数值为多少？
内存地址 | 机器码 | 汇编指令
—|—|—
1000:0 | b8 00 00 | mov ax,0
1000:3 | e8 01 00 | call s
1000:6 | 40 | inc ax
1000:8 | 58 | s:pop ax

0006h

检测点10.3

下面的程序执行后，ax 中的数值为多少？

1
2
3
4
5
6
7
8
9

内存地址 | 机器码   | 汇编指令
---|---|---
1000:0 | b8 00 00       |   mov ax,0
1000:3 | 9A 09 00 00 10 |   call far ptr s
1000:8 | 40             |   inc ax
1000:9 | 58             | s:pop ax
                            add ax,ax
                            pop bx
                            add ax,bx

1010h

检测点10.4

下面的程序执行后，ax 中的数值为多少？

1
2
3
4
5
6
7

内存地址 | 机器码   | 汇编指令
---|---|---
1000:0 | b8 06 00       |   mov ax,6
1000:3 | ff d0          |   call ax
1000:5 | 40             |   inc ax
1000:6 |                |   mov bp,sp
                            add ax,[bp]

000Bh

检测点10.5

1. 下面的程序执行后，ax 中的数值为多少？ (注意: 用 call 指令的原理来分析，不要在 Debug 中单步跟踪来验证你的结论。对于此程序，在Debug中单步跟踪的结果，不能代表 CPU 的实际执行结果。)

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

   assume cs:code stack segment dw 8 dup(0) stack segment code segment start: mov ax,stack mov ss,ax mov sp,16 mov ds,ax mov ax,0 call word ptr ds:[0EH] inc ax inc ax inc ax mov ax,4c00h int 21h code ends end start

0003h

2. 下面的程序执行后，ax 和 bx 中的数值为多少？

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

   assume cs:code data segment dw 8 dup(0) data ends code segment start: mov ax,data mov ss,ax mov sp,16 mov word ptr ss:[0],offset s mov ss:[2],cs call dword ptr ss:[0] nop s: mov ax,offset s sub ax,ss:[0cH] mov bx,cs sub bx,ss:[0eH] mov ax,4c00h int 21h code ends end start

ax = 0001h, bx = 0000h

检测点11.1

写出下面每条指令执行后，ZF，PF，SF等标志位的值。

1
2
3
4
5
6
7

sub al,al           ; ZF= 1 ,PF= 1  ,SF= 0
mov al,1            ; ZF= 1 ,PF= 1  ,SF= 0
push ax             ; ZF= 1 ,PF= 1  ,SF= 0
pop bx              ; ZF= 1 ,PF= 1  ,SF= 0
add al,bl           ; ZF= 0 ,PF= 0  ,SF= 0
add al,10           ; ZF= 0 ,PF= 1  ,SF= 0
mul al              ; ZF= 0 ,PF= 1  ,SF= 0

检测点11.2

写出下面每条指令执行后，ZF，PF，SF，CF，OF等标志位的值。

检测点11.3

1. 补全下面的程序，统计 F:000:0 处 32 个字节中，大小在[32,128]的数据的个数。

   1 2 3 4 5 6 7 8 9 10 11 12 13 14

   mov ax,0f000h mov ds,ax mov bx,0 mov dx,0 mov cx,32 s: mov al,[bx] cmp al,32 jb s0 cmp al,128 ja s0 inc dx s0: inc bx loop s

2. 补全下面程序中，统计 F:000:0 处 32 个字节中，大小在 (32,128) 的数据的个数。

   1 2 3 4 5 6 7 8 9 10 11 12 13

   mov ax,0f000h mov ds,ax mov bx,0 mov dx,0 mov cx,32 s: mov al,[bx] cmp al,32 jna s0 cmp al,128 jnb s0 inc dx s0: inc bx loop s

检测点11.4

下面的程序执行后: (ax) =？

1
2
3
4
5
6
7
8
9

mov ax,0
push ax
popf
mov ax,0fff0h
add ax,0010h
pushf
pop ax
and al,11000101B
and ah,00001000B

0045h

检测点12.1

1. 用 Debug 查看内存，情况如下:

   1	0000:0000 68 10 A7 00 8B 01 70 00-16 00 9D 03 8B 01 70 00

   则 3 号中断源对应的中断处理程序的入口地址为: 0070h:018Bh

2. 存储 N 号中断源对应的中断处理程序入口的偏移地址的内存单元的地址为: [4N]。
   存储 N 号中断源对应的中断处理程序入口的段地址的内存单元的地址为: [4N+2]。

检测点13.1

1. 在上面的内容中，我们用 7ch 中断例程实现 loop 的功能，则上面的 7ch 中断例程所能进行的最大转移位移是多少？
   -128~127

2. 用 7ch 中断例程完成 jmp near ptr s 指令的功能，用 bx 向中断例程传送转移位移。
   应用举例: 在屏幕的第 12 行，显示 data 段中以 0 结尾的字符串。

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

   assume cs:code,ds:data data segment db 'conversation',0 data ends code segment start: mov ax,cs mov ds,ax mov si,offset show mov ax,0 mov es,ax mov di,200h mov cx,offset showend-offset show cld rep movsb mov ax,0 mov es,ax mov word ptr es:[7ch*4],200h mov word ptr es:[7ch*4+2],0 mov ax,data mov ds,ax mov si,0 mov ax,0b800h mov es,ax mov di,12*160 s: cmp byte ptr [si],0 je ok mov al,[si] mov es:[di],al mov al,2 mov es:[di+1],al inc si add di,2 mov bx,offset s-offset ok int 7ch ok: mov ax,4c00h int 21h show: push bp mov bp,sp add [bp+2],bx pop bp iret showend:nop code ends end start

检测点13.2

1. 错误，BIOS在ROM中 (READ ONLY) ，不能被更改
2. 错误，19h中断，操作系统还未被引导。

检测点14.1

1. 编程，读取 CMOS RAM 的 2 号单元的内容

   1 2 3

   mov al,2 out 70h,al in al,71h

2. 编程，向 CMOS RAM 的 2 号单元写入 0。

   1 2 3 4

   mov al,0 out 71h,al mov al,2 in 70h,al

检测点14.2

编程，用加法和移位指令计算 (ax) = (ax) 10。 (提示， (ax) 10= (ax)2+(ax)8)

1
2
3
4
5
6

mov ax,2
shl ax,1
mov bx,ax
shl ax,1
shl ax,1
add ax,bx

检测点15.1

1. 精简

   1 2	pushf call dword ptr ds:[0]

   2.
   在中断向量表中设置新的int9中断入口地址的时候不让其发生中断。

   1 2 3 4

   cli mov word ptr es:[9*4],offset int9 mov word ptr es:[9*4+2],cs sti

恢复中断向量表int9的源地址时同理:

1
2
3
4
5
6

cli
push ds:[0]
pop es:[9*4]
push ds:[2]
pop es:[9*4+2]
sti

检测点16.1

下面的程序将 code 段中 a 处的 8 个数据累加，结果存储到 b 处的双字中，补全程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

assume cs:code
code segment
    a dw 1,2,3,4,5,6,7,8
    b dd 0

    start:  mov si,0
            mov cx,8
        s:  mov ax,a[si]
            add b,ax
            abc b,0
            add si,1
            loop s

            mov ax,4c00h
            int 21h
code ends
end start

检测点16.2

下面的程序将 data 段中 a 处的 8 个数据累加，结果存储到 b 处的双字中，补全程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

assume cs:code,es:data

data segment
    a db 1,2,3,4,5,6,7,8
    b dw 0
data ends

code segment
start:  mov ax,data
        mov es,ax
        mov si,0
        mov cx,8
    s:  mov al,a[si]
        mov ah,0
        add b,ax
        inc si
        loop s

        mov ax,4c00h
        int 21h
code ends
end start

检测点17.1

当执行int16中断时是从缓冲区中读出字符，若缓冲区为空，则int16应该可以响应int9的中断，故IF不一定为1

• sudo apt update
• sudo apt install firefox

chrome

• 添加软件源 sudo wget http://www.linuxidc.com/files/repo/google-chrome.list -P /etc/apt/sources.list.d/
• 导入谷歌软件公钥 wget -q -O - https://dl.google.com/linux/linux_signing_key.pub | sudo apt-key add -
• sudo apt update
• sudo apt-get install google-chrome-stable
• /usr/bin/google-chrome-stable

vim

• sudo apt install vim
• sudo vim /etc/vim/vimrc
• 取消syntax on的注释
• 最后一行配置:

1
2
3
4
5
6

set nu          //在左侧显示行号码
set tabstop=4   //tab 长度设为4
set nobackup    //覆盖文件不备份
set cursorline  //突出显示当前行
set ruler       //在右下角显示光标位置打状态行
set autoindent  //自动缩进

git

• sudo apt install git
• git config --global user.name "your name"
• git config --globa user.email "your email.com"
• ssh-keygen -t rsa -b 4096 -C "your_email@example.com"
• 复制公钥到github上

vscode

用 ubuntu-make 安装

• sudo add-apt-repository ppa:ubuntu-desktop/ubuntu-make
• sudo apt update
• sudo apt install ubuntu-make
• sudo umake ide visual-studio-code

apt 安装

• sudo apt update
• sudo apt install software-properties-common apt-transport-https wget
• wget -q https://packages.microsoft.com/keys/microsoft.asc -O- | sudo apt-key add -
• sudo add-apt-repository "deb [arch=amd64] https://packages.microsoft.com/repos/vscode stable main"
• sudo apt install code

20181123 update: sudo umake web visual-studio-code，在新版本中 vscode 移动到 ide 分类中

PS: ubuntu 下的推荐字体 `font-family=”‘Ubuntu Mono’, monospace”

anaconda

• 官网下载
• sudo bash Anaconda3-5.0.1-Linux-x86_64.sh 然后选yes
• 添加环境路径
• sudo chmod 777 -R anaconda3/ 给权限
• jupyter的皮肤配置: jupyterthemes配置 jt -t gruvboxd -f ubuntu -fs 12 -tfs 12 -ofs 11, 我发现ubuntu的字体已经比window好太多，所以就没配置。

java

一件很奇怪的事情，就是不知道为什么我用apt的ppa源下载，一直连不上oracle官网。。一直404失败。所以就徒手配置了。

• apt -u dist-upgrade强制升级一下版本
• sudo apt remove --purge openjdk*删除openjdk
• sudo mkdir /usr/local/java 创建安装目录 cd /usr/local/java 进入安装目录
• 因为服务器连不上oracle官网。。所以我用了rz把本地的jdk传上去了。。
• tar -zxvf jdk-8u161-linux-x64.tar.gz 解压
• vim ~/.bashrc 环境变量配置

  1 2 3 4

  export JAVA_HOME=/usr/local/java/jdk1.8.0_161 export JRE_HOME={JAVA_HOME}/jre export CLASSPATH=.:{JAVA_HOME}/lib:${JRE_HOME}/lib export PATH=$JAVA_HOME/bin:$PATH

• source ~/.bashrc 重新加载环境变量生效

node

• sudo apt install nodejs-legacy nodejs 直接下载
• sudo apt install npm 安装npm
• sudo npm install -g n 下载node版本控制库
• sudo n stable 升级到最新的LTS

codeblocks

• sudo add-apt-repository ppa:damien-moore/codeblocks-stable 添加ppa源
• sudo apt update 更新
• sudo apt install codeblocks 下载安装

coursera

• ping coursera.org 得到ip
• 浏览器里看network，未正常响应的都添加到hosts里。
• vim /etc/hosts 修改
• sudo /etc/init.d/networking restart重启网络服务

shutter

• apt install shutter

system theme

• sudo apt install unity-tweak-tool 下载 unity-tweak-tool
• sudo add-apt-repository ppa:noobslab/themes 添加源
• sudo apt update 更新
• sudo apt install flatabulous-theme 下载 flatabulous-themes
• sudo apt install ultra-flat-icons 下载 ultra-flat的图标

Ubuntu18.04 用了 gnome，更改主题 Ubuntu18.04美化主题

• Gnome-LOOK

zsh

• sudo apt install zsh 下载
• chsh -s $(which zsh) 设置
• 重启计算机生效
• sh -c "$(curl -fsSL https://raw.github.com/robbyrussell/oh-my-zsh/master/tools/install.sh)"
• git clone git://github.com/zsh-users/zsh-autosuggestions $ZSH_CUSTOM/plugins/zsh-autosuggestions
• 改动 ~/.zshrc 的 plugins=(git) 为 plugins=(git zsh-autosuggestions)

shadowsocks

• sudo apt install python-pip 下载 pip
• sudo pip install shadowsocks 下载 shadowsocks
• sudo vim /etc/shadowsocks.json 修改配置文件

  1 2 3 4 5 6 7 8 9 10 11

  { "server":"ip地址", "server_port":服务器端口, "local_address": "127.0.0.1", "local_port":1080, "password":"密码", "timeout":300, "method":"使用的方法", "fast_open": false, "workers": 1 }

• sudo sslocal -c /etc/shadowsocks.json 开中断启动 ss
• 更改系统设置 -> 网络 -> 网络代理 -> Socks主机: 127.0.0.1 -> port: 1080
• 给 chrome 下一个插件 SwitchyOmega(SwitchyOmega 配置)，选择 autoProxy，规则列表网址:

  1	https://raw.githubusercontent.com/gfwlist/gfwlist/master/gfwlist.txt

• 别的浏览器 firefox 的代理都关了，不然不开 ss 上不了网，需要 FQ 的时候再用终端开个 ss 。

开机启动

• sudo vim /etc/systemd/system/shadowsocks.service
• 把 /home/xx/Software/ShadowsocksConfig/shadowsocks.json 修改为自己的 shadowsocks.json 路径

  1 2 3 4 5 6 7 8 9 10 11

  [Unit] Description=Shadowsocks Client Service After=network.target [Service] Type=simple User=root ExecStart=/usr/bin/sslocal -c /home/xx/Software/ShadowsocksConfig/shadowsocks.json [Install] WantedBy=multi-user.target

• systemctl enable /etc/systemd/system/shadowsocks.service 重启生效