nuniok

笔记本

0%

发表于

利用Python自带的包可以建立简单的web服务器。在DOS里cd到准备做服务器根目录的路径下，输入命令：
python -m Web服务器模块 [端口号，默认8000]
例如：
python -m SimpleHTTPServer 8080
然后就可以在浏览器中输入
http://localhost:端口号/路径
来访问服务器资源。
例如：
http://localhost:8080/index.htm（当然index.htm文件得自己创建）
其他机器也可以通过服务器的IP地址来访问。

这里的“Web服务器模块”有如下三种：

  • BaseHTTPServer: 提供基本的Web服务和处理器类，分别是HTTPServer和BaseHTTPRequestHandler。
  • SimpleHTTPServer: 包含执行GET和HEAD请求的SimpleHTTPRequestHandler类。
  • CGIHTTPServer: 包含处理POST请求和执行CGIHTTPRequestHandler类。

发表于

平均时间复杂度均为O(n^2)的排序算法：

插入排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# -*- coding:utf-8 -*-
# 插入排序，两层遍历，以一个位置为基准，不断向前遍历，将比基准位置大的数调整到基准位置。
def insertion_sort(sort_list):
    iter_len = len(sort_list)
    if iter_len < 2:
        return sort_list
    for i in range(1, iter_len):
        key = sort_list[i]
        j = i - 1
        while j>=0 and sort_list[j]>key:
            sort_list[j+1] = sort_list[j]
            j -= 1
        sort_list[j+1] = key
    return sort_list
if __name__ == "__main__":
    sort_list = [4,2,7,3,1,9,33,25,46,21,45,22]
    print sort_list
    print insertion_sort(sort_list)

冒泡排序

1
2
3
4
5
6
7
8
9
10
11
12
13
def bubble_sort(sort_list):
    iter_len = len(sort_list)
    if iter_len < 2:
        return sort_list
    for i in range(iter_len-1):
        for j in range(iter_len-i-1):
            if sort_list[j] > sort_list[j+1]:
                sort_list[j], sort_list[j+1] = sort_list[j+1], sort_list[j]
    return sort_list
if __name__ == "__main__":
    sort_list = [4,2,7,3,1,9,33,25,46,21,45,22]
    print sort_list
    print bubble_sort(sort_list)

选择排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# -*- coding:utf-8 -*-
# 向后遍历，选择最小值进行交换。
def selection_sort(sort_list):
    iter_len = len(sort_list)
    if iter_len < 2:
        return sort_list
    for i in range(iter_len-1):
        smallest = sort_list[i]
        location = i
        for j in range(i, iter_len):
            if sort_list[j] < smallest:
                smallest = sort_list[j]
                location = j
        if i != location:
            sort_list[i], sort_list[location] = sort_list[location], sort_list[i]
    return sort_list
if __name__ == "__main__":
    sort_list = [4,2,7,3,1,9,33,25,46,21,45,22]
    print sort_list
    print selection_sort(sort_list)

归并排序

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 Merge_sort(object):
    def _merge(self, alist, p, q, r):
        left = alist[p:q+1]
        right = alist[q+1:r+1]
        for i in range(p, r+1):
            if len(left)>0 and len(right)>0:
                if left[0]<=right[0]:
                    alist[i] = left.pop(0)
                else:
                    alist[i] = right.pop(0)
            elif len(right)==0:
                alist[i] = left.pop(0)
            elif len(left)==0:
                alist[i] = right.pop(0)
 
    def _merge_sort(self, alist, p, r):
        if p<r:
            q = int((p+r)/2)
            self._merge_sort(alist, p, q)
            self._merge_sort(alist, q+1, r)
            self._merge(alist, p, q, r)
 
    def __call__(self, sort_list):
        self._merge_sort(sort_list, 0, len(sort_list)-1)
        return sort_list
if __name__ == "__main__":
    sort_list = [4,2,7,3,1,9,33,25,46,21,45,22]
    print sort_list
    merge = Merge_sort()
    print merge(sort_list)

堆排序

堆排序，是建立在数据结构——堆上的。关于堆的基本概念、以及堆的存储方式这里不作介绍。这里用一个列表来存储堆（和用数组存储类似），对于处在i位置的元素，2i+1位置上的是其左孩子，2i+2是其右孩子，类似得可以得出该元素的父元素。
首先我们写一个函数，对于某个子树，从根节点开始，如果其值小于子节点的值，就交换其值。用此方法来递归其子树。接着，我们对于堆的所有非叶节点，自下而上调用先前所述的函数，得到一个树，对于每个节点（非叶节点），它都大于其子节点。（其实这是建立最大堆的过程）在完成之后，将列表的头元素和尾元素调换顺序，这样列表的最后一位就是最大的数，接着在对列表的0到n-1部分再调用以上建立最大堆的过程。最后得到堆排序完成的列表。

快速排序

首先要用到的是分区工具函数（partition），对于给定的列表（数组），我们首先选择基准元素（这里我选择最后一个元素），通过比较，最后使得该元素的位置，使得这个运行结束的新列表（就地运行）所有在基准元素左边的数都小于基准元素，而右边的数都大于它。然后我们对于待排的列表，用分区函数求得位置，将列表分为左右两个列表（理想情况下），然后对其递归调用分区函数，直到子序列的长度小于等于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
class Quick_sort(object):
    def _partition(self, alist, p, r):
        i = p-1
        x = alist[r]
        for j in range(p, r):
            if alist[j]<=x:
                i += 1
                alist[i], alist[j] = alist[j], alist[i]
        alist[i+1], alist[r] = alist[r], alist[i+1]
        return i+1
 
    def _quicksort(self, alist, p, r):
        if p<r:
            q = self._partition(alist, p, r)
            self._quicksort(alist, p, q-1)
            self._quicksort(alist, q+1, r)
 
    def __call__(self, sort_list):
        self._quicksort(sort_list, 0, len(sort_list)-1)
        return sort_list
if __name__ == "__main__":
    sort_list = [4,2,7,3,1,9,33,25,46,21,45,22]
    print sort_list
    quick = Quick_sort()
    print quick(sort_list)

Python对于递归深度做了限制，默认值为1000，可以通过设置修改深度。

1
2
import sys
sys.setrecursionlimit(99999)

另外一种是随机化分区函数。由于之前我们的选择都是子序列的最后一个数，因此对于特殊情况的健壮性就差了许多。现在我们随机从子序列选择基准元素，这样可以减少对特殊情况的差错率。

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
import random
class Random_quick_sort(object):
    
    def _randomized_partition(self, alist, p, r):
        i = random.randint(p, r)
        alist[i], alist[r] = alist[r], alist[i]
        return self._partition(alist, p, r)
    def _partition(self, alist, p, r):
        i = p-1
        x = alist[r]
        for j in range(p, r):
            if alist[j]<=x:
                i += 1
                alist[i], alist[j] = alist[j], alist[i]
        alist[i+1], alist[r] = alist[r], alist[i+1]
        return i+1
    def _quicksort(self, alist, p, r):
        if p<r:
            q = self._randomized_partition(alist, p, r)
            self._quicksort(alist, p, q-1)
            self._quicksort(alist, q+1, r)
 
    def __call__(self, sort_list):
        self._quicksort(sort_list, 0, len(sort_list)-1)
        return sort_list
if __name__ == "__main__":
    sort_list = [4,2,7,3,1,9,33,25,46,21,45,22]
    print sort_list
    random_quick = Random_quick_sort()
    print random_quick(sort_list)

Python风格快速排序算法

1
2
3
4
5
6
7
8
9
10
def quick_sort_2(sort_list):
    if len(sort_list)<=1:
        return sort_list
    return quick_sort_2([lt for lt in sort_list[1:] if lt<sort_list[0]]) + \
           sort_list[0:1] + \
           quick_sort_2([ge for ge in sort_list[1:] if ge>=sort_list[0]])
if __name__ == "__main__":
    sort_list = [4,2,7,3,1,9,33,25,46,21,45,22]
    print sort_list
    print quick_sort_2(sort_list)

计数排序

计数排序的基本思想是对于给定的输入序列中的每一个元素x，确定该序列中值小于x的元素的个数。一旦有了这个信息，就可以将x直接存放到最终的输出序列的正确位置上。例如，如果输入序列中只有17个元素的值小于x的值，则x可以直接存放在输出序列的第18个位置上。当然，如果有多个元素具有相同的值时，我们不能将这些元素放在输出序列的同一个位置上，因此，上述方案还要作适当的修改。
假设输入的线性表L的长度为n，L=L1,L2,..,Ln；线性表的元素属于有限偏序集S，|S|=k且k=O(n)，S={S1,S2,..Sk}；则计数排序可以描述如下：
1、扫描整个集合S，对每一个Si∈S，找到在线性表L中小于等于Si的元素的个数T(Si)；
2、扫描整个线性表L，对L中的每一个元素Li，将Li放在输出线性表的第T(Li)个位置上，并将T(Li)减1。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Counting_sort(object):
    def _counting_sort(self, alist, k):
        alist3 = [0 for i in range(k)]
        alist2 = [0 for i in range(len(alist))]
        for j in alist:
            alist3[j] += 1
        for i in range(1, k):
            alist3[i] = alist3[i-1] + alist3[i]
        for l in alist[::-1]:
            alist2[alist3[l]-1] = l
            alist3[l] -= 1
        return alist2
 
    def __call__(self, sort_list, k=None):
        if k is None:
            import heapq
            k = heapq.nlargest(1, sort_list)[0] + 1
        return self._counting_sort(sort_list, k)
if __name__ == "__main__":
    sort_list = [4,2,7,3,1,9,33,25,46,21,45,22]
    print sort_list
    counting = Counting_sort()
    print counting(sort_list)

排序算法用于研究其思想，具体的应用需要根据实际环境进行修改，但是要遵循以下规则。
当需要排序的时候，尽量设法使用内建Python列表的sort方法。
当需要搜索的时候，尽量设法使用内建的字典。

发表于

装饰器模式定义：动态地给一个对象添加一些额外的职责。

在 Python 中 Decorator Mode 可以按照像其它编程语言如 C++、Java 等的样子来实现，但是 Python 在应用装饰概念方面的能力上远不止于此， Python 提供了一个语法和一个编程特性来加强这方面的功能。

首先需要了解一下 Python 中闭包的概念：如果在一个内部函数里，对在外部作用域（但不是在全局作用域）的变量进行引用，那么内部函数就被认为是闭包（closure）。

dec1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def makeblod(fn):
    def wrapped():
        return '<b>'+fn()+'</b>'
    return wrapped

def makeitalic(fn):
    def wrapped():
        return '<i>'+fn()+'</i>'
    return wrapped

@makeblod
@makeitalic
def hello():
    return 'hello world'

print hello()

dec2

1
2
3
4
5
6
7
8
9
10
11
12
13
def deco(arg):
    def _deco(func):
        def __deco():
            print "before %s called [%s]." % (func.__name__, arg)
            func()
            print "after %s called [%s]." % (func.__name__, arg)
        return __deco
    return _deco

@deco("mymodule")
def myfunc():
    print "myfunc() called."
myfunc()

闭包学习：

http://blog.csdn.net/marty_fu/article/details/7679297

接收参数的装饰器

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

def decorator(run_count):
    def _decorator(fun):
        def wrapper(*args, **kwargs):
            start = time.time()
            for i in xrange(run_count):
                fun(*args, **kwargs)
            runtime = time.time() - start
            print runtime
        return wrapper
    return _decorator

@decorator(2)
def do_something(name):
    time.sleep(0.1)
    print "play game " + name

do_something("san guo sha")

装饰器类

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

class decorator(object):
    def __init__(self, count):
        self._count = count

    def __call__(self, fun):
        self.fun = fun
        return self.call_fun

    def call_fun(self, *args, **kwargs):
        start = time.time()
        for _ in range(self._count):
            self.fun(*args, **kwargs)
        runtime = time.time() - start
        print runtime

@decorator(2)
def do_something():
    time.sleep(0.1)
    print "play game"

do_something()

发表于

SQL连接可以分为内连接、外连接、交叉连接。

数据库数据：
book表
stu表

内连接

  • 等值连接：在连接条件中使用等于号(=)运算符比较被连接列的列值，其查询结果中列出被连接表中的所有列，包括其中的重复列。
  • 不等值连接：在连接条件使用除等于运算符以外的其它比较运算符比较被连接的列的列值。这些运算符包括>、>=、<=、<、!>、!<和<>。
  • 自然连接：在连接条件中使用等于(=)运算符比较被连接列的列值，但它使用选择列表指出查询结果集合中所包括的列，并删除连接表中的重复列。

内连接：内连接查询操作列出与连接条件匹配的数据行，它使用比较运算符比较被连接列的列值。
select * from book as a,stu as b where a.sutid = b.stuidselect * from book as a inner join stu as b on a.sutid = b.stuid

内连接可以使用上面两种方式，其中第二种方式的inner可以省略。

stu表

其连接结果如上图，是按照a.stuid = b.stuid进行连接。

外连接

  • 左联接：是以左表为基准，将a.stuid = b.stuid的数据进行连接，然后将左表没有的对应项显示，右表的列为NULL
    select * from book as a left join stu as b on a.sutid = b.stuid

stu表

  • 右连接：是以右表为基准，将a.stuid = b.stuid的数据进行连接，然以将右表没有的对应项显示，左表的列为NULL
    select * from book as a right join stu as b on a.sutid = b.stuid

stu表

  • 全连接：完整外部联接返回左表和右表中的所有行。当某行在另一个表中没有匹配行时，则另一个表的选择列表列包含空值。如果表之间有匹配行，则整个结果集行包含基表的数据值。
    select * from book as a full outer join stu as b on a.sutid = b.stuid

stu表

交叉连接

交叉连接：交叉联接返回左表中的所有行，左表中的每一行与右表中的所有行组合。交叉联接也称作笛卡尔积。
select * from book as a cross join stu as b order by a.id

stu表

发表于

伪彩色处理是指将灰度图像转换成彩色图象。因为人眼对于彩色的分辨能力远高于对灰度图像的分辨能力，所以将灰度图像转换成彩色可以提高人眼对图像细节的辨别能力。伪彩色并不能真实的反映图像像的彩色情况。

效果图：

强度分层法和灰度级-彩色变换法：
（1）强度分层法是伪彩色处理技术中最简单的一种。
在某个灰度级Li上设置一个平行于x-y平面的切割平面，切割平面下面的，即灰度级小于Li的像素分配给一种颜色，相应的切割平面上大于灰度级Li的像素分配给另一种颜色。这样切割结果可以分成两层的伪彩色。可以使用M个平面去切割，就会得到M个不同灰度级的区域，这样就是具有M种颜色的为彩色图像。这种方法虽然简单，但是视觉效果不理想。
（2）灰度级-彩色变换法可以将灰度图像变为具有多种颜色渐变的连续彩色图像。
主要就是将图像通过不同变换特性的红、绿、蓝3个变换器，然后将三个颜色通道的输出合成某种颜色。由于三种颜色变换的不同，使得不同大小灰度级可以合成不同的颜色。一组典型的变换传递函数如下图。

这里面需要注意的地方，代码只能是处理JPG格式的灰度图像，因为JPG图像的颜色深度是24位表示（R,G,B），每像素由3个字节表示即可，然而PNG图像的颜色深度是32位表示（R,G,B,A）。

下面的代码是测试代码，以处理24位深度的图像为例，同像素不同通道的颜色值要相同，组合表示出是具有一定灰度的颜色。在实际应用中需要修改下面的代码依据要处理的图像格式。

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
#region 伪彩色图像处理

/// <summary>
/// 伪彩色图像处理
/// 博客园-初行 http://www.cnblogs.com/zxlovenet
/// 日期：2014.2.14
/// </summary>
/// <param name="bmp">传入的灰度图像</param>
/// <param name="method">使用何种方法，false强度分层法,true灰度级-彩色变换法</param>
/// <param name="seg">强度分层中的分层数</param>
/// <returns>返回伪彩色图像</returns>
private Bitmap gcTrans(Bitmap bmp, bool method, byte seg)
{
    if (bmp != null)
    {
        if (System.Drawing.Imaging.PixelFormat.Format24bppRgb == bmp.PixelFormat)
        {
            Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height);
            System.Drawing.Imaging.BitmapData bmpData = bmp.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadWrite, bmp.PixelFormat);
            IntPtr ptr = bmpData.Scan0;
            int bytes = bmp.Width * bmp.Height * 3;
            byte[] grayValues = new byte[bytes];
            System.Runtime.InteropServices.Marshal.Copy(ptr, grayValues, 0, bytes);
            bmp.UnlockBits(bmpData);

            byte[] rgbValues = new byte[bytes];
            //清零
            Array.Clear(rgbValues, 0, bytes);
            byte tempB;

            if (method == false)
            {
                //强度分层法
                for (int i = 0; i < bytes; i += 3)
                {
                    byte ser = (byte)(256 / seg);
                    tempB = (byte)(grayValues[i] / ser);
                    //分配任意一种颜色
                    rgbValues[i + 1] = (byte)(tempB * ser);
                    rgbValues[i] = (byte)((seg - 1 - tempB) * ser);
                    rgbValues[i + 2] = 0;
                }
            }
            else
            {
                //灰度级-彩色变换法
                for (int i = 0; i < bytes; i += 3)
                {
                    if (grayValues[i] < 64)
                    {
                        rgbValues[i + 2] = 0;
                        rgbValues[i + 1] = (byte)(4 * grayValues[i]);
                        rgbValues[i] = 255;
                    }
                    else if (grayValues[i] < 128)
                    {
                        rgbValues[i + 2] = 0;
                        rgbValues[i + 1] = 255;
                        rgbValues[i] = (byte)(-4 * grayValues[i] + 2 * 255);
                    }
                    else if (grayValues[i] < 192)
                    {
                        rgbValues[i + 2] = (byte)(4 * grayValues[i] - 2 * 255);
                        rgbValues[i + 1] = 255;
                        rgbValues[i] = 0;
                    }
                    else
                    {
                        rgbValues[i + 2] = 255;
                        rgbValues[i + 1] = (byte)(-4 * grayValues[i] + 4 * 255);
                        rgbValues[i] = 0;
                    }
                }

            }

            bmp = new Bitmap(bmp.Width, bmp.Height, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
            bmpData = bmp.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadWrite, bmp.PixelFormat);
            ptr = bmpData.Scan0;

            System.Runtime.InteropServices.Marshal.Copy(rgbValues, 0, ptr, bytes);
            bmp.UnlockBits(bmpData);

            return bmp;
        }
        else
        {
            return null;
        }
    }
    else
    {
        return null;
    }
}
#endregion

颜色映射：

颜色映射的方法需要做一个颜色映射表，不同灰度级都会有对应的颜色。这个跟强度分层法相似，可以分成不同的层次，对应的颜色可以根据实际情况做映射。
在实际应用中，热成像测温系统所产生的红外图像为黑白灰度级图像，灰度值动态范围不大，人眼很难从这些灰度级中获得丰富的信息。为了更直观地增强显示图像的层次，提高人眼分辨能力，对系统所摄取的图像进行伪彩色处理，从而达到图像增强的效果，使图像信息更加丰富。例如对受热物体所成的像进行伪彩色时，将灰度低的区域设置在蓝色附近(或蓝灰、黑等)，而灰度级高的区域设置在红色附近(或棕红、白等)，以方便人们对物体的观察。

下面几张图片是在实际应用中的情况（图片来源网络，侵删）：


xmind文件

发表于

微弱的灯光驱散浓重的夜色，压低的歌声怕惊醒梦中人。

又是深夜，双手在键盘上飞舞，闪烁的光标不断向前推进，一行行的注释和代码呈现在屏幕上，对于我来说这便成为了一种习惯，喜欢在深夜学习编程，接触编程有两年半了，非睡眠状态下的大部分时间都贡献给了我手中这台笔记本电脑，现在被我的朋友称之为我的“媳妇”。哈哈，因为她对于我来说兴趣很浓，我从不迷恋游戏，只是偶尔玩玩，也很少购物，电影基本不看，只是偶尔听听歌，还是敲代码的时候。转眼这不又是要过年了，该来点总结了，看看都学了什么，有什么体会都要来写写的。

主要学习的语言是C#，两年半的时间大部分都是用C#在编程；当然对C++/Java也是比较熟悉的，给点代码也是能看懂什么意思的。对汇编语言也有所了解，目前正在学习中。
那下面就是要讲讲主攻技能.NET平台下的学习细节了：

  1. ASP.NET网站开发方面能做出个像模像样的网站，但是不能保证效率；熟悉三层架构，用的比较烂；对于难理解的HttpModule、HttpHandler有些了解。
  2. Winform方面百分之八十的控件能熟练使用，剩下的就是感觉不好用的了，这里的熟练使用是了解并使用过常用的属性、方法、事件。
  3. 再有就是关于多线程、网络编程、数字图像处理、单元测试等等升级技能也是用的比较不错，专门买过书学习过。

像一些附加技能的话如HTML/CSS用的还是比较不错的，至少能做出能拿得出手的网页去，各种效果咱不会写还不会“偷”吗，其实就是拷贝网上现有的呗。JS/jQuery这些吗，实话是没有怎么接触，也基本能写一点点的，都不好意思说了。不想走网站开发方面，感觉没有前途，也不好玩，就学了一年就止步了。

再有就是编程的基本功，像数据结构、操作系统、算法、数据库这些知识是学会六分左右，现在正在补习其余的四分，并且是努力的在夯实这方面欠缺的。至于软件工程的知识我觉得是先有所了解然后在工作中主键掌握并熟练运用。

最大的优点是对计算机软件技术充满了热情，乐死不疲的。各种好玩的新技术都想鼓捣一下，比如：Wifi共享、RamDisk、远程开机等等。

不足之处是不太爱说话，喜欢熬夜。

目前学习计划：

  • 数据结构+算法
  • Unity3D游戏开发

职业规划还木有想好，因为还未毕业，干嘛这么早就草率决定，等工作一两年之后再说呗，定居城市也是这样。但是目前来说不想一直走.NET发展路线，先打好基本功到时候好转行。

2014年，把前半年的时间用在刀刃上，学习的技能放在毕业找的工作方面。另外要努力学习英语，这个也是个大大的重点。

发表于

ipython：
sudo pip install ipython

ipython notebook：
sudo pip install notebook

Pycharm

发表于

MySQL 函数

字符串替换函数
REPLACE(field1, 'abc', 'def')

截取字符串函数

SUBSTRING(str1, start_index, length)

SELECT 增加自增序列

1
2
SET @counter=0;
SELECT @counter:=@counter+1 AS Rank,LastName,Roll_no as Roll FROM Students ORDER BY Roll_no ASC;

时间戳转标准时间函数

FROM_UNIXTIME(unix_timestamp ，'%Y-%m-%d %H:%i:%S')

标准时间转时间戳函数

UNIX_TIMESTAMP(date)

当前标准时间函数

NOW()

当前时间戳函数

UNIX_TIMESTAMP(NOW())

Hive 函数

时间戳转标准时间函数

FROM_UNIXTIME(unix_timestamp ，'yyyyMMdd')

发表于

http://blog.csdn.net/zhaoyangjian724/article/details/52858519

先非主键范围加锁
查看事务状态
插入区分度高的数据-成功
插入区分度低的数据-失败
查看引擎状态，发现页锁
改为以主键做查询条件加锁
插入区分度低的数据-成功

SELECT * FROM INNODB_TRX;

SHOW ENGINE INNODB STATUS;

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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

=====================================
2017-12-18 11:47:27 7fd5dd6f6700 INNODB MONITOR OUTPUT
=====================================
Per second averages calculated from the last 57 seconds
-----------------
BACKGROUND THREAD
-----------------
srv_master_thread loops: 22630 srv_active, 0 srv_shutdown, 15047550 srv_idle
srv_master_thread log flush and writes: 15067795
----------
SEMAPHORES
----------
OS WAIT ARRAY INFO: reservation count 21761
OS WAIT ARRAY INFO: signal count 42765
Mutex spin waits 38129, rounds 296291, OS waits 3638
RW-shared spins 25778, rounds 578697, OS waits 16634
RW-excl spins 4632, rounds 145148, OS waits 1184
Spin rounds per wait: 7.77 mutex, 22.45 RW-shared, 31.34 RW-excl
------------
TRANSACTIONS
------------
Trx id counter 167458
Purge done for trx's n:o < 167444 undo n:o < 0 state: running but idle
History list length 942
LIST OF TRANSACTIONS FOR EACH SESSION:
---TRANSACTION 0, not started
MySQL thread id 2700260, OS thread handle 0x7fd5dd6f6700, query id 16186792 10.21.0.2 wallet init
SHOW ENGINE INNODB STATUS
---TRANSACTION 167433, not started
MySQL thread id 2700100, OS thread handle 0x7fd5dd7fa700, query id 16185344 10.100.27.2 wallet cleaning up
---TRANSACTION 167449, not started
MySQL thread id 2700073, OS thread handle 0x7fd5e6581700, query id 16186116 10.100.53.2 wallet cleaning up
---TRANSACTION 167434, not started
MySQL thread id 2700060, OS thread handle 0x7fd5e6685700, query id 16185479 10.100.53.2 wallet cleaning up
---TRANSACTION 0, not started
MySQL thread id 2699993, OS thread handle 0x7fd5dd5f2700, query id 16184159 10.100.27.2 wallet cleaning up
---TRANSACTION 0, not started
MySQL thread id 2699968, OS thread handle 0x7fd5dd633700, query id 16183926 10.100.53.2 wallet cleaning up
---TRANSACTION 0, not started
MySQL thread id 2699967, OS thread handle 0x7fd5dd7b9700, query id 16183863 10.100.53.2 wallet cleaning up
---TRANSACTION 0, not started
MySQL thread id 2699966, OS thread handle 0x7fd5e6540700, query id 16183754 10.100.53.2 wallet cleaning up
---TRANSACTION 0, not started
MySQL thread id 2699965, OS thread handle 0x7fd5e4049700, query id 16183668 10.100.53.2 wallet cleaning up
---TRANSACTION 0, not started
MySQL thread id 2699964, OS thread handle 0x7fd5e66c6700, query id 16183581 10.100.53.2 wallet cleaning up
---TRANSACTION 0, not started
MySQL thread id 2699963, OS thread handle 0x7fd5dd6b5700, query id 16183494 10.100.53.2 wallet cleaning up
---TRANSACTION 167457, ACTIVE 11 sec inserting
mysql tables in use 1, locked 1
LOCK WAIT 2 lock struct(s), heap size 360, 1 row lock(s), undo log entries 1
MySQL thread id 2700275, OS thread handle 0x7fd5dd737700, query id 16186778 10.21.0.2 wallet update
INSERT INTO `ttt` (`id`, `no`, `trade_number`)
VALUES
	(586, '856195904590458889', '200526175912156728')
------- TRX HAS BEEN WAITING 11 SEC FOR THIS LOCK TO BE GRANTED:
RECORD LOCKS space id 50 page no 5 n bits 96 index `idx_number` of table `test`.`ttt` trx id 167457 lock_mode X locks gap before rec insert intention waiting
Record lock, heap no 14 PHYSICAL RECORD: n_fields 2; compact format; info bits 0
 0: len 29; hex 5a484c4956454255593230313730353236323233323432363434353939; asc ZHLIVEBUY20170526223242644599;;
 1: len 8; hex 0000000000000229; asc        );;

------------------
---TRANSACTION 167447, ACTIVE 602 sec
4 lock struct(s), heap size 1184, 3 row lock(s)
MySQL thread id 2699383, OS thread handle 0x7fd5e4251700, query id 16186751 10.21.0.2 wallet cleaning up
--------
FILE I/O
--------
I/O thread 0 state: waiting for completed aio requests (insert buffer thread)
I/O thread 1 state: waiting for completed aio requests (log thread)
I/O thread 2 state: waiting for completed aio requests (read thread)
I/O thread 3 state: waiting for completed aio requests (read thread)
I/O thread 4 state: waiting for completed aio requests (read thread)
I/O thread 5 state: waiting for completed aio requests (read thread)
I/O thread 6 state: waiting for completed aio requests (write thread)
I/O thread 7 state: waiting for completed aio requests (write thread)
I/O thread 8 state: waiting for completed aio requests (write thread)
I/O thread 9 state: waiting for completed aio requests (write thread)
Pending normal aio reads: 0 [0, 0, 0, 0] , aio writes: 0 [0, 0, 0, 0] ,
 ibuf aio reads: 0, log i/o's: 0, sync i/o's: 0
Pending flushes (fsync) log: 0; buffer pool: 0
6707 OS file reads, 383968 OS file writes, 119945 OS fsyncs
0.00 reads/s, 0 avg bytes/read, 0.11 writes/s, 0.09 fsyncs/s
-------------------------------------
INSERT BUFFER AND ADAPTIVE HASH INDEX
-------------------------------------
Ibuf: size 1, free list len 74, seg size 76, 733 merges
merged operations:
 insert 34, delete mark 169019, delete 2
discarded operations:
 insert 0, delete mark 0, delete 0
Hash table size 149489, node heap has 168 buffer(s)
0.00 hash searches/s, 0.05 non-hash searches/s
---
LOG
---
Log sequence number 394355624
Log flushed up to   394355624
Pages flushed up to 394355624
Last checkpoint at  394355624
0 pending log writes, 0 pending chkp writes
65750 log i/o's done, 0.04 log i/o's/second
----------------------
BUFFER POOL AND MEMORY
----------------------
Total memory allocated 77266944; in additional pool allocated 0
Dictionary memory allocated 669112
Buffer pool size   4607
Free buffers       1024
Database pages     3415
Old database pages 1240
Modified db pages  0
Pending reads 0
Pending writes: LRU 0, flush list 0, single page 0
Pages made young 11699, not young 475003
0.00 youngs/s, 0.00 non-youngs/s
Pages read 6606, created 13587, written 300725
0.00 reads/s, 0.00 creates/s, 0.05 writes/s
Buffer pool hit rate 1000 / 1000, young-making rate 0 / 1000 not 0 / 1000
Pages read ahead 0.00/s, evicted without access 0.00/s, Random read ahead 0.00/s
LRU len: 3415, unzip_LRU len: 0
I/O sum[3]:cur[0], unzip sum[0]:cur[0]
--------------
ROW OPERATIONS
--------------
0 queries inside InnoDB, 0 queries in queue
0 read views open inside InnoDB
Main thread process no. 12657, id 140556665968384, state: sleeping
Number of rows inserted 227014, updated 19739, deleted 89828, read 47831814
0.00 inserts/s, 0.00 updates/s, 0.00 deletes/s, 0.00 reads/s
----------------------------
END OF INNODB MONITOR OUTPUT
============================