空城旧梦

分词技术-词的分类

Mon, 20 Feb 2017 00:00:00 +0800

词的分类

实词：名词、动词、形容词、状态词、区别词、数词、量词、代词
虚词：副词、介词、连词、助词、拟声词、叹词。

ICTPOS3.0词性标记集

n 名词
	nr 人名
		nr1 汉语姓氏
		nr2 汉语名字
		nrj 日语人名
		nrf 音译人名
	ns 地名
	　nsf 音译地名
	nt 机构团体名
	nz 其它专名
	nl 名词性惯用语
	ng 名词性语素

t 时间词
　　tg 时间词性语素

s 处所词

f 方位词

v 动词
	vd 副动词
	vn 名动词
	vshi 动词“是”
	vyou 动词“有”
	vf 趋向动词
	vx 形式动词
	vi 不及物动词（内动词）
	vl 动词性惯用语
	vg 动词性语素
a 形容词
	ad 副形词
	an 名形词
	ag 形容词性语素
	al 形容词性惯用语
b 区别词
	bl 区别词性惯用语
z 状态词
r 代词
	rr 人称代词
	rz 指示代词
		rzt 时间指示代词
		rzs 处所指示代词
		rzv 谓词性指示代词
	ry 疑问代词
		ryt 时间疑问代词
		rys 处所疑问代词
		ryv 谓词性疑问代词
	rg 代词性语素
m 数词
	mq 数量词
q 量词
	qv 动量词
	qt 时量词

虚词

d 副词
p 介词
	pba 介词“把”
	pbei 介词“被”
c 连词
	cc 并列连词
u 助词
	uzhe 着
	ule 了 喽
	uguo 过
	ude1 的 底
	ude2 地
	ude3 得
	usuo 所
	udeng 等 等等 云云
	uyy 一样 一般 似的 般
	udh 的话
	uls 来讲 来说 而言 说来

	uzhi 之
	ulian 连 （“连小学生都会”）

e 叹词
y 语气词(delete yg)
o 拟声词
h 前缀
k 后缀
x 字符串
	xx 非语素字
	xu 网址URL
w 标点符号
	wkz 左括号，全角：（ 〔  ［  ｛  《 【  〖 〈   半角：( [ { <
	wky 右括号，全角：） 〕  ］ ｝ 》  】 〗 〉 半角： ) ] { >
	wyz 左引号，全角：“ ‘ 『
	wyy 右引号，全角：” ’ 』
	wj 句号，全角：。
	ww 问号，全角：？ 半角：?
	wt 叹号，全角：！ 半角：!
	wd 逗号，全角：， 半角：,
	wf 分号，全角：； 半角： ;
	wn 顿号，全角：、
	wm 冒号，全角：： 半角： :
	ws 省略号，全角：……  …
	wp 破折号，全角：——   －－   ——－   半角：---  ----
	wb 百分号千分号，全角：％ ‰   半角：%
	wh 单位符号，全角：￥ ＄ ￡  °  ℃  半角：$

ICTCLAS 汉语词性标注集

代码 | 名称 | 帮助记忆的诠释 —- | —- | ————– Ag | 形语素 | 形容词性语素。形容词代码为a，语素代码ｇ前面置以A。 a | 形容词 | 取英语形容词adjective的第1个字母。 ad | 副形词 | 直接作状语的形容词。形容词代码a和副词代码d并在一起。 an | 名形词 | 具有名词功能的形容词。形容词代码a和名词代码n并在一起。 b | 区别词 | 取汉字“别”的声母。 c | 连词 | 取英语连词conjunction的第1个字母。 Dg | 副语素 | 副词性语素。副词代码为d，语素代码ｇ前面置以D。 d | 副词 | 取adverb的第2个字母，因其第1个字母已用于形容词。 e | 叹词 | 取英语叹词exclamation的第1个字母。 f | 方位词 | 取汉字“方” 的声母。 g | 语素 | 绝大多数语素都能作为合成词的“词根”，取汉字“根”的声母。 h | 前接成分 | 取英语head的第1个字母。 i | 成语 | 取英语成语idiom的第1个字母。 j | 简称略语 | 取汉字“简”的声母。 k | 后接成分 | l | 习用语 | 习用语尚未成为成语，有点“临时性”，取“临”的声母。 m | 数词 | 取英语numeral的第3个字母，n，u已有他用。 Ng | 名语素 | 名词性语素。名词代码为n，语素代码ｇ前面置以N。 n | 名词 | 取英语名词noun的第1个字母。 nr | 人名 | 名词代码n和“人(ren)”的声母并在一起。 ns | 地名 | 名词代码n和处所词代码s并在一起。 nt | 机构团体 | “团”的声母为t，名词代码n和t并在一起。 nz | 其他专名 | “专”的声母的第1个字母为z，名词代码n和z并在一起。 | o | 拟声词 | 取英语拟声词onomatopoeia的第1个字母。 p | 介词 | 取英语介词prepositional的第1个字母。 q | 量词 | 取英语quantity的第1个字母。 r | 代词 | 取英语代词pronoun的第2个字母,因p已用于介词。 s | 处所词 | 取英语space的第1个字母。 Tg | 时语素 | 时间词性语素。时间词代码为t,在语素的代码g前面置以T。 t | 时间词 | 取英语time的第1个字母。 u | 助词 | 取英语助词auxiliary 的第2个字母,因a已用于形容词。 Vg | 动语素 | 动词性语素。动词代码为v。在语素的代码g前面置以V。 v | 动词 | 取英语动词verb的第一个字母。 vd | 副动词 | 直接作状语的动词。动词和副词的代码并在一起。 vn | 名动词 | 指具有名词功能的动词。动词和名词的代码并在一起。 w | 标点符号 | x | 非语素字 | 非语素字只是一个符号，字母x通常用于代表未知数、符号。 y | 语气词 | 取汉字“语”的声母。 z | 状态词 | 取汉字“状”的声母的前一个字母。

jieba 字典中出现的类型

a
	ad
	ag
	an
b
c
d
	df
	dg
e
f
g
h
i
j
k
l
m
	mg
	mq
n
	ng
	nr
	nrfg
	nrt
	ns
	nt
	nz
o
p
q
r
	rg
	rr
	rz
s
t
	tg
u
	ud
	ug
	uj
	ul
	uv
	uz
v
	vd
	vg
	vi
	vn
	vq
x
y
z
	zg

simhash 过滤的掉的词汇

c
e
h
k
o
p
u
	ud
	ug
	uj
	ul
	uv
	uz
x
y

深度优先和广度优先

Mon, 23 Jan 2017 00:00:00 +0800

深度优先和广度优先

从一个简单的迷宫问题入手，深入理解DFS和BFS

##问题：

迷宫, 1为墙壁， 0为可以走的路，只能横着走和竖着走，求解左上角到右下角的路线。

int maze[5][5] = {
    0, 1, 0, 0, 0,
    0, 1, 0, 1, 0,
    0, 0, 0, 0, 0,
    0, 0, 0, 1, 0,
};

思路：

解法一：

深度优先搜索(DFS, Depth First Search):每次搜索完各个方向相邻的点之后，取其中一个相邻的点走下去，一直走到无路可走了再退回来(回溯)，取另一个相邻的点再走下去。

将起点标记为已走过并压栈；

while (栈非空) {
    从栈顶弹出一个点P；
    if (p这个点是终点) {
        break;
    }
    沿右、下、左、上四个方向探索相邻的点;
    if (和p相邻的点有路可走，并且还没走过) {
        将相邻的点标记为已走过并压栈，它的前趋就是p点;
    }
}
if (p点是终点) {
    打印p点的坐标；
    while (p点有前趋) {
        p点 = p点的前趋;
        打印p点的坐标;
    }
} else {
    没有路线可以到达终点;
}

附源码如下：

#include <stdio.h>
#define MAX_ROW 5
#define MAX_COL 5

struct point {
    int row, col;
} stack[512];

int top = 0;

void push(struct point p)
{
    stack[top++] = p;
}

struct point pop(void)
{
    return stack[--top];
}

int is_empty(void)
{
    return top == 0;
}

int maze[MAX_ROW][MAX_COL] = {
    0, 1, 0, 0, 0,
    0, 1, 0, 1, 0,
    0, 0, 0, 0, 0,
    0, 1, 1, 1, 0,
    0, 0, 0, 1, 0,
};

void print_maze(void)
{
    int i, j;
    for (i = 0; i < MAX_ROW; i++) {
        for (j = 0; j < MAX_COL; j++) {
            printf("%d ", maze[i][j]);
        }
        putchar('\n');
    }
    printf("************\n");
}

struct point predecessor[MAX_ROW][MAX_COL] = {
    { {-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}},
    { {-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}},
    { {-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}},
    { {-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}},
    { {-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}},
};

void visit(int row, int col, struct point pre)
{
    struct point visit_point = {
        row, col
    };
    maze[row][col] = 2;
    predecessor[row][col] = pre;
    push(visit_point);
}

int main(void)
{
    struct point p = {
        0, 0
    };
    maze[p.row][p.col] = 2;
    push(p);

    while (!is_empty()) {
        p = pop();
        if (p.row == MAX_ROW - 1 && p.col == MAX_COL - 1) {
            break;
        }
        if (p.col + 1 < MAX_COL && maze[p.row][p.col + 1] == 0) {
            visit(p.row, p.col + 1, p);
        }
        if (p.row + 1 < MAX_ROW && maze[p.row + 1][p.col] == 0) {
            visit(p.row + 1, p.col, p);
        }
        if (p.col - 1 >= 0 && maze[p.row][p.col - 1] == 0) {
            visit(p.row, p.col - 1, p);
        }
        if (p.row - 1 >= 0 && maze[p.row - 1][p.col] == 0) {
            visit(p.row - 1, p.col, p);
        }
        print_maze();
    }
    if (p.col == MAX_COL - 1 && p.row == MAX_ROW - 1) {
        printf("(%d, %d)\n", p.row, p.col);
        while (predecessor[p.row][p.col].row != -1) {
            p = predecessor[p.row][p.col];
            printf("(%d, %d)\n", p.row, p.col);
        }
    } else {
        printf("No path!\n");
    }
    return 0;
}

DFS 优化：

代码没有什么难懂的地方，不过有很多可以优化的地方，例如在predecessor这个数据结构上，浪费了太多的存储空间，可以做以下优化：

重新定义predecessor存储方式

struct point predecessor[MAX_ROW][MAX_COL] = { 0 }; 所有的值定义为0,前趋点为上点，则将他赋值为1，前趋点为下点，则赋值为-1，前趋点为左点，则赋值为2,前趋点为右点，则赋值为-2；通过定义四个不同的值区分前趋点，减少了存储空间，相应的函数也要对应修改即可。

用递归取代predecessor数据结构

解法二：广度优先搜索(BFS, Breadth First Search): BFS沿各个方向上同时展开搜索，每个可以走通的方向轮流往前走一步。

将起点标记为已经走过的队列 while (队列非空) { 出队一个点p; if (p为终点) { break; } 否则沿右下左上四个方向探索相邻的点 if (和p相邻的点有路走，且没有走过) { 将相邻的点标记为已经走过并入队列，他的前趋就是刚出队的p点; } if (p点是终点) { 打印p点的坐标; while (p点有前趋) { p点 = p 点的前趋; 打印 p 点的坐标; } } else { 没有到达终点的路线; } } BFS相比较于DFS，BFS可以找到从起点到终点的最短路径。

附源码如下:

#include <stdio.h>
#define MAX_ROW 5
#define MAX_COL 5

struct point {
    int row, col, predecessor;
} queue[512];

int head = 0, tail = 0;

void enqueue(struct point p)
{
    queue[tail++] = p;
}

struct point dequeue(void)
{
    return queue[head++];
}

int is_empty(void)
{
    return head == tail;
}

int maze[MAX_ROW][MAX_COL] = {
    0, 1, 0, 0, 0,
    0, 1, 0, 1, 0,
    0, 0, 0, 0, 0,
    0, 1, 1, 1, 0,
    0, 0, 0, 1, 0,
};

void print_maze(void)
{
    int i, j;
    for (i = 0; i < MAX_ROW; i++) {
        for (j = 0; j < MAX_COL; j++) {
            printf("%d ", maze[i][j]);
        }
        putchar('\n');
    }
    printf("************\n");
}

void visit(int row, int col)
{
    struct point visit_point = {
        row, col, head - 1
    };
    maze[row][col] = 2;
    enqueue(visit_point);
}

int main(void)
{
    struct point p = {
        0, 0, -1
    };
    maze[p.row][p.col] = 2;
    enqueue(p);

    while (!is_empty()) {
        p = dequeue();
        if (p.row == MAX_ROW - 1 && p.col == MAX_COL - 1) {
            break;
        }
        if (p.row + 1 < MAX_ROW && maze[p.row + 1][p.col] == 0) {
            visit(p.row + 1, p.col);
        }
        if (p.col + 1 < MAX_COL && maze[p.row][p.col + 1] == 0) {
            visit(p.row, p.col + 1);
        }
        if (p.col - 1 >= 0 && maze[p.row][p.col - 1] == 0) {
            visit(p.row, p.col - 1);
        }
        if (p.row - 1 >= 0 && maze[p.row - 1][p.col] == 0) {
            visit(p.row - 1, p.col);
        }
        print_maze();
    }
    if (p.row == MAX_ROW - 1 && p.col == MAX_COL - 1) {
        printf("(%d, %d)\n", p.row, p.col);
        while (p.predecessor != -1) {
            p = queue[p.predecessor];
            printf("(%d, %d)\n", p.row, p.col);
        }
    } else {
        printf("No path!\n");
    }
}

原文出处

PHP url解析

Tue, 10 Jan 2017 00:00:00 +0800

PHP url解析

<?php
$url = 'http://www.baidu.com/index.php?m=content&c=index&a=lists&catid=6&area=0&author=0&h=0&region=0&s=1&page=1';
 
$arr = parse_url($url);
var_dump($arr);
$arr_query = convertUrlQuery($arr['query']);
var_dump($arr_query);
var_dump(getUrlQuery($arr_query));
 
/**
 * 将字符串参数变为数组
 * @param $query
 * @return array array (size=10)
                    'm' => string 'content' (length=7)
                    'c' => string 'index' (length=5)
                    'a' => string 'lists' (length=5)
                    'catid' => string '6' (length=1)
                    'area' => string '0' (length=1)
                    'author' => string '0' (length=1)
                    'h' => string '0' (length=1)
                    'region' => string '0' (length=1)
                    's' => string '1' (length=1)
                    'page' => string '1' (length=1)
 */
function convertUrlQuery($query)
{
    $queryParts = explode('&', $query);
    $params = array();
    foreach ($queryParts as $param) {
        $item = explode('=', $param);
        $params[$item[0]] = $item[1];
    }
    return $params;
}
 
/**
 * 将参数变为字符串
 * @param $array_query
 * @return string string 'm=content&c=index&a=lists&catid=6&area=0&author=0&h=0&region=0&s=1&page=1' (length=73)
 */
function getUrlQuery($array_query)
{
    $tmp = array();
    foreach($array_query as $k=>$param)
    {
        $tmp[] = $k.'='.$param;
    }
    $params = implode('&',$tmp);
    return $params;
}

js跨域请求

Thu, 05 Jan 2017 00:00:00 +0800

js跨域请求

前端对Cross-Origin Resource Sharing 问题（CORS，中文又称’跨域’）应该很熟悉了。

众所周知出于安全的考虑，浏览器有个同源策略，对于不同源的站点之间的相互请求会做限制（跨域限制是浏览器行为，不是服务器行为。）。不过下午想到了一个略无趣的问题：浏览器和服务器到底是如何判定有没有跨域呢？本文主要分两个部分，一是对这个问题的总结，二是nginx下如何配置服务器允许跨域。

同源策略

同源指的是域名（或IP），协议，端口都相同，不同源的客户端脚本(javascript、ActionScript)在没明确授权的情况下，不能读写对方的资源。

同源的判定

以 http://www.example.com/dir/page.html 为例，以下表格指出了不同形式的链接是否与其同源：（原因里未申明不同的属性即说明其与例子里的原链接对应的属性相同）

链接	结果	原因
`http:// www.example.com /dir/page2.html`	是	同协议同域名同端口
`http:// www.example.com /dir2/other.html`	是	同协议同域名同端口
`http://user:pwd@ www.example.com/dir2/other.html`	是	同协议同域名同端口
`http://www.example.com: 81/dir/other.html`	否	端口不同
`https://www.example.com/dir/other.html`	否	协议不同端口不同
`http:// en.example.com/dir/other.html`	否	域名不同
`http:// example.com/dir/other.html`	否	域名不同（要求精确匹配）
`http:// v2.www.example.com/dir/other.html`	否	域名不同（要求精确匹配）
`http://www.example.com:80/dir/other.html`	不确定取决于浏览器的实现方式

是否允许跨域的判定

前文提到了同源策略的判定，然而同源策略在加强了安全的同时，对开发却是极大的不便利。因此开发者们又发明了很多办法来允许数据的跨域传输（常见的办法有JSONP、CORS)。当域名不同源的时候，由于跨域实现的存在，浏览器不能直接根据域名来判定跨域限制。那么浏览器具体又是如何实现判定的呢？看下面的例子。

待完成。。。

原文地址

正则表达式-匹配数字|中文-PHP版

Tue, 27 Dec 2016 00:00:00 +0800

preg_match_all("/[^\d](\d{1,})/ism", $paramStr, $match); //匹配所有包含数字
preg_replace("/([^\d])(\d{1,})/ism", "$1<int>", $paramStr); //替换所有数字
preg_match_all("/[\x{4e00}-\x{9fa5}]+/u", $res, $matchZH); //匹配所有中文字符
preg_replace("/[\x{4e00}-\x{9fa5}]+/u", "$1<zh>", $res); //替换所有中文字符

Linux服务器性能评估与优化(一)

Thu, 17 Nov 2016 00:00:00 +0800

原文地址这里

一、前言简介

影响Linux服务器性能的因素

操作系统级

性能调优是找出系统瓶颈并消除这些瓶颈的过程。很多系统管理员认为性能调优仅仅是调整一下内核的参数即可解决问题，事实上情况并不是这样。性能调优是实现操作系统的各个子系统之间的平衡性，这些子系统包括：

CPU
内存
磁盘I/O带宽
网络I/O带宽

子系统之间相互依存，任何一个子系统的负载过度都能导致其他子系统出现问题，例如：

大量的 page-in IO 请求可能导致内存队列被塞满
网卡的巨量吞吐可能导致 CPU 资源耗尽
系统尝试保持释放内存队列时可能耗尽 CPU 资源
来自内存的大量磁盘写入请求可能导致 CPU 资源和 IO 通道耗尽

性能调优的前提是找出系统瓶颈之所在，尽管问题看似由某个子系统所导致，然而这很可能是另外一个子系统的过载所引起的。

应用程序级

为了明白从何处开始着手调整性能瓶颈，弄清被分析系统的性能表现是首要任务。任何系统的应用常可分为以下两类：

1） IO 限制型——一个 IO 限制型的应用需要大量的内存和基础存储设备占用。因其需要大量的数据读写请求，此类应用对 CPU 和网络需求不高（除非存储系统在网络上）。IO 限制型应用使用 CPU 资源来进行 IO 操作且常进入睡眠状态。数据库应用常被认为属于此类。

2）CPU 限制型——一个 CPU 限制型应用需要大量的 CPU 资源，来进行批量的处理或大量的计算。大容量 web 服务，mail 服务，以及任何类型的渲染服务都被归到此类。

系统性能评估标准

判断一个系统是否有性能问题的唯一途径是弄清楚对系统的期望是神马，需求的性能是神马，应该得到的数据是神马？而为了建立这些信息的唯一途径是为系统建立一个基准。在性能可接受的状态下必须为系统建立统计信息，这样就可以在性能不可接受时进行对比。

%user：表示CPU处在用户模式下的时间百分比。
%sys：表示CPU处在系统模式下的时间百分比。
%iowait：表示CPU等待输入输出完成时间的百分比。
swap in：即si，表示虚拟内存的页导入，即从SWAP DISK交换到RAM
swap out：即so，表示虚拟内存的页导出，即从RAM交换到SWAP DISK。

系统性能分析工具

二、负载：整体性能评估

三、CPU性能评估

四、内存性能评估

五、磁盘i/o性能评估

六、网络性能评估

七、监控利器

php-fpm重启

Wed, 09 Nov 2016 00:00:00 +0800

重启 php-fpm

我们在新安装扩展后，是需要重新php-fpm的，已使扩展生效。

最简单粗暴的重新php-fpm的方式是：

先找到php-fpm的进程号，kill 掉，再用/usr/local/php/sbin/php-fpm 这样启动。

其实还有更多温和的方法，就是使用信号。

INT, TERM 立刻终止
QUIT 平滑终止
USR1 重新打开日志文件
USR2 平滑重载所有worker进程并重新载入配置和二进制模块

示例：

php-fpm 关闭：

kill -INT `cat /usr/local/php/var/run/php-fpm.pid`

php-fpm 重启：

kill -USR2 `cat /usr/local/php/var/run/php-fpm.pid`

Linux内存清理/释放命令

Wed, 09 Nov 2016 00:00:00 +0800

查看内存使用

free -m

优化内存

cache释放：

To free pagecache:

echo 1 > /proc/sys/vm/drop_caches

To free dentries and inodes:

echo 2 > /proc/sys/vm/drop_caches

To free pagecache, dentries and inodes:

echo 3 > /proc/sys/vm/drop_caches

说明，释放前最好sync一下，防止丢数据。

因为LINUX的内核机制，一般情况下不需要特意去释放已经使用的cache。这些cache起来的内容可以增加文件以及的读写速度。

vmstat：查看系统负载

iostat：查看IO负载

pstree：查看进程

pstree -p 3020（进程号）

Linux命令-解析json工具-jq

Thu, 20 Oct 2016 00:00:00 +0800

JSON是前端编程经常用到的格式，对于PHP或者Python，解析JSON都不是什么大事，尤其是PHP的json_encode和json_decode,干的相当的漂亮。Linux下也有处理处理JSON的神器：jq。

对于JSON格式而言，jq就像sed/awk/grep这些神器一样的方便，而也，jq没有乱七八糟的依赖，只需要一个binary文件jq，就足矣。下面我们看下jq的使用。

cat json_raw.txt | jq .
cat json_raw.txt | jq '.key'
cat json_raw.txt | jq '.key.keykey' /* 嵌套 */
cat json_raw.txt | jq '.key[1].keykey' /* 数组式 */
cat json_raw.txt | jq 'keys' /* 键名 */

jq还有一些内建函数如 key，has

key是用来获取JSON中的key元素
has是用来是判断是否存在某个key

如何解决秒杀的性能问题和超卖的讨论

Sat, 15 Oct 2016 00:00:00 +0800

最近业务试水电商，接了一个秒杀的活。之前经常看到淘宝的同行们讨论秒杀，讨论电商，这次终于轮到我们自己理论结合实际一次了。

ps：进入正文前先说一点个人感受，之前看淘宝的ppt感觉都懂了，等到自己出解决方案的时候发现还是有很多想不到的地方其实都没懂，再次验证了“细节是魔鬼”的理论。并且一个人的能力有限，只有大家一起讨论才能想的更周全，更细致。好了，闲话少说，下面进入正文。

一、秒杀带来了什么？

秒杀或抢购活动一般会经过【预约】【抢订单】【支付】这3个大环节，而其中【抢订单】这个环节是最考验业务提供方的抗压能力的。

抢订单环节一般会带来2个问题：

1、高并发

比较火热的秒杀在线人数都是10w起的，如此之高的在线人数对于网站架构从前到后都是一种考验。

2、超卖

任何商品都会有数量上限，如何避免成功下订单买到商品的人数不超过商品数量的上限，这是每个抢购活动都要面临的难题。

二、如何解决？

首先，产品解决方案我们就不予讨论了。我们只讨论技术解决方案

1、前端

面对高并发的抢购活动，前端常用的三板斧是【扩容】【静态化】【限流】

A：扩容

加机器，这是最简单的方法，通过增加前端池的整体承载量来抗峰值。

B：静态化

将活动页面上的所有可以静态的元素全部静态化，并尽量减少动态元素。通过CDN来抗峰值。

C：限流

一般都会采用IP级别的限流，即针对某一个IP，限制单位时间内发起请求数量。

或者活动入口的时候增加游戏或者问题环节进行消峰操作。

D：有损服务

最后一招，在接近前端池承载能力的水位上限的时候，随机拒绝部分请求来保护活动整体的可用性。

2、后端

那么后端的数据库在高并发和超卖下会遇到什么问题呢？主要会有如下3个问题：（主要讨论写的问题，读的问题通过增加cache可以很容易的解决）

　　I：首先MySQL自身对于高并发的处理性能就会出现问题，一般来说，MySQL的处理性能会随着并发thread上升而上升，但是到了一定的并发度之后会出现明显的拐点，之后一路下降，最终甚至会比单thread的性能还要差。

　　II：其次，超卖的根结在于减库存操作是一个事务操作，需要先select，然后insert，最后update -1。最后这个-1操作是不能出现负数的，但是当多用户在有库存的情况下并发操作，出现负数这是无法避免的。

　　III：最后，当减库存和高并发碰到一起的时候，由于操作的库存数目在同一行，就会出现争抢InnoDB行锁的问题，导致出现互相等待甚至死锁，从而大大降低MySQL的处理性能，最终导致前端页面出现超时异常。

针对上述问题，如何解决呢？我们先看眼淘宝的高大上解决方案：

　　I：关闭死锁检测，提高并发处理性能。

　　II：修改源代码，将排队提到进入引擎层前，降低引擎层面的并发度。

　　III：组提交，降低server和引擎的交互次数，降低IO消耗。

不过结合我们的实际，改源码这种高大上的解决方案显然有那么一点不切实际。于是小伙伴们需要讨论出一种适合我们实际情况的解决方案。以下就是我们讨论的解决方案：

首先设定一个前提，为了防止超卖现象，所有减库存操作都需要进行一次减后检查，保证减完不能等于负数。（由于MySQL事务的特性，这种方法只能降低超卖的数量，但是不可能完全避免超卖）

update number set x=x-1 where (x -1 ) >= 0;

解决方案1：

将存库从MySQL前移到Redis中，所有的写操作放到内存中，由于Redis中不存在锁故不会出现互相等待，并且由于Redis的写性能和读性能都远高于MySQL，这就解决了高并发下的性能问题。然后通过队列等异步手段，将变化的数据异步写入到DB中。

优点：解决性能问题

缺点：没有解决超卖问题，同时由于异步写入DB，存在某一时刻DB和Redis中数据不一致的风险。

解决方案2：

引入队列，然后将所有写DB操作在单队列中排队，完全串行处理。当达到库存阀值的时候就不在消费队列，并关闭购买功能。这就解决了超卖问题。

优点：解决超卖问题，略微提升性能。

缺点：性能受限于队列处理机处理性能和DB的写入性能中最短的那个，另外多商品同时抢购的时候需要准备多条队列。

解决方案3：

将写操作前移到MC中，同时利用MC的轻量级的锁机制CAS来实现减库存操作。

优点：读写在内存中，操作性能快，引入轻量级锁之后可以保证同一时刻只有一个写入成功，解决减库存问题。

缺点：没有实测，基于CAS的特性不知道高并发下是否会出现大量更新失败？不过加锁之后肯定对并发性能会有影响。

解决方案4：

将提交操作变成两段式，先申请后确认。然后利用Redis的原子自增操作（相比较MySQL的自增来说没有空洞），同时利用Redis的事务特性来发号，保证拿到小于等于库存阀值的号的人都可以成功提交订单。然后数据异步更新到DB中。

优点：解决超卖问题，库存读写都在内存中，故同时解决性能问题。

缺点：由于异步写入DB，可能存在数据不一致。另可能存在少买，也就是如果拿到号的人不真正下订单，可能库存减为0，但是订单数并没有达到库存阀值。

三、总结

1、前端三板斧【扩容】【限流】【静态化】

2、后端两条路【内存】+【排队】

四、非技术感想

1、团队的力量是无穷的，各种各样的解决方案（先不谈可行性）都是在小伙伴们七嘴八舌中讨论出来的。我们需要让所有人都发出自己的声音，不要着急去否定。

2、优化需要从整体层面去思考，不要只纠结于自己负责的部分，如果只盯着一个点思考，最后很可能就走进死胡同中了。

3、有很多东西以为读过了就懂了，其实不然。依然还是需要实践，否则别人的知识永远不可能变成自己的。

4、多思考为什么，会发生什么，不要想当然。只有这样才能深入进去，而不是留在表面。

ps：以上仅仅是我们讨论的一些方案设想，欢迎大家一起讨论各种可行方案。