CAP定理

保证脚本的独立运行

是如何实现的从内存到硬盘的写入，以及查询过程中硬盘文件是如何应用的

是的是的SD

主更流程

主动更新介绍

本地编译命令

远程编译命令

无参数

ssh user@server 'bash -s' < local.script.sh

有参数

ssh user@server ARG1="arg1" ARG2="arg2" 'bash -s' < local_script.sh

#!/bin/bash  
IP_LIST="192.168.18.1 192.168.1.1 192.168.18.2"
for IP in $IP_LIST; do
    NUM=1
    while [ $NUM -le 3 ]; do
        if ping -c 1 $IP > /dev/null; then
            echo "$IP Ping is successful."
            break
        else
            # echo "$IP Ping is failure $NUM"
            FAIL_COUNT[$NUM]=$IP
            let NUM++
        fi
    done
    if [ ${#FAIL_COUNT[*]} -eq 3 ];then
        echo "${FAIL_COUNT[1]} Ping is failure!"
        unset FAIL_COUNT[*]
    fi
done

方法1：
# echo $RANDOM |md5sum |cut -c 1-8
471b94f2
方法2：
# openssl rand -base64 4
vg3BEg==
方法3：
# cat /proc/sys/kernel/random/uuid |cut -c 1-8
ed9e032c

方法1：

# echo $RANDOM |cksum |cut -c 1-8
23648321
方法2：
# openssl rand -base64 4 |cksum |cut -c 1-8
38571131
方法3：
# date +%N |cut -c 1-8
69024815

1）开头加解释器：#!/bin/bash

2）语法缩进，使用四个空格；多加注释说明。

3）命名建议规则：变量名大写、局部变量小写，函数名小写，名字体现出实际作用。

4）默认变量是全局的，在函数中变量local指定为局部变量，避免污染其他作用域。

5）有两个命令能帮助我调试脚本：set -e 遇到执行非0时退出脚本，set-x 打印执行过程。

6）写脚本一定先测试再到生产上。

该命令可以将当前Vim打开的窗口以文件的方式进行保存，当下次打开时直接以保存时的状态打开

保存当前会话session： :mks filename

更新当前会话session： :mks! filename

载入会话session： vim -S sessionFile

单位: 1/1000000 元

原子性 持久性 隔离性 一致性

新增数据端口在本机时，需要先执行安装才能进行

这里指定sock，则可以直接免密登录账号

这里是关键union是实现弱类型的点睛之笔

这里需要注意下

至于在fork子进程退出的时候 i=1 =2 =3的时候都只有一个父进程fork一个子进程 所以只有三个儿子

可以将视频类型、视频编码进行重新转码操作

返回结果为元组时，不需要关注的值，可以使用『_』来不获取该值

如何将开发的分支代码，merge到主干上？

• 创建新分支开发

$ git checkout -b dev

• 在新分支下新增测试文件

$ echo 'Readme' > ./readme.txt

$ git add readme.text

• 将文件提交到分支

$ git commit -m "dev branch test"

• 分支开发工作完成，我们现在可以切回 master 分支

$ git checkout master

• 将 dev 分支的工作成果合并到 master 分支上

$ git merge dev

• 合并完成之后，dev 分支没有作用就可以放心删除了

$ git branch -d dev

• 删除后，查看剩余分支列表，就只剩下 master 分支了

$ git branch

创建新的开发分支进行开发，与下面一组命令相同

$ git branch dev $ git checkout dev

$$git checkout$$

命令加上 \(-b\) 参数表示创建并切换

该命令与 \(git checkout -b dev\) 相同

事例举得不错

这里的介绍我觉得更直白的表现出与http协议的区别，当然从网络七层传输协议上来将也是一种解释，但我更喜欢此处的介绍

允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。

简单的实现：

1. 定义一个抽象类，然后再定义N个具体操作类，集成抽象类中的公共方法
2. 定义一个装饰类，该类同样继承上面的抽象类，然后参照工厂模式的方法，在里面实现可以实例化对应具体类
3. 在装饰类的继承方法中，将实现具体对象的方法进行重载，并在重载代码的上下，增加需要的内容即可

可以这么简单的理解，一个类中包含了实例化各种子类的方法（功能具体实现类），然后该类中提供了一个接口，可以采用传递几个参数，就是实现对应对象的实例化

个人感觉从下面的笔记中更好理解这个模式，主要实现方式理解为：

1. 创建一个抽象类
2. 定义几个实现类，用于继承抽象类，并实现里面的具体方法
3. 定义测试类，用于创建接受者对象的实例化（多个对象保存），然后，调用方法进行变量实例化对下，并调用他们的实现方法来进行发送通知

阻塞

接收数据

内核对cpu上运行进程的挂起和恢复操作，称为进程切换

后序遍历

中序遍历

先序遍历

完全二叉树

满二叉树

翻译 volatile 易变的

翻译：传输

HTTP Pipelining是这样一种技术：在等待上一个请求响应的同时，发送下一个请求。(译者注：作者这个解释并不完全正确，HTTP Pipelining其实是把多个HTTP请求放到一个TCP连接中一一发送，而在发送过程中不需要等待服务器对前一个请求的响应；只不过，客户端还是要按照发送请求的顺序来接收响应。)但就像在超市收银台或者银行柜台排队时一样，你并不知道前面的顾客是干脆利索的还是会跟收银员/柜员磨蹭到世界末日（译者注：不管怎么说，服务器（即收银员/柜员）是要按照顺序处理请求的，如果前一个请求非常耗时（顾客磨蹭），那么后续请求都会受到影响），这就是所谓的线头阻塞（Head of line blocking）。 http://blog.csdn.net/qq_28885149/article/details/52922107

这个锁就永远得不到释放了

Redis分布式锁

尾递归的优点

递归的问题点

尾递归概念

尾调用优化的精髓

函数调用记录在内存中的实现

尾调用的概念

解释了什么是汉明距离，即两个相同长度的字对于位不同的数量

例： 0000000 1111111 这两个的汉明距离就是 1 + 1 + 1 + 1 + 1 + 1 + 1 = 7

这篇文章对堆和栈的解释比较明朗。

这里指名 栈 和 堆栈 是一个概念，而解决了在其他文章中说两个为不同概念的误导。

区别：

1. 队列先进先出，在对头做删除操作，在队尾做插入操作；
2. 栈先进后出，在栈顶做插入和删除操作；
3. 堆和他们不同，不存在是先进后出还是先进先出，他类似与KV存储，但是不用了需要做释放操作；

int MB = 0;  
while(malloc(1 << 20))  
{  
        MB++;  
}  
printf("Allocate %d MB total\n", MB);

具体实现：

#!/usr/bin/python

import glob
import os
import sys

from PIL import Image

EXTS = 'jpg', 'jpeg', 'JPG', 'JPEG', 'gif', 'GIF', 'png', 'PNG'

def avhash(im):
    if not isinstance(im, Image.Image):
        im = Image.open(im)
    im = im.resize((8, 8), Image.ANTIALIAS).convert('L')
    avg = reduce(lambda x, y: x + y, im.getdata()) / 64.
    return reduce(lambda x, (y, z): x | (z << y),
                  enumerate(map(lambda i: 0 if i < avg else 1, im.getdata())),
                  0)

def hamming(h1, h2):
    h, d = 0, h1 ^ h2
    while d:
        h += 1
        d &= d - 1
    return h

if __name__ == '__main__':
    if len(sys.argv) <= 1 or len(sys.argv) > 3:
        print "Usage: %s image.jpg [dir]" % sys.argv[0]
    else:
        im, wd = sys.argv[1], '.' if len(sys.argv) < 3 else sys.argv[2]
        h = avhash(im)

        os.chdir(wd)
        images = []
        for ext in EXTS:
            images.extend(glob.glob('*.%s' % ext))

        seq = []
        prog = int(len(images) > 50 and sys.stdout.isatty())
        for f in images:
            seq.append((f, hamming(avhash(f), h)))
            if prog:
                perc = 100. * prog / len(images)
                x = int(2 * perc / 5)
                print '\rCalculating... [' + '#' * x + ' ' * (40 - x) + ']',
                print '%.2f%%' % perc, '(%d/%d)' % (prog, len(images)),
                sys.stdout.flush()
                prog += 1

        if prog: print
        for f, ham in sorted(seq, key=lambda i: i[1]):
            print "%d\t%s" % (ham, f)

参考代码：

1. http://www.ruanyifeng.com/blog/2011/07/imgHash.txt

汉明距离： 在信息论中，两个等长字符串之间的汉明距离（英语：Hamming distance）是两个字符串对应位置的不同字符的个数。换句话说，它就是将一个字符串变换成另外一个字符串所需要替换的字符个数。

汉明重量：汉明重量是字符串相对于同样长度的零字符串的汉明距离，也就是说，它是字符串中非零的元素个数：对于二进制字符串来说，就是1的个数，所以11101的汉明重量是4。

参考资料：

1. 维基百科

这是针对列表中字典排序的更高升华

多级排序，先用score排序，再用name排序

常量FUNCNAME，但是有一点区别是，它是一个数组而非字符串，其中数组的第一个元素为当前函数的名称

获取当前行的行号

获取调用该函数所在行的行号

MAC在Finder栏显示所浏览文件夹路径的方法

shell 如何把多行内容输出到一个文件

crontab 执行命令，将对应运行日志按照日期进行存放

从开头第k行处开始输出

显示某次提交的元数据和内容变化

查看某个文件在某次提交的变动信息: git show [commit] [filename]

显示某次提交时，某个文件的内容

选择一个commit，合并进当前分支

合并指定分支到当前分支

新建一个分支，与指定的远程分支建立追踪关系

新建一个分支，与指定的远程分支建立追踪关系

新建一个分支，指向指定commit

新建一个分支，并切换到该分支

新建一个分支，但依然停留在当前分支

列出所有本地分支

显示commit历史，以及每次commit发生变更的文件

显示今天你写了多少行代码

显示指定文件是什么人在什么时间修改过

显示指定文件相关的每一次diff

显示效果如下，但会显示高亮：

commit 32e0c4f6bbb91617126b1cf2ab8c403ce7691ffe
Author: lishuailong <lishuailong@baidu.com>
Date:   Tue Jul 11 15:14:59 2017 +0800

    delete by loc

diff --git a/bin/server_control b/bin/server_control
index 6d81daa..4cf5106 100755
--- a/bin/server_control
+++ b/bin/server_control
@@ -48,7 +48,7 @@ function cleanup() {
 function realtime_cleanup() {
     mkdir -p ../realtime_delete/data
     DATE_TO_CLEANUP=`date +"%Y%m%d" -d "-7 days"`
-    cat ../data/*${DATE_TO_CLEANUP}*.succ | $PYTHON_BIN delete_succ.py 2> ../log/realtime_cleanup.log
+    cat ../data/*${DATE_TO_CLEANUP}*.succ | $PYTHON_BIN delete.py --format json 2> ../log/realtime_cleanup.log
     rm -f ../data/*${DATE_TO_CLEANUP}*
 }


commit 47a2565e033dc1ed60a0ffd4df5e760dbcaebad8
Author: lishuailong <lishuailong@baidu.com>
Date:   Thu Jul 6 16:18:47 2017 +0800

    fix realtime cleanup

diff --git a/bin/server_control b/bin/server_control
index 13b756f..6d81daa 100755
--- a/bin/server_control
+++ b/bin/server_control
@@ -48,7 +48,7 @@ function cleanup() {
 function realtime_cleanup() {
     mkdir -p ../realtime_delete/data
     DATE_TO_CLEANUP=`date +"%Y%m%d" -d "-7 days"`
-    cat ../data/*${DATE_TO_CLEANUP}.succ | $PYTHON_BIN delete_succ.py 2> ../log/realtime_cleanup.log
+    cat ../data/*${DATE_TO_CLEANUP}*.succ | $PYTHON_BIN delete_succ.py 2> ../log/realtime_cleanup.log
     rm -f ../data/*${DATE_TO_CLEANUP}*
 }