JB全家桶激活教程

发表于 2020-01-04 | 分类于软件

本教程适用于jetbrains全家桶开发工具（Pycharm、Idea、WebStorm、phpstorm、CLion、RubyMine、AppCode、DataGrid）
本教程适用于所有版本
软件直接从官网下载即可
不需要修改host

激活教程

1. 下载破解补丁

下载补丁文件：jetbrains-agent.jar
文件保存位置可以任意，建议放置到软件安装路径的bin目录下。避免误删文件。

pika学习之数据结构篇

发表于 2019-12-29 | 分类于 Pika

pika的持久化存储模块称为nemo存储引擎，其本质上是对rocksDB(只支持KV存储)的改造和封装。使其支持多数据结构的存储。
pika作为类redis数据库，所以肯定得兼容redis最基本的五种数据结构：string、hash、list、set、zset。

KV存储

KV存储作为rocksDB原生支持的存储方式，所以并没有做太多的处理。仅仅只是在value的结尾加上8个字节的附加信息(前4个字节表示version，后4个字节表示ttl)。
version字段用于对该键值对进行标记，以便后续处理，如删除一个键值对时，可以在该version进行标记，后续再进行真正的删除，这样可以减少删除操作造成的服务阻塞时间。

Hash存储

对于每一个Hash结构，它都包含hash键(key)、域名(field)、值(value)。
nome的存储方式是将key和field组合成为一个新的key，将这个新生成的key与要存储的value组成最终落盘的kv键值对。
对于每一个hash键，nome还为它添加了一个存储元数据信息的落盘kv，它保存的是对应hash键下的所有域值对的个数。

左图字段保存的是hash键的对象，它由标记位+key+version+ttl组成
右图字段仅仅只保存一个数字，表示该hash下field的数量

上图表示nome对传统hash结构转换成kv结构的拆分存储模式。

k结构部分由标记位+长度+key+field组成。size表示的是hash键key的长度。
v结构部分就由具体的value+version+ttl组成。
阅读全文 »

redis复制过程演变

发表于 2019-12-29 | 分类于 Redis

Redis的主从复制主要经历以下的几个阶段：

2.8版本以下—-sync
2.8-4.0版本—-psync
4.0版本+ —-psync2

下面我就来简单的讲讲Redis主从复制的演变过程。

Redis主从复制过程

客户端发送slaveof命令给Redis实例
准备阶段函数为replicationSetMaster，这个函数主要会做一些复制之前的数据和状态清理工作。
更新server.master
将实例状态修改为REPL_STATE_CONNECT
阅读全文 »

浅析GeoHash

发表于 2019-12-26 | 分类于 Redis

GeoHash算法能够将二维的经纬度转换成字符串。主要有以下几个特性:

每一个字符串代表了某一矩形区域.
字符串的长度越长，所表示的位置越精确。
字符串越相近的表示的举例越接近.

原理

GeoHash将经纬度转换为hash字符串主要分为三步：

将纬度(-90, 90)平均分成两个区间(-90, 0)、(0, 90)，如果坐标位置的纬度值在第一区间，则编码是0，否则编码为1
经纬度的编码合并，从0开始，奇数为是纬度，偶数为是经度
对经纬度合并后的编码，进行base32编码

大概过程如下图，不断的对经纬度进行切割，直到精准度达到要求。

代码实现

将经纬度转换成二进制编码

private void convert(double min, double max, double value, List<Character> list) {
        if (list.size() > (length - 1)) {
            return;
        }
        double mid = (max + min) / 2;
        if (value < mid) {
            list.add('0');
            convert(min, mid, value, list);
        } else {
            list.add('1');
            convert(mid, max, value, list);
        }
    }

阅读全文 »

Redis4.0的大key发现和删除

发表于 2019-12-19 | 分类于 Redis

Redis4.0版本之后引入了memory usage命令和lazyfree机制。不管是对大key的发现，还是解决删除大key造成的阻塞问题都有了很大的提升。

大key发现

memory usage的实现主要在object.c->memoryCommand方法中：

{"memory",memoryCommand,-2,
     "random read-only",
     0,NULL,0,0,0,0,0,0},
     
else if (!strcasecmp(c->argv[1]->ptr,"usage") && c->argc >= 3) {
        dictEntry *de;
        long long samples = OBJ_COMPUTE_SIZE_DEF_SAMPLES;
        for (int j = 3; j < c->argc; j++) {
            if (!strcasecmp(c->argv[j]->ptr,"samples") &&
                j+1 < c->argc)
            {
                if (getLongLongFromObjectOrReply(c,c->argv[j+1],&samples,NULL)
                     == C_ERR) return;
                if (samples < 0) {
                    addReply(c,shared.syntaxerr);
                    return;
                }
                if (samples == 0) samples = LLONG_MAX;;
                j++; /* skip option argument. */
            } else {
                addReply(c,shared.syntaxerr);
                return;
            }
        }
        if ((de = dictFind(c->db->dict,c->argv[2]->ptr)) == NULL) {
            addReplyNull(c);
            return;
        }
        size_t usage = objectComputeSize(dictGetVal(de),samples);
        usage += sdsAllocSize(dictGetKey(de));
        usage += sizeof(dictEntry);
        addReplyLongLong(c,usage);
    }

阅读全文 »

Redis初始化启动过程

发表于 2019-12-15 | 分类于 Redis

这篇博文将基于Redis5.0 unstable版本介绍其在启动过程中所做的主要操作以及相关流程函数方法。
在此，先放上一张Redis初始化流程的大意图。

阅读全文 »

缓存雪崩穿透击穿介绍

发表于 2019-12-15 | 分类于 Redis

看到这个标题，你肯定在想：什么是雪崩？什么是穿透？什么是击穿？怎么感觉都是一个意思，都是缓存失效导致的数据库压力问题。

这三个问题的确都会导致数据库压力问题，但是出现的场景还是存在区别滴。在处理手段上也有很大的区别。

缓存雪崩

需要使用的热点数据都做了缓存，但是为了保证Redis的内存够用，所以会对一些数据进行设置过期时间操作。一般情况下存在定时任务去刷新缓存信息，这个时候就存在一个隐患的问题：假设在定时任务中设置的过期时间都一样，那么在某一个时间点时，大量的key同时过期。本来缓存抵挡住了大量的请求，key过期后，这些压力全部同时打到了数据库中，数据库可能就扛不住。直接被打挂了，重启数据库后，立马又被新的流量打挂了。这就是缓存雪崩。
(注：这里还有个隐患，Redis可能会频繁的处理过期key，从而导致Redis性能降低)

处理缓存雪崩主要有以下几个思路：

分散过期时间。把每个key的过期时间都加上一个随机的过期值。保证数据不会在同一时间大面积失效。
设置过期标志更新缓存。给每一个缓存数据都增加一个相应的缓存标记，记录缓存是否失效。如果缓存失效，则更新数据缓存。这样虽然在缓存首次失效时，仍会带来数据库压力问题。但是能够在一定程度上缓解后续被新流量打挂以及所有服务不可用的情况。
在代码层面上设定一定策略，比如加锁等待、减慢请求速度。给数据库留下启动和重建缓存的机会。

缓存穿透

缓存穿透就是指客户端不断的查询缓存和数据库都没有的数据。相当于进行了两次无用的查询。降低缓存的命中率，增加数据库的压力。

解决手段：

客户端进行校验，先将明显不符合的key给过滤掉。
对于查询不到的数据，直接赋值一个null给它。
使用布隆过滤器来对不存在数据进行过滤掉。
限流。

缓存击穿

缓存击穿和缓存雪崩有点像。但是又不一样，缓存雪崩是大面积的缓存同时失效，打崩了DB。而缓存击穿是指一个key非常热点，在不停的扛着大并发，当这个key失效的瞬间，持续的大并发就击穿缓存，直接请求数据库。

解决手段:
主要场景是多个线程同时去查询数据库的这条数据，那么我们可以在第一个查询数据的请求上使用一个互斥锁来锁住它。
其他的线程走到这一步拿不到锁就等着，等第一个线程查询到了数据，然后做缓存。后面的线程进来发现已经有缓存了，就直接走缓存。

Spring boot整合SpringTask实现定时任务

发表于 2019-07-26 | 分类于 Spring Boot

SpringTask是Spring自主研发的一个定时任务工具，不需要引入其他依赖就可以使用。

SpringTask Cron语法

类似于shell中的crontab，只不过最前面多了一个Seconds秒级别。
Seconds Minutes Hours DayofMonth Month DayofWeek

时间元素	可出现的字符	数值范围
Seconds	,-*/	0-59
Minutes	,-*/	0-59
Hours	,-*/	0-23
Day of Month	,-*/?LW	0-31
Month	,-*/	1-12
Day of Week	,-*/?L#	1-7

“,” 列出枚举值
“-“ 触发范围
“*” 任意值
“/“ 每隔一段时间执行
“?” 任意值
“#” 确定第几个星期几
“L” 表示最后的有效值
“W” 表示有效工作日
阅读全文 »

java实现快排

发表于 2019-07-24 | 分类于 Java

算法思想

在数组中选出一个元素做为中枢值，把所有比它小的元素都移动到它的左边，比它大的元素都移动到它的右边。直到数组有序。

递归实现

private static void qSort(int[] a,int left,int right){
    if(left < right){
        int mid = divide(a,left,right);
        qSort(a,left,mid);
        qSort(a,mid+1,right);
    }
}

private static int divide(int[] a,int left,int right){
    int mid = left;

    while(left < right) {
        while (left < right && a[right] >= a[mid]) {
            right--;
        }
        while (left < right && a[left] < a[mid]) {
            left++;
        }
        if (left < right) {
            swap(a, left, right);
        }
    }
    return left;
}

private static void swap(int[] a, int left, int right) {
    int tmp = a[left];
    a[left] = a[right];
    a[right] = tmp;
}

具体流程：

定义两个指针left和right代表两个初始化位置，分别表示需要排序数组的最左和最右。
一直遍历，right向左移动，直到找到小于中枢值的位置。
一直遍历，left向右移动，直到找到大于中枢值的位置。
如果left<right，交换这两个元素。
重复上面步骤。
使用递归再对两边子数组进行排序。

非递归实现

//    非递归实现快排
    private static void qSort2(int[] a,int left,int right){
        Stack<Integer> s = new Stack<>();
        s.push(left);
        s.push(right);

        while(!s.isEmpty()){
            int r = s.pop();
            int l = s.pop();
            int mid = divide(a,l,r);
            if(l < mid){
                s.push(l);
                s.push(mid);
            }
            if(mid + 1 < right){
                s.push(mid+1);
                s.push(right);
            }
        }
    }

对需要排序的数组的左指针和右指针l、r记录起来，压入到栈中，每次循环都会弹出一对l、r。
当栈为空时，说明都已经排序了。接收循环。

Linux命令之sort

发表于 2019-07-23 | 分类于 Linux

Linux自带排序命令：sort
在一些临时性排序需求的时候，使用该命令可以快速的处理。小巧的工具使我们使用非常便捷。
语法：sort [-bcCdfghiRMmnrsuVz] [-k field1[,field2]] [-S memsize] [-T dir] [-t char] [-o output] [file ...]

可选项

-b 忽略每行前面开始出的空格字符。
-c 检查文件是否已经按照顺序排序。
-d 排序时，处理英文字母、数字及空格字符外，忽略其他的字符。
-f 排序时，将小写字母视为大写字母。
-i 排序时，除了040至176之间的ASCII字符外，忽略其他的字符。
-k：以哪个区间 (field) 来进行排序
-m：将几个排序好的文件进行合并，只是单纯合并，不做排序
-M：将前面3个字母依照月份的缩写进行排序
-n：依照数值的大小排序
-o<输出文件>：将排序后的结果存入指定的文件
-r：降序
-R: 乱序
-u：忽略相同行
-t<分隔字符>：指定分隔符，默认的分隔符为空白字符和非空白字符之间的空字符

阅读全文 »