MySQL的四种事务隔离级别

一、事务的并发问题

1、脏读:事务A读取了事务B更新的数据,然后B回滚操作,那么A读取到的数据是脏数据

2、不可重复读:事务 A 多次读取同一数据,事务 B 在事务A多次读取的过程中,对数据作了更新并提交,导致事务A多次读取同一数据时,结果不一致。

3、幻读:系统管理员A将数据库中所有学生的成绩从具体分数改为ABCDE等级,但是系统管理员B就在这个时候插入了一条具体分数的记录,当系统管理员A改结束后发现还有一条记录没有改过来,就好像发生了幻觉一样,这就叫幻读。

 

小结:不可重复读的和幻读很容易混淆,不可重复读侧重于修改,幻读侧重于新增或删除。解决不可重复读的问题只需锁住满足条件的行,解决幻读需要锁表Continue reading "MySQL的四种事务隔离级别"

Gitlab库已损坏前端显示500错误解决方法:remote: fatal: loose object xxx is corrupt

今天团队小伙伴们在git push的时候报错:

remote: error: object file ./objects/ba/8dd150f67fe38c7e9d8cf44eee7c38b0afe34e is empty
remote: error: object file ./objects/ba/8dd150f67fe38c7e9d8cf44eee7c38b0afe34e is empty
remote: fatal: loose object ba8dd150f67fe38c7e9d8cf44eee7c38b0afe34e (stored in ./objects/ba/8dd150f67fe38c7e9d8cf44eee7c38b0afe34e) is corrupt

咋一看吓一跳,数据文件坏掉啦?!赶紧搜索了一下,以下是解决方案。

Continue reading "Gitlab库已损坏前端显示500错误解决方法:remote: fatal: loose object xxx is corrupt"

Go学习整理笔记

最近重新梳理了一下Go学习中的一些要点,包括Go性能优化及底层源码要点,作此笔记,巩固基础。

一、并发

1、Go语言的goroutine类似于线程和协程的综合体,能最大限度提升执行效率,发挥多核处理能力;

2、通常情况下,用多进程来实现分布式负载均衡,减轻单进程垃圾回收压力;用多线程(LWP)抢夺更多的处理器资源;用协程来提高处理器时间片利用率;

3、相比较系统默认MB级别的线程栈,goroutine自定义栈初始仅需2KB,所以才能创建成千上万的并发任务。自定义栈采用按需分配策略,在需要时进行扩容,最大能到GB规模;

4、Go在运行时可能会创建很多线程,但任何时候仅有限的几个线程参与并发任务执行。该量默认与处理器核数相等,可用runtime.GOMAXPROCS函数或者环境变量修改;

5、通道:

         1)、通道(channel)相当于一个并发安全的队列;

         2)、goroutine leak是指goroutine处于发送或者接受阻塞状态,但一直未被唤醒,垃圾回收器并不收集此类资源,导致它们会在队列里长期休眠,形成资源泄露;

6、同步:

         1)、通道并不是用来取代锁的,它们有各自不同的使用场景。通道倾向于解决逻辑层次的并发处理架构,而锁则用来保护局部范围的数据安全;

         2)、将Mutex作为匿名字段时,相关方法必须实现为pointer-receiver模式,否则会因为复制导致锁机制失效;

         3)、应将Mutex锁粒度控制在最小范围内,及早释放;

7、建议:

         1)、对性能要求较高时,应避免使用defer Unlock;

         2)、读写并发时,用RWMutex性能会更好一些;

         3)、对单个数据读写保护,可尝试用原子操作;

         4)、执行严格测试,尽可能打开数据竞争检查;

Continue reading "Go学习整理笔记"

OSI七层模型与TCP/IP五层模型

一直做应用层的开发,对于底层的一些概念比较模糊了,这里稍微整理了一下。

一、OSI参考模型

 1、OSI的来源

        OSI(Open System Interconnect),即开放式系统互联。 一般都叫OSI参考模型,是ISO(国际标准化组织)组织在1985年研究的网络互连模型。

        ISO为了更好的使网络应用更为普及,推出了OSI参考模型。其含义就是推荐所有公司使用这个规范来控制网络。这样所有公司都有相同的规范,就能互联了。

  2、OSI七层模型的划分

       OSI定义了网络互连的七层框架(物理层、数据链路层、网络层、传输层、会话层、表示层、应用层),即ISO开放互连系统参考模型。如下图。

        每一层实现各自的功能和协议,并完成与相邻层的接口通信。OSI的服务定义详细说明了各层所提供的服务。某一层的服务就是该层及其下各层的一种能力,它通过接口提供给更高一层。各层所提供的服务与这些服务是怎么实现的无关。
Continue reading "OSI七层模型与TCP/IP五层模型"

JetBrains 出品的 Go 集成开发环境 GogLand 发布正式版

一直用Gogland的公测版本,从本月初发布了正式版(名字改成Goland了),使用了一下,整体功能和公测版差别不大,希望一些异常崩溃的问题得到了解决。

下载地址:

Linux:https://download.jetbrains.com/go/goland-2017.3.tar.gz 
Windows:https://download.jetbrains.com/go/goland-2017.3.exe 
macOS:https://download.jetbrains.com/go/goland-2017.3.dmg

Linsence Server:http://xidea.online

虽然有破解版,看了一下个人版本一年才89刀,支持下正版。

MySQL中int(10)和int(11)的区别+示例

我们都知道MySQL中的int(10)和int(11)在宽度上是不一样的,但是其实区别真不大,因为都是占用4个字节,所以范围都是一样的,那么主要的区别在哪儿呢?

今天忽然想到这个问题,因此做了一下测试:

1、创建一个测试用的表test,里面只有两个字段,一个int10,一个int11

 

2、往表中插入一条数据,sql如下:

insert into test values(1000000000, 10000000000)	
1 row(s) affected, 1 warning(s): 1264 Out of range value for column 'int11' at row 1	
0.001 sec

这个时候int11字段报warning了,因为都是4个字节,10000000000已经超过4字节范围上限了,但是只是一个warning,因为MySQL底层已经做了截断处理。

Continue reading "MySQL中int(10)和int(11)的区别+示例"

Go语言实现的常用哈希函数,并提供对应的64位方法

以下是使用Go语言实现的常用哈希函数(BKDRHash,APHash,DJBHash,JSHash,RSHash,SDBMHash,PJWHash,ELFHash),并提供每个哈希对应的64位方法。经测试,64位的哈希函数基本不会出现碰撞(测试数据为十亿随机字符串数据量)。

哈希函数代码库地址:https://gitee.com/johng/gf/tree/master/src/g/encoding/ghash

// 封装常用的hash函数
package ghash


// BKDR Hash Function
func BKDRHash(str []byte) uint32 {
    var seed uint32 = 131; // 31 131 1313 13131 131313 etc..
    var hash uint32 = 0;
    for i := 0; i < len(str); i++ {
        hash = hash * seed + uint32(str[i])
    }
    return (hash & 0x7FFFFFFF)
}

// BKDR Hash Function 64
func BKDRHash64(str []byte) uint64 {
    var seed uint64 = 131; // 31 131 1313 13131 131313 etc..
    var hash uint64 = 0;
    for i := 0; i < len(str); i++ {
        hash = hash * seed + uint64(str[i])
    }
    return (hash & 0x7FFFFFFFFFFFFFFF)
}

// SDBM Hash
func SDBMHash(str []byte) uint32 {
    var hash uint32 = 0;
    for i := 0; i < len(str); i++ {
        // equivalent to: hash = 65599*hash + uint32(str[i]);
        hash = uint32(str[i]) + (hash << 6) + (hash << 16) - hash;
    }
    return (hash & 0x7FFFFFFF);
}

// SDBM Hash 64
func SDBMHash64(str []byte) uint64 {
    var hash uint64 = 0;
    for i := 0; i < len(str); i++ {
        // equivalent to: hash = 65599*hash + uint32(str[i]);
        hash = uint64(str[i]) + (hash << 6) + (hash << 16) - hash;
    }
    return (hash & 0x7FFFFFFFFFFFFFFF);
}

// RS Hash Function
func RSHash(str []byte) uint32 {
    var b uint32 = 378551;
    var a uint32 = 63689;
    var hash uint32 = 0;
    for i := 0; i < len(str); i++ {
        hash = hash * a + uint32(str[i]);
        a *= b;
    }
    return (hash & 0x7FFFFFFF);
}

// RS Hash Function 64
func RSHash64(str []byte) uint64 {
    var b    uint64 = 378551;
    var a    uint64 = 63689;
    var hash uint64 = 0;
    for i := 0; i < len(str); i++ {
        hash = hash * a + uint64(str[i]);
        a *= b;
    }
    return (hash & 0x7FFFFFFFFFFFFFFF);
}

// JS Hash Function
func JSHash(str []byte) uint32 {
    var hash uint32 = 1315423911;
    for i := 0; i < len(str); i++ {
        hash ^= ((hash << 5) + uint32(str[i]) + (hash >> 2));
    }
    return (hash & 0x7FFFFFFF);
}

// JS Hash Function 64
func JSHash64(str []byte) uint64 {
    var hash uint64 = 1315423911;
    for i := 0; i < len(str); i++ {
        hash ^= ((hash << 5) + uint64(str[i]) + (hash >> 2));
    }
    return (hash & 0x7FFFFFFFFFFFFFFF);
}

// P. J. Weinberger Hash Function
func PJWHash(str []byte) uint32 {
    var BitsInUnignedInt uint32 = (4 * 8);
    var ThreeQuarters    uint32 = ((BitsInUnignedInt  * 3) / 4);
    var OneEighth        uint32 = (BitsInUnignedInt / 8);
    var HighBits         uint32 = (0xFFFFFFFF) << (BitsInUnignedInt - OneEighth);
    var hash uint32             = 0;
    var test uint32             = 0;
    for i := 0; i < len(str); i++ {
        hash = (hash << OneEighth) + uint32(str[i]);
        if test = hash & HighBits; test != 0 {
            hash = ((hash ^ (test >> ThreeQuarters)) & (^HighBits + 1));
        }
    }
    return (hash & 0x7FFFFFFF);
}

// P. J. Weinberger Hash Function 64
func PJWHash64(str []byte) uint64 {
    var BitsInUnignedInt uint64 = (4 * 8);
    var ThreeQuarters    uint64 = ((BitsInUnignedInt  * 3) / 4);
    var OneEighth        uint64 = (BitsInUnignedInt / 8);
    var HighBits         uint64 = (0xFFFFFFFF) << (BitsInUnignedInt - OneEighth);
    var hash             uint64 = 0;
    var test             uint64 = 0;
    for i := 0; i < len(str); i++ {
        hash = (hash << OneEighth) + uint64(str[i]);
        if test = hash & HighBits; test != 0 {
            hash = ((hash ^ (test >> ThreeQuarters)) & (^HighBits + 1));
        }
    }
    return (hash & 0x7FFFFFFFFFFFFFFF);
}

// ELF Hash Function
func ELFHash(str []byte) uint32 {
    var hash uint32 = 0;
    var x    uint32 = 0;
    for i := 0; i < len(str); i++ {
        hash = (hash << 4) + uint32(str[i]);
        if x = hash & 0xF0000000; x != 0 {
            hash ^= (x >> 24);
            hash &= ^x + 1;
        }
    }
    return (hash & 0x7FFFFFFF);
}

// ELF Hash Function 64
func ELFHash64(str []byte) uint64 {
    var hash uint64 = 0;
    var x    uint64 = 0;
    for i := 0; i < len(str); i++ {
        hash = (hash << 4) + uint64(str[i]);
        if x = hash & 0xF0000000; x != 0 {
            hash ^= (x >> 24);
            hash &= ^x + 1;
        }
    }
    return (hash & 0x7FFFFFFFFFFFFFFF);
}

// DJB Hash Function
func DJBHash(str []byte) uint32 {
    var hash uint32 = 5381;
    for i := 0; i < len(str); i++ {
        hash += (hash << 5) + uint32(str[i]);
    }
    return (hash & 0x7FFFFFFF);
}

// DJB Hash Function 64
func DJBHash64(str []byte) uint64 {
    var hash uint64 = 5381;
    for i := 0; i < len(str); i++ {
        hash += (hash << 5) + uint64(str[i]);
    }
    return (hash & 0x7FFFFFFFFFFFFFFF);
}

// AP Hash Function
func APHash(str []byte) uint32 {
    var hash uint32 = 0;
    for i := 0; i < len(str); i++ {
        if ((i & 1) == 0) {
            hash ^= ((hash << 7) ^ uint32(str[i]) ^ (hash >> 3));
        } else {
            hash ^= (^((hash << 11) ^ uint32(str[i]) ^ (hash >> 5)) + 1);
        }
    }
    return (hash & 0x7FFFFFFF);
}

// AP Hash Function 64
func APHash64(str []byte) uint64 {
    var hash uint64 = 0;
    for i := 0; i < len(str); i++ {
        if ((i & 1) == 0) {
            hash ^= ((hash << 7) ^ uint64(str[i]) ^ (hash >> 3));
        } else {
            hash ^= (^((hash << 11) ^ uint64(str[i]) ^ (hash >> 5)) + 1);
        }
    }
    return (hash & 0x7FFFFFFFFFFFFFFF);
}

 

Go语言/位操作/取反/异或/左移/右移

package main

import (
    "fmt"
)

// 获取0-n之间的所有偶数
func even(a int) (array []int) {
    for i := 0; i < a; i++ {
        if i&1 == 0 { // 位操作符&与C语言中使用方式一样
            array = append(array, i)
        }
    }
    return array
}

// 互换两个变量的值
// 不需要使用第三个变量做中间变量
func swap(a, b int) (int, int) {
    a ^= b // 异或等于运算
    b ^= a
    a ^= b
    return a, b
}

// 左移、右移运算
func shifting(a int) int {
    a = a << 1
    a = a >> 1
    return a
}

// 变换符号
func nagation(a int) int {
        // 注意: C语言中是 ~a+1这种方式
    return ^a + 1 // Go语言取反方式和C语言不同,Go语言不支持~符号。
}

func main() {
    fmt.Printf("even: %v\n", even(100))
    a, b := swap(100, 200)
    fmt.Printf("swap: %d\t%d\n", a, b)
    fmt.Printf("shifting: %d\n", shifting(100))
    fmt.Printf("nagation: %d\n", nagation(100))
}