XinYu

Linux启动之后进入死锁的解决方法

Tue, 04 Oct 2022 22:58:21 +0000

Linux开机之后过一会儿自己进入死锁状态，然后CPU……嗯

真是个大坑，掉进去好几个小时，竟然这样解决了……呃呃呃

事情是这样的：

打开VMware，启动三台hadoop，结果开机之后每台都死锁，log如下：

NMI watchdog: BUG: soft lockup -cpu#0 stuck for 22s!

打印上面这句话表示发生了内核软锁死,linux中每个cpu都设置了一个watchdog进程来检测内存软锁的问题，如果进程进入死锁或者进入死循环，watchdog长时间得不到调度，系统检测到进程占用cpu的时间超出特定时间后，便打印此警告。

INFO: rcu_sched detecded stalls on cpus/tasks

打印上面这句话是和RCU相关的,只知道RCU(Read-Copy Update)是Linux引入的一种新的锁机制。

然而各种查文献资料，又是加内存，加CPU核，又是重启，balabala……,然而都无法解决。

最后这样解决了:

把所有关于VMware的服务全部重启了一遍，终于解决！

END…

搭建Nginx高可用集群(keepalived+双机热备)

Wed, 25 May 2022 20:00:01 +0000

一、Nginx高可用

首先了解一下什么是高可用，高可用是分布式系统架构中必须考虑的因素。

我们都知道，使用nginx的反向代理和负载均衡可以解决tomcat等web容器的单点故障以及高并发等问题。

反向代理是指以代理服务器来接收浏览器的请求，然后再将请求转发到内网的服务器，然后再将从服务器上得到的结果返回给客户端。负载均衡就是要解决一个web服务器压力过大的问题，此时可以通过多个web服务器根据不同的算法将并发过来的请求分配到多个服务器上，从而减轻单个服务器压力过大的问题。

这样的话，当一台web服务器挂掉了，还有其他的服务器可以处理客户端的请求，也解决了单点故障问题，这是对web服务器的高可用。

但是，上述架构仍然存在单点故障问题吗，如果这台Nginx挂了，那么所有对外提供的接口都将导致无法访问，所以我们也需要给Nginx配置高可用机制。

可以使用keepalived来实现Nginx的高可用。

二、Nginx双机热备

双机热备方案是目前使用最为普遍的一种高可用方案，双机热备就是指一台服务器整在提供服务，另外一台作为备用状态，当一台服务器挂掉之后另外一台就会代替他继续提供服务。

双机热备主要解决的是Nginx的单点故障问题。

三、LVS负载均衡

再来了解一下LVS，LVS（Linux Vritual Server）即Linux虚拟服务器，他是一个开源的软件，可以实现传输层四层负载均衡，通过 LVS 达到的负载均衡技术可以实现一个高性能高可用的 Linux 服务器集群。

大概流程就是：当客户端发出请求时，会先连接到互联网的DNS服务器，然后解析到LVS负载均衡调度器上，LVS可以帮我们虚拟出来一个IP地址（外网IP），此时客户端用户就会去连接这个虚拟出来的IP，当用户连接到虚拟IP之后LVS会根据指定的调度算法确定具体要连接到哪一台Nginx服务器上。客户端连接到虚拟IP的过程对用户是透明的，而LVS具体连接到哪一台Nginx服务器对用户来说是不知道的。

LVS负载均衡调度器仅仅只是一个调度器，并不是真正的服务。

四、keepalived健康监测

来了解了解为什么要引入keepalived

LVS可以实现负载均衡，但是不能够进行健康检查。意思就是，假如一台Nginx服务器挂掉了，LVS仍然会把客户端的请求发送到这个挂掉了Nginx上（因为LVS并不知道此Nginx挂了），这样就会导致请求无效无法处理客户端的请求。

keepalive 软件可以进行健康检查，所以我们需要使用他来进行监测，而且可以实现Nginx的高可用性，解决Nginx的单点故障问题及LVS不能进行健康检查的问题。

keepalived的工作原理 keepalived是基于VRRP协议实现的保证集群高可用的一个服务软件，主要功能是实现真机的故障隔离和负载均衡器间的失败切换，防止单点故障。VRRP协议保证当主机的下一路由器出现故障时，由另外一台路由器来代替出现故障的路由器进行工作，从而保持网络通信的连续性和可靠性。

VRRP虚拟出来的是路由。

五、开始搭建Nginx高可用集群

1、首先准备两台Nginx服务器，一个作为主服务器MASTER，一个作为备服务器BACKUP，再利用LVS虚拟出来一个IP地址。

#搭建keepalived环境
yum install -y  keepalived
 
#keepalived的启动与停止
service keepalived start
service keepalived stop

2、修改主Nginx服务器keepalived文件：vim /etc/keepalived/keepalived.conf
设置自己的主Nginx服务器的IP地址等信息，我这里是192.168.66.100，虚拟IP设置为192.168.66.99

! Configuration File for keepalived
vrrp_script chk_nginx {
    script "/etc/keepalived/nginx_check.sh" #运行脚本，脚本内容下面有，就是起到一个nginx宕机以后，自动开启服务
    interval 2 #检测时间间隔
    weight -20 #如果条件成立的话，则权重 -20
}
# 定义虚拟路由，VI_1 为虚拟路由的标示符，自己定义名称
vrrp_instance VI_1 {
    state MASTER #来决定主从
    interface ens33 # 绑定虚拟 IP 的网络接口，根据自己的机器填写
    virtual_router_id 121 # 虚拟路由的 ID 号， 两个节点设置必须一样
    mcast_src_ip 192.168.66.100 #填写本机ip
    priority 100 # 节点优先级,主要比从节点优先级高
    nopreempt # 优先级高的设置 nopreempt 解决异常恢复后再次抢占的问题
    advert_int 1 # 组播信息发送间隔，两个节点设置必须一样，默认 1s
    authentication {
        auth_type PASS
        auth_pass 1111
    }
    # 将track_script块加入instance 配置块
    track_script {
        chk_nginx #执行Nginx监控的服务
    }
 
    virtual_ipaddress {
        192.168.66.99 #虚拟ip
    }
}

3、修改从Nginx服务器keepalived文件, vim /etc/keepalived/keepalived.conf

设置自己的从Nginx服务器的IP地址等信息，我这里是192.168.66.101，虚拟IP也设置为192.168.66.99

! Configuration File for keepalived
vrrp_script chk_nginx {
    script "/etc/keepalived/nginx_check.sh" #运行脚本，脚本内容下面有，就是起到一个nginx宕机以后，自动开启服务
    interval 2 #检测时间间隔
    weight -20 #如果条件成立的话，则权重 -20
}
# 定义虚拟路由，VI_1 为虚拟路由的标示符，自己定义名称
vrrp_instance VI_1 {
    state BACKUP #来决定主从
    interface ens33 # 绑定虚拟 IP 的网络接口，根据自己的机器填写
    virtual_router_id 121 # 虚拟路由的 ID 号， 两个节点设置必须一样
    mcast_src_ip 192.168.66.101 #填写本机ip
    priority 100 # 节点优先级,主要比从节点优先级高
    nopreempt # 优先级高的设置 nopreempt 解决异常恢复后再次抢占的问题
    advert_int 1 # 组播信息发送间隔，两个节点设置必须一样，默认 1s
    authentication {
        auth_type PASS
        auth_pass 1111
    }
    # 将 track_script 块加入 instance 配置块
    track_script {
        chk_nginx #执行 Nginx 监控的服务
    }
 
    virtual_ipaddress {
        192.168.66.99 # 虚拟ip
    }
}

4、Nginx+keepalived实现高可用写入脚本：vim /etc/keepalived/nginx_check.sh （两台机器都需要写）

#!/bin/bash
A=`ps -C nginx —no-header |wc -l`
if [ $A -eq 0 ];then
    /usr/local/nginx/sbin/nginx
    sleep 2
    if [ `ps -C nginx --no-header |wc -l` -eq 0 ];then
        killall keepalived
    fi
fi

并对该脚本文件授权：

chmod 777 /etc/keepalived/nginx_check.sh

此时已经配置完成。

在浏览器访问虚拟IP192.168.66.99时即可访问到主Nginx服务器中的服务，即使主Nginx服务器挂了，也会自动连接到从Nginx服务器上，从而保证了Nginx的高可用，当主Nginx恢复正常时，会再次自动连接到主Nginx服务器上继续服务。

END……

缓存雪崩、缓存击穿、缓存穿透的区别及解决方案

Tue, 01 Feb 2022 23:31:01 +0000

一、Redis是什么

Redis（Remote Dictionary Server）是现在最受欢迎的NoSQL数据库之一，是一个基于内存实现的键值型非关系数据库，且开源免费。
（具体使用方法及应用场景不再赘述）

二、缓存雪崩、缓存击穿、缓存穿透的区别及解决方案

使用缓存需要考虑这几个问题

1、缓存雪崩（Cache Avalanche）

当Redis中某时刻发生大面积的缓存失效（即redis中的key过期），那么就会导致大量的用户请求直接打在数据库上面，导致数据库压力剧增。若在高并发场景下，数据库服务瞬间就会挂掉。

原因：

可以发现根本原因是同一时间大规模的key失效，是因为大量的Key在同一时间过期（设置缓存时采用了相同的过期时间，导致缓存在某一时刻同时失效），再就是有可能Redis服务挂掉了。

解决方案：

（1）、过期时间打散：

既然是大量缓存集中失效，那最容易想到就是让他们不集中生效。可以给缓存的过期时间时加上一个随机值时间，使得每个 key 的过期时间分布开来，不会集中在同一时刻失效。

（2）、热点数据不过期：

该方式和缓存击穿一样，也是要着重考虑刷新的时间间隔和数据异常如何处理的情况。

（3）、加互斥锁:

该方式和缓存击穿一样，按 key 维度加锁，对于同一个 key，只允许一个线程去计算，其他线程原地阻塞等待第一个线程的计算结果，然后直接走缓存即可。

（4）、采用熔断机制:

流量到达一定峰值时，直接返回系统繁忙。

java中可以加锁排队：

 public Object GetProductListNew(String cacheKey) {
        int cacheTime = 30;
        String lockKey = cacheKey; 
        // 获取key的缓存
        String cacheValue = jedis.get(cacheKey); 
        // 缓存未失效返回缓存
        if (cacheValue != null) {
            return cacheValue;
        } else { 
            // 枷锁
            synchronized (lockKey) { 
                // 获取key的value值
                cacheValue = jedis.get(cacheKey);
                if (cacheValue != null) {
                    return cacheValue;
                } else { 
                    // 这里一般是sql查询数据 
                    // db.set(key) 
                    // 添加缓存
                    jedis.set(cacheKey, "");
                }
            }
            return cacheValue;
        }
    }

2、缓存击穿（Cache Breakdown）

某一个热点 Key在缓存过期的一瞬间,同时有大量的请求打进来，由于此时缓存过期了，所以请求最终都会走到数据库，造成数据库压力瞬间剧增，极有可能可能使数据库服务挂掉。

解决方案：

和缓存雪崩类似，缓存雪崩是大规模的key失效，而缓存击穿是一个热点的Key失效。

（1）、互斥锁：

在并发的多个请求中，只有第一个请求线程能拿到锁并执行数据库查询操作，其他的线程拿不到锁就阻塞等着，等到第一个线程将数据写入缓存后，其他线程直接查询缓存。

（2）、热点数据不过期：

直接将缓存设置为不过期，然后由定时任务去异步加载数据，更新缓存。

java中的代码实现：

public String get(String key) throws InterruptedException {
        String value = jedis.get(key);
        // 缓存过期
        if (value == null) {
            // 设置3分钟超时，防止删除操作失败的时候 下一次缓存不能load db
            Long setnx = jedis.setnx(key + "mutex", "1");
            jedis.pexpire(key + "mutex", 3 * 60);
            // 代表设置成功
            if (setnx == 1) {
                // 数据库查询
                // value = db.get(key);
                // 保存缓存
                jedis.setex(key, 3 * 60, "");
                jedis.del(key + "mutex");
                return value;
            } else {
                // 这个时候代表同时操作的其他线程已经load db并设置缓存了。 需要重新重新获取缓存
                Thread.sleep(50);
                // 重试
                return get(key);
            }
        } else {
            return value;
        }
    }

3、缓存穿透（Cache Penetration）

缓存穿透是指缓存和数据库中都没有的数据查询一个一定不存在的数据，而用户不断发起请求，比如发起的请求都不合理，每次请求都会到数据库。这时的用户很可能是攻击者，攻击会导致数据库压力过大。

分析：

用户查询数据，在数据库没有，自然在缓存中也不会有。这样就导致用户查询的时候，在缓存中找不到，每次都要去数据库再查询一遍，然后返回空（相当于进行了两次无用的查询）。这样请求就绕过缓存直接查数据库，这也是经常提的缓存命中率问题。

解决方案：

（1）、对空值缓存：

如果一个查询返回的数据为空（不管数据是否存在），我们仍然把这个空结果缓存，设置空结果的过期时间会很短，最长不超过5分钟。（存在一定问题）

（2）、布隆过滤器：

如果想判断一个元素是不是在一个集合里，一般想到的是将集合中所有元素保存起来，然后通过比较确定。
布隆过滤器是一种数据结构，可以高效的插入和查询。

java中的代码实现：

<dependency> 
    <groupId>cn.hutool</groupId> 
    <artifactId>hutool-all</artifactId> 
    <version>5.7.17</version> 
</dependency>

// 构造方法的参数10决定了布隆过滤器BitMap的大小 
public void bulong{
    BitMapBloomFilter filter = new BitMapBloomFilter(10); 
    filter.add("123"); 
    filter.add("abc"); 
    filter.add("ddd"); 
    boolean abc = filter.contains("abc");
    System.out.println(abc);
}

日常开发中使用Redis一定要考虑周到,不过Redis在众多NoSQL中还是非常好用的

END…

Web漏洞挖掘——SQL注入

Sat, 15 Jan 2022 23:23:56 +0000

一、记录一下SQL注入

哈哈，SQL注入攻击好像挺流行的，用大白话解释一下，SQL注入就是利用有些系统没有对用户输入的数据进行充分的检查这一漏洞，在用户输入数据中注入非法的SQL语句片段或者命令，从而利用系统的SQL引擎做出恶意行为的做法。

下面贴一个栗子：

使用Statement实现查询操作：

public static List<Account> queryAccounts(String sql) throws Exception {
        List<Account> accounts = new ArrayList<>();
        Connection conn = JDBCUtils.getConnection();
        Statement statement = conn.createStatement();
        // 执行查询操作
        ResultSet rs = statement.executeQuery(sql);
        // 获取元数据
        ResultSetMetaData rsmd = rs.getMetaData();
        // 获取列数
        while (rs.next()) {
            // 将每一行数据通过反射方式赋给Account对象（成员变量）
            Account account = new Account();
            // 通过反射赋值，先将所有的列拿出来
            for (int i = 0; i < rsmd.getColumnCount(); i++) {
                // 再根据列的索引来获取每一列的值
                Object columnValue = rs.getObject(i + 1);
                String columnName = rsmd.getColumnName(i + 1);
                // 获取Account的属性信息
                Field f = account.getClass().getDeclaredField(columnName);
                // 提升权限
                f.setAccessible(true);
                // 注入列值
                f.set(account, columnValue);
            }
            accounts.add(account);
        }
        rs.close();
        JDBCUtils.close(conn, statement);
        return accounts;
    }

执行用户登录的代码：

public static boolean login(Map<String, String> userLoginInfo) throws Exception {
        // 定义sql，拼接参数
        String sql = "select * from account where useraccount='" + userLoginInfo.get("account")
                + "' and userpassword = '" + userLoginInfo.get("password") + "'";
        List<Account> accounts = queryAccounts(sql);
        if (accounts.size() == 0) {
            return false;
        }
        return true;
    }

此时登录输入用户名和密码：

以上输入的账号和密码，通过SQL拼接，在执行过程中的SQL实际上是：

select * from account where useraccount = 'username' and userpassword = 'password' or '1=1'

由于1=1永远成立，所以不管账号密码是否正确，都会返回登陆成功。

二、导致SQL注入的根本原因

可以发现，用户输入的信息中包含SQL语句的关键字，且这些关键字参与了SQL语句的编译过程，导致SQL语句的原意更改，从而达到SQL注入的目的。

三、SQL注入解决方案

只要用户提供的信息不参与SQL语句的编译过程，即使用户提供的信息中包含SQL语句的关键字，但是没有参与编译，所以不会起作用。使用预编译，PreparedStatement可以将信息参数化。

使用PreparedStatement实现查询操作：

public static List<Account> queryAccounts(String sql, Object... args) throws Exception {
        List<Account> accounts = new ArrayList<>();
        Connection conn = JDBCUtils.getConnection();
        PreparedStatement ps = conn.prepareStatement(sql);
        // 预处理之后对sql语句中的占位符进行替换
        for (int i = 0; i < args.length; i++) {
            ps.setObject(i + 1, args[i]);
        }
        // 执行查询操作
        ResultSet rs = ps.executeQuery();
        // 获取元数据
        ResultSetMetaData rsmd = rs.getMetaData();
        // 获取列数
        while (rs.next()) {
            // 将每一行数据通过反射方式赋给Account对象（成员变量）
            Account account = new Account();
            // 通过反射赋值，先将所有的列拿出来
            for (int i = 0; i < rsmd.getColumnCount(); i++) {
                // 再根据列的索引来获取每一列的值
                Object columnValue = rs.getObject(i + 1);
                String columnName = rsmd.getColumnName(i + 1);
                // 获取Account的属性信息
                Field f = account.getClass().getDeclaredField(columnName);
                // 提升权限
                f.setAccessible(true);
                // 注入列值
                f.set(account, columnValue);
            }
            accounts.add(account);
        }
        return accounts;
    }

执行用户登录的代码：

public static boolean login(Map<String, String> userLoginInfo) throws Exception {
        String sql = "select * from account where useraccount=? and userpassword = ?";
        List<Account> accounts = queryAccounts(sql, userLoginInfo.get("account"), userLoginInfo.get("password"));
        if (accounts.size() == 0) {
            return false;
        }
        return true;
    }

此时登录输入用户名和密码：

以上输入的账号和密码，通过PreparedStatement预编译，将password’or’1=1作为一个整体的字符串参数设置到SQL当中，在执行过程中的SQL实际上是：

select * from account where useraccount = 'zhangsan' and userpassword = "password'or'1=1"

Prestatement 和statement的区别？
Prestatement 对批量处理可以提高效率，statement 每次执行SQL语句都要进行编译

四、参数预编译方式防止sql注入的原理

在使用参数化查询的情况下，数据库系统不会将参数的内容视为SQL指令的一部分处理，而是在数据库完成SQL指令的编译后才加上参数运行，因此就算参数中含有破坏性的指令，也不会被数据库所运行。

对于参数化查询来说，SQL语句的格式是已经规定好了，用户能提供的只是数据，而且只能按照需求提供，无法进一步做出影响数据库的其他操作。

五、Web开发中mybatis框架环境下最容易出现sql注入的场景

1、模糊查询

通过采用预编译机制，避免SQL语句拼接的问题，防止SQL注入漏洞产生。

2、order by之后的参数

3、其他的有待研究

六、在开发阶段避免SQL注入

参数预编译、用正则表达式过滤传入的参数。

此处可以渗透？？（没研究明白，以后再说吧）

用SQL注入漏洞扫描工具。

先会攻击、后会防御 -_-

END…

C++实现快速排序

Wed, 22 Dec 2021 23:54:10 +0000

概述：

快速排序是对冒泡排序的一种改进。基本思想是：通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

首先用数组的第一个数作为枢轴，然后将所有比它小的数都放到它的位置之前，所有比它大的数都放到它的位置之后，由此可以该“枢轴“记录最后所落的位置i作为分界线，将序列分割成两个子序列。这个过程称为一趟快速排序。

一趟快速排序的算法是：

设置两个变量i、j，排序开始的时候：令i=0，j=length-1；

以第一个数组元素作为枢轴，赋值给key，即key=array[0]；

从j开始向前扫描，找到第一个小于key的值array[j]，将array[j]和array[i]的值交换；

从i开始向后扫描，找到第一个大于key的值array[i]，将array[i]和array[j]的值交换；

重复第3、4步，直到i==j，将枢轴元素移到正确位置上，即将key赋值给array[i]。

时间复杂度：通常，快速排序被认为是，在所有同数量级(O(nlogn))的排序方法中，其平均性能最好。但是，若初始记录序列按关键字有序或基本有序时，快速排序将蜕化为冒泡排序，其时间复杂度为O(n²)。

最坏：O(n²)

最好和平均：O(nlogn)

代码如下：

//快速排序
#include <iostream> 
using namespace std;
void QuickSort(int *array,int low,int high){	//快排 
	if(low>=high){	//若待排序序列只有一个元素，返回空 
		return ;
	}
	int i=low;	//i作为指针从左向右扫描 
	int j=high;	//j作为指针从右向左扫描
	int key=array[low];//第一个数作为基准数 
	while(i<j){
		while(array[j]>=key&&i<j){	//从右边找小于基准数的元素 （此处由于j值可能会变，所以仍需判断i是否小于j） 
			j--;	//找不到则j减一 
		}
		array[i]=array[j];	//找到则赋值 
		while(array[i]<=key&&i<j){	//从左边找大于基准数的元素 
			i++;	//找不到则i加一 
		}
		array[j]=array[i];	//找到则赋值 
	}
	array[i]=key;	//当i和j相遇，将基准元素赋值到指针i处 
	QuickSort(array,low,i-1);	//i左边的序列继续递归调用快排 
	QuickSort(array,i+1,high);	//i右边的序列继续递归调用快排 
}
int main(){
	int array[]={49,38,65,97,76,13,27,49};
	int length=sizeof(array)/sizeof(*array);
	cout<<"原始序列：";
	for(int i=0;i<length;i++){
		cout<<array[i]<<" ";
	}
	cout<<endl;
	QuickSort(array,0,length-1);
	cout<<"快排序列：";
	for(int i=0;i<length;i++){
		cout<<array[i]<<" ";
	}
	return 0;
}

XinYu

Linux启动之后进入死锁的解决方法

Linux开机之后过一会儿自己进入死锁状态，然后CPU……嗯

事情是这样的：

然而各种查文献资料，又是加内存，加CPU核，又是重启，balabala……,然而都无法解决。

最后这样解决了:

搭建Nginx高可用集群(keepalived+双机热备)

一、Nginx高可用

二、Nginx双机热备

三、LVS负载均衡

四、keepalived健康监测

五、开始搭建Nginx高可用集群

缓存雪崩、缓存击穿、缓存穿透的区别及解决方案

一、Redis是什么

二、缓存雪崩、缓存击穿、缓存穿透的区别及解决方案

1、缓存雪崩（Cache Avalanche）

原因：

解决方案：

（1）、过期时间打散：

（2）、热点数据不过期：

（3）、加互斥锁:

（4）、采用熔断机制:

2、缓存击穿（Cache Breakdown）

解决方案：

（1）、 互斥锁：

（2）、 热点数据不过期：

3、缓存穿透（Cache Penetration）

分析：

解决方案：

（1）、对空值缓存：

（2）、布隆过滤器：

Web漏洞挖掘——SQL注入

一、记录一下SQL注入

下面贴一个栗子：

二、导致SQL注入的根本原因

三、SQL注入解决方案

四、参数预编译方式防止sql注入的原理

五、Web开发中mybatis框架环境下最容易出现sql注入的场景

1、模糊查询

2、order by之后的参数

3、其他的有待研究

六、在开发阶段避免SQL注入

C++实现快速排序

概述：

代码如下：

运行截图如下：

参考我的博客地址： 点一下这里，嘻嘻……

（1）、互斥锁：

（2）、热点数据不过期：

参考我的博客地址：点一下这里，嘻嘻……