fyupeng

利用OpenResty统计网站访问量

2026-03-05T07:34:18.000Z

系列运维文章目录

作者：fyupeng
技术专栏：☞ https://github.com/fyupeng
项目地址：☞ https://github.com/fyupeng/distributed-blog-system-api
访问量预览项目效果：☞ https://www.fyupeng.cn/detail?name=home&articleId=250904CN0FMKT0X4

效果图：

前言

例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。

一、openresty是什么？

OpenResty 是一个基于 Nginx 与 Lua 的高性能 Web 平台，集成了大量精良的 Lua 库、第三方模块及常用工具。其核心是通过 LuaJIT 即时编译器扩展 Nginx 的能力，使开发者能够用 Lua 脚本编写高性能的 Web 应用、网关和动态流量处理逻辑。

1.核心特点

高性能： 基于 Nginx 的事件驱动架构和 LuaJIT 的高效执行，适合高并发场景。
动态能力： 通过 Lua 脚本实现动态路由、认证、日志处理等逻辑，无需重启服务。
丰富生态： 内置 Lua-resty 系列库（如 HTTP 客户端、Redis/MySQL 驱动），支持自定义模块开发。
灵活扩展： 兼容 Nginx 原生配置，可直接复用现有 Nginx 插件。

2.典型应用场景

API 网关： 实现鉴权、限流、请求转发等逻辑。
动态 CDN： 通过 Lua 脚本实时调整缓存策略或内容改写。
微服务入口： 聚合后端服务响应，减少客户端请求次数。
实时监控： 在流量层嵌入日志采集或性能分析脚本。

3.基础示例

以下是一个简单的 Lua 脚本示例，用于在 Nginx 中返回动态内容：

location /hello {  
    default_type 'text/plain';  
    content_by_lua_block {  
        ngx.say("Hello, OpenResty!")  
    }  
}

4.学习资源

官方文档：https://openresty.org/
GitHub 仓库：https://github.com/openresty/openresty
书籍：《OpenResty 最佳实践》

OpenResty 适用于需要兼顾性能与灵活性的中间层开发，尤其适合替代传统编程语言实现的网关或代理服务。

二、使用步骤

1.脚本编写

ip_counter.lua 文件内容如下：

local shell   = require "resty.shell"
local log     = "/usr/local/nginx/logs/access.log"

--[[ 把数字月 → 英文缩写 ]]
local enMonth = {
    "Jan","Feb","Mar","Apr","May","Jun",
    "Jul","Aug","Sep","Oct","Nov","Dec"
}

--[[ 根据传入 date 返回 grep 要用的正则串 及 实际查询范围 ]]
local function build_grep_pat(date)
    -- 1) 完整日期  2025-03-15
    local y,m,d = date:match("^(%d%d%d%d)%-(%d%d)%-(%d%d)$")
    if y then
        return ("%s/%s/%s"):format(d, enMonth[tonumber(m)], y),  "day"
    end
    -- 2) 只有年月  2025-03
    y,m = date:match("^(%d%d%d%d)%-(%d%d)$")
    if y then
        return ("%s/%s"):format(enMonth[tonumber(m)], y), "month"
    end
    -- 3) 只有年  2025
    y = date:match("^(%d%d%d%d)$")
    if y then
        -- 构造  Jan/2025|Feb/2025|...|Dec/2025
        local t = {}
        for _, mon in ipairs(enMonth) do
            t[#t+1] = mon.."/"..y
        end
        return table.concat(t,"|"), "year"
    end
    return nil,"invalid format"
end

--[[ 统计函数 ]]
local function count_ip(date)
    local pat,range = build_grep_pat(date)
    if not pat then return nil,range end

    local cmd
    if range == "year" then
        -- 一整年：egrep  "Jan/2025|Feb/2025|...|Dec/2025"
        cmd = ('egrep "%s" %s | awk "{print \\$1}" | sort -u | wc -l'):format(pat, log)
    else
        -- 一个月或一天
        cmd = ('grep "%s" %s | awk "{print \\$1}" | sort -u | wc -l'):format(pat, log)
    end

    local ok,out,err = shell.run(cmd, nil, 5000)
    if not ok then return nil,err or "shell error" end
    return tonumber(out:match("%d+"))
end

---------------- 入口 ----------------
local date = ngx.var.arg_date
if not date then
    ngx.status=400
    ngx.say('{"msg":"missing ?date=YYYY[-MM][-DD]"}')
    return
end

local n,err = count_ip(date)
if not n then
    ngx.status=500
    ngx.say(('{"msg":"%s"}'):format(err))
    return
end

ngx.header.content_type = "application/json"
ngx.say(('{"date":"%s","ipCount":%d}'):format(date, n))

2.代理配置

nginx.conf 文件内容如下：

server {
        listen       9999;
        server_name  localhost;

        #charset koi8-r;

        #access_log  logs/host.access.log  main;

        location / {
            root   html;
            index  index.html index.htm;
        }

        # 示例：使用OpenResty的Lua模块处理请求

        location /hello {
            default_type 'text/plain';
            content_by_lua_block {
                ngx.say("Hello, OpenResty!")
            }
        }


        # 统计 ip 数量
        location /ipCount {
             content_by_lua_file  /usr/local/openresty/nginx/lua/ip_counter.lua;
        }

3.启动程序

3.1启动OpenResty服务

1	openresty -p /usr/local/openresty/nginx -c conf/nginx.conf

3.2验证配置

1	openresty -t -p /usr/local/openresty/nginx -c conf/nginx.conf

3.3热重载配置不中断服务

1	openresty -s reload -p /usr/local/openresty/nginx

3.4接口调试

浏览器或postman调用接口 http://localhost:9999/ipCount?date=${YYYY[-MM][-DD]}

例如：

date=2025
date=2025-12
date=2025-12-01

总结

共同学习，与君共勉！

ES索引重建（零工具纯脚本执行）

2026-03-05T07:31:18.000Z

作者：fyupeng
技术专栏：☞ https://github.com/fyupeng
项目地址：☞ https://github.com/fyupeng/distributed-blog-system-api
项目预览地址：☞ 预览

在日常开发与业务迭代过程中，索引结构的调整是 Elasticsearch 应用场景中非常常见的需求 —— 随着业务需求的更新（比如字段新增 / 类型调整、分词规则优化、数据结构适配业务逻辑变更等），原有 ES 索引的 Mapping/Settings 配置往往无法满足新的业务诉求。而 ES 本身不支持直接修改已创建索引的核心配置（如字段类型、分词器），因此索引重建就成为解决这类问题的核心方案。

回归正题，索引重建主要包括这几步：
数据备份与迁移、旧索引清理与新索引重建、数据回迁与验证和业务切换。这里为了方便，业务切换采取的服务重启自动重建索引。

第一步：拷贝源索引上的数据到临时索引上

curl -XPOST "http://localhost:9200/_reindex" -H "Content-Type: application/json; charset=UTF-8" -d "{\"source\":{\"index\":\"scs-ckp-task-2026\"},\"dest\":{\"index\":\"scs-ckp-task-2026-copy\"},\"max_docs\":100000}"

第二步：验证临时索引是否创建，数据是否与原数据一致

1 2	# 原索引数据计数 curl -XGET "http://localhost:9200/scs-ckp-task-2026/_count"

1
2
3

# 临时索引数据计数
curl -XGET "http://localhost:9200/scs-ckp-task-2026-copy/_count"
# 返回成功结果示例：{"count":28675,"_shards":{"total":1,"successful":1,"skipped":0,"failed":0}}

第三步：删除原索引（谨慎操作，临时索引要保留，为了重建索引）

1 2	curl -XDELETE "http://localhost:9200/scs-ckp-task-2026" # 返回成功结果示例： {"acknowledged":true}

第四步：波塞冬重新部署 SCS 服务

1
2
3

# 保证执行以下命令能查询出结果
curl -XGET "http://localhost:9200/scs-ckp-task-2026/_count"
# 返回成功结果示例：{"count":0,"_shards":{"total":3,"successful":3,"skipped":0,"failed":0}}

第五步：临时索引把数据重新复制回新索引

curl -XPOST "http://localhost:9200/_reindex" -H "Content-Type: application/json; charset=UTF-8" -d "{\"source\":{\"index\":\"scs-ckp-task-2026-copy\"},\"dest\":{\"index\":\"scs-ckp-task-2026\"},\"max_docs\":100000}"

使用EasyExcel自定义导出表格

2026-03-05T07:29:18.000Z

一、介绍

作者：fyupeng
技术专栏：☞ https://github.com/fyupeng
分布式博客项目地址：☞ https://github.com/fyupeng/distributed-blog-system-api

留给读者

工作中难免会遇到数据导出的问题，最简单的解决方案就是引入阿里的EasyExcel来解决。

二、代码

实体类

@Data
public class Person {


    @ExcelProperty(value = "序号", index = 0)
    private String seqNumber;

    @ExcelProperty(value = "名称", index = 1)
    private String name;

    @ExcelProperty(value = "爱好", index = 2)
    private String hobby;

}

实现代码

private final static DateTimeFormatter DATE_TIME_FORMAT = DateTimeFormatter.ofPattern("yyyy-MM-dd");


   public static void export(HttpServletRequest request, HttpServletResponse response) throws IOException {

      Person person = new Person();
      person.setName("小明");
      person.setHobby("苹果");
      List list = new ArrayList<>();
      list.add(person);

      String fileName = "人.xlsx";
      
      SXSSFWorkbook sheets = exportExcel(list);
      response.setContentType("application/octet-stream;charset=UTF8");
      response.setHeader("Content-Type", "application/vnd.ms-excel");
      fileName = URLEncoder.encode(fileName, "UTF-8") + DATE_TIME_FORMAT.format(LocalDate.now());
      response.setHeader("Content-Disposition", "attachment;filename=" + fileName + ".xlsx");
      response.addHeader("Cache-Control", "no-cache");
      OutputStream out = response.getOutputStream();
      sheets.write(out);
      out.flush();
      out.close();

   }

   private static SXSSFWorkbook exportExcel(List moduleList) {
      // 标题
      String[] title = {"序号", "名称", "爱好"};
      // 创建一个工作薄
      SXSSFWorkbook workbook = new SXSSFWorkbook();
      // 创建一个工作表 sheet
      SXSSFSheet sheet1 = workbook.createSheet("Sheet1");
      // 创建第二行
      Row row = sheet1.createRow(1);
      // 创建单元格
      Cell cell = null;
      // 创建表头
      for (int i = 0; i < title.length; i++) {
         cell = row.createCell(i);
         // 设置样式
         CellStyle cellStype = workbook.createCellStyle();
         cellStype.setAlignment(HorizontalAlignment.CENTER); // 设置字体居中
         // 设置字体
         Font font = workbook.createFont();
         font.setFontHeightInPoints((short) 13);
         cellStype.setFont(font);
         cell.setCellStyle(cellStype);
         cell.setCellValue(title[i]);
      }
      // 从第三行开始追加数据
      for (int i = 2; i < (moduleList.size() + 2); i++) {
         // 创建第i行
         Row nextRow = sheet1.createRow(i);
         for (int j = 0; j < 3; j++) {
            Person person = moduleList.get(i - 2);
            Cell cell2 = nextRow.createCell(j);
            if (j == 0) {
               cell2.setCellValue(String.valueOf(i - 1));
            } else if (j == 1) {
               cell2.setCellValue(person.getName());
            } else if (j == 2) {
               cell2.setCellValue(person.getHobby());
            }
         }
      }
      return workbook;
   }

展示效果

三、总结

生活总能给你带来惊喜，工作中总结未尝不是？

使用EasyExcel导出明细数据

2026-03-05T07:12:18.000Z

作者：fyupeng
技术专栏：☞ https://github.com/fyupeng
分布式博客项目地址：☞ https://github.com/fyupeng/distributed-blog-system-api

留给读者

工作中难免会遇到数据导出的问题，最简单的解决方案就是引入阿里的EasyExcel来解决。

一、介绍

EasyExcel是alibaba开源的一个Excel工具，容易上手，基本能够满足企业的需求。

<dependency>
    <groupId>com.alibabagroupId>
    <artifactId>easyexcelartifactId>
    <version>2.2.6version>
dependency>

二、代码

1. 实体注解

@NoArgsConstructor
@AllArgsConstructor
@ToString
@Data
@Builder(toBuilder = true)
public class Entity implements Serializable {
// 导出value对应表格头，index对应排序（从0下标开始）
@ExcelProperties(value = "编码", index = 0)
private String code;

@ExcelProperties(value = "名称", index = 1)
private String name;
}

2. 核心代码

public void export(HttpServletRequest request, HttpServletResponse response) {
String fileName = "导出明细.xlsx";
OutputStream out = null;
try {
response.setContentType("application/octet-stream;charset=UTF-8");
response.setHeader("Content-Type", "application/vnd.ms-excel");
fileName = URLEncoder.encode(fileName, "UTF-8");
response.setHeader("Content-Disposition", "attachment;filename=", fileName);
response.addHeader("Cache-Control", "no-cache");
out = response.getOutputStream();

// 创建 Exce 文件写入流
ExcelWriter excelWriter = EasyExcel.write(out).build();

// 新增 Sheet 表格
WriteSheet sheet = EasyExcel.writeSheet(0, "基本信息").head(Entity.class).build();
List list = new ArrayList<>();
excelWriter.write(list, sheet);

// 关闭 excel 写入流
excelWriter.finish();
// 内存刷入响应流并清空内存
response.flushBuffer();
} catch (IOException e) {
throw new Exception("明细导出失败！");
}
}

三、总结

每日总结归档，学习会遗忘，但学习后总结不会，它能让你变得越来越强！

nacos一键启动、停止、查看状态脚本

2023-02-28T02:17:50.000Z

一、直接给代码

1. start.sh

使用方法

[root@localhost] #ls
nacos
./start.sh ./nacos -m standalone # 单机模式
./start.sh ./nacos -m cluster # 集群模式

代码

#!/bin/bash

function read_dir() {
  for file in `ls $1`
  do
    if [[ -d $1"/"$file ]];
      then
        read_dir $1"/"$file $2 $3
    else
      if [[ -f $1"/"$file ]] && [[ "$file" = startup.sh ]];
        then
          cd ./$1
          if [[ "$2" = "-m" ]];
    then
      if [[ "$3" = "standalone" ]];
        then
          ./startup.sh -m standalone > /dev/null
          echo $1$file 单机模式启动成功！
  cd - > /dev/null
      elif [[ "$3" = "cluster" ]];
        then
          ./startup.sh -m cluster > /dev/null
           echo $1$file 集群模式启动成功！
  cd - > /dev/null
      else
        echo "1adUsage: ./startup.sh [Directory] -m [standalone | cluster]"
      fi
  else
    echo "2Usage: ./startup.sh [Directory] -m [standalone | cluster]"
    exit -1;
          fi
      fi
    fi
  done
}

# 读取第一个参数
read_dir $1 $2 $3

2. status.sh

使用方法

[root@localhost] #ls
nacos
./status.sh ./nacos -m standalone # 单机模式
./status.sh ./nacos -m cluster # 集群模式

代码

#!/bin/bash

target_dir=$1

if [[ "$target_dir" = "" ]] || [[ ! -d $target_dir ]];
then
  echo "Usage: ./status.sh [Dir]"
fi

pid=`ps ax | grep -i 'nacos.nacos' | grep ${target_dir} | grep java | grep -v grep | awk '{print $1}'`

if [[ -z "$pid" ]];
then
  echo "No NacosServer running."
 exit -1;
fi

echo "The nacosServer $1"nacos-server.jar"  is running, it's pids as follow:"
echo "$pid"

3.stop.sh

使用方法

[root@localhost] #ls
nacos
./status.sh ./nacos -m standalone # 单机模式
./status.sh ./nacos -m cluster # 集群模式

代码

#!/bin/bash

target_dir=$1

pid=`ps ax | grep -i 'nacos.nacos' | grep ${target_dir} | grep java | grep -v grep | awk '{print $1}'`
if [ -z "$pid" ] ; then
        echo "No nacosServer running."
        exit -1;
fi

echo "The nacosServer $1"nacos-server.jar"  is running, it's pids as follow:"
echo  "$pid"

kill ${pid}

echo "Services stop successfully！ which has been killed forcibly!"
echo pid as follow: 
echo "$pid"

二、结束语

评论区可留言，可私信，可互相交流学习，共同进步，小生会努力写出优质文章，期待同友多多回访。

专注品质，热爱生活。
交流技术，寻求同志。

vue一键启动、停止、查看状态实用工具

2023-02-01T04:07:59.000Z

一、直接给代码

1. start.sh

#!/bin/bash
function read_dir() {
if [ $# -eq 0 ]
then
echo "Usage: $0 [DirFile]"
exit 1
fi

echo "Service is starting...." 


cd ./$1
mkdir logs/ &> /dev/null &
nohup npm run serve >& logs/catalina-$(date +%Y-%m-%d).log &

echo "Service starting succuesful!"
}

read_dir $1

2. stop.sh

# !/bin/bash

function read_dir() {
if [ $# -eq 0 ]
then
echo "Usage: $0 [DirFile]"
exit 1
fi

echo "Service is stop...."

if [[ -f $1 ]]
then
echo "$1 is not a DirFile!"
exit 1
fi

pid=`ps -ef | grep $1 | grep -v grep | awk '{print $2}'`
if [ -z $pid ]; then
echo ""
echo "Service $1 is not running! It's not necessary to stop it!"
echo ""
else
kill -9 $pid
echo ""
echo "Servuce stop successfuly! pid:${pid} which has been killid forcibly!"
echo ""
fi
}

read_dir $1

3.status.sh

# !/bin/bash

function read_dir() {
if [ $# -eq 0 ]
then
echo "Usage: $0 [DirFile]"
exit 1
fi

if [[ -f $1 ]]
then
echo "$1 is not a DirFile!"
exit 1
fi

pid=`ps -ef | grep $1 | grep -v grep | awk '{print $2}'`
if [ -z $pid ]; then
echo ""
echo "Service $1 is not running!"
echo ""
else
echo ""
echo "Servuce $1 is running. It's pids=${pid}"
echo ""
fi
}

read_dir $1

二、结束语

评论区可留言，可私信，可互相交流学习，共同进步，欢迎各位给出意见或评价，本人致力于做到优质文章，希望能有幸拜读各位的建议！

专注品质，热爱生活。
交流技术，寻求同志。
—— 嗝屁小孩纸 QQ：1160886967

jar包批量启动、查看状态、关闭脚本

2023-02-01T03:55:30.000Z

一、直接给代码

1. start.sh

#!/usr/bin/env bash
  
# 配置文件名称
# (该配置文件放置在jar包同级目录下并且必须存在已经配置文件名称具备统一性！！！请根据实际的配置文件名称进行修改)
CONFIG_FILE_NAME="application.properties"

# 启动一个目录下的所有jar包
function read_dir(){
for file in `ls $1`
do
  #如果当前文件是文件夹则递归处理
  if [ -d $1"/"$file ];
  then
    read_dir $1"/"$file
  else
    # 当前文件不是一个文件夹
    if [[ -f $1"/"$file ]];
    then
        # 如果当前文件是一个.jar结尾的文件则启动它
        if [[ ${file:0-4} == '.jar' ]];
        then
  echo $1/$file 开始启动...
          cd ./$1
          #nohup java -jar $1"/"$file --spring.config.location=$1"/"$CONFIG_FILE_NAME > /dev/null &
   if [[ ! -d "./logs/" ]];
  then  
          mkdir "./logs" > /dev/nul
  fi
      nohup java -jar -Dlogging.config="./config/logback.xml" "./"$file > "./logs/catalina.log" &
     #nohup java -jar ./$file > ./logs/catalina.log &
            echo $1"/"$file  启动成功!
    echo ""
            cd - > /dev/null
        fi
    fi
  fi
done
}
#读取第一个参数
read_dir $1

2. status.sh

#!/usr/bin/env bash
# 查看某个目录下所有jar程序的状态
function read_dir(){
for file in `ls $1`
do
  #如果当前文件是文件夹则递归处理
  if [ -d $1"/"$file ]
  then
    read_dir $1"/"$file
  else
    # 当前文件不是一个文件夹
    if [[ -f $1"/"$file ]]
    then
        if [[ ${file:0-4} == '.jar' ]];
        then
            # 获取pid
                pid=`ps -ef | grep $file | grep -v grep | awk '{print $2}'`
            # -z 表示如果$pid为空时则输出提示
                if [ -z $pid ];then
                        echo ""
                echo "Service $file is not running!"
                        echo ""
                else
                        echo ""
                echo "Service $1"/"$file is running. It's pids=${pid}"
                        echo ""
                fi
        fi
    fi
  fi
done
}
#读取第一个参数
read_dir $1

3.stop.sh

#!/usr/bin/env bash
# 停止一个目录下的所有jar程序
function read_dir(){
for file in `ls $1`
do
  #如果当前文件是文件夹则递归处理
  if [ -d $1"/"$file ]
  then
    read_dir $1"/"$file
  else
    # 当前文件不是一个文件夹
    if [[ -f $1"/"$file ]]
    then
        if [[ ${file:0-4} == '.jar' ]];
        then
            # 获取pid
            # 模糊匹配 $file 进程| 过滤自身命令进程 | 输出进程表中的进程号
                pid=`ps -ef | grep $file | grep -v grep | awk '{print $2}'`
            # -z 表示如果$pid为空时则输出提示
                if [ -z $pid ]; then
                echo "Service $file is not running! It's not necessary to stop it!"
                else
                # 杀死进程
                        kill -9 $pid
                        echo "Service stop successfully！pid:${pid} which has been killed forcibly!"
echo ""
                fi
        fi
    fi
  fi
done
}
#读取第一个参数
read_dir $1

二、结束语

评论区可留言，可私信，可互相交流学习，共同进步，欢迎各位给出意见或评价，本人致力于做到优质文章，希望能有幸拜读各位的建议！

专注品质，热爱生活。
交流技术，寻求同志。

宕机检测、重启、告警开发工具

2023-02-01T03:55:08.000Z

一、直接给代码

1. keepalived.conf

安装详见 keepalived安装教程
配置前请备份好原文件，新建文件夹/etc/keepalived并将副本keepalived.conf复制到/etc/keepalived即可。

!Configuration File for keepalived
global_defs {
        router_id master
        notification_email {
          ******@163.com  
        }
        notification_email_from ******@126.com
        smtp_server 127.0.0.1
        smtp_connect_timeout 30
}

vrrp_script chk_http_port {
        # 脚本检测工具，见 3.nginx_check.sh
        script "/usr/local/src/nginx_check.sh"
        interval 2 #（检测脚本执行的间隔）
        weight -20
}

vrrp_instance VI_1 {
        state MASTER # 备份服务器上将 MASTER 改为 BACKUP
        ## 具体网卡请 键入命令 ip a 查看有哪些来进行配置
        interface eth0 //网卡
        virtual_router_id 1 # 主、备机的 virtual_router_id 必须相同
        priority 100 # 主、备机取不同的优先级，主机值较大，备份机值较小
        advert_int 1

        authentication {
                auth_type PASS
                auth_pass root123
        }

        track_script{ # 这里调用检测脚本执行，一秒检测一次
               chk_http_port
        }

        # 根据 内网子网 设置虚拟地址，用于转发，keepalived集群不在此章节
        virtual_ipaddress {
                192.168.0.100/24 dev eth0 label eth0:1
        }

        #配置keepalived发生故障转移时，触发执行的脚本
        notify_master "/etc/keepalived/notify.sh master "
        notify_backup "/etc/keepalived/notify.sh backup "
        notify_fault  "/etc/keepalived/notify.sh fault "

}

2. notify.sh

#!/bin/bash
#接收者邮箱，多个以空格分隔
contact=(******@163.com ******@qq.com)
#本机ip
HOST_IP=192.168.0.100/24
notify() {
#邮件主题
    mailsubject="vip转移,$HOST_IP keepalived to be $1"
    #邮件正文
    mailbody="$(date +'%F %T'): 节点切换, $HOST_IP keepalived changed to be $1"
    for receiver in ${contact[*]}
    do
        #发送邮件
        echo "$mailbody" | mail -s "$mailsubject" $receiver
    done
}
case $1 in
master)
    notify master
    ;;
backup)
    notify backup
    ;;
fault)
    notify fault
    ;;
*)
    echo "Usage:{master|backup|fault}"
    exit 1
    ;;
esac

3.nginx_check.sh

以nginx为例，脚本用于宕机检测和重启

#!/usr/bin/env bash
echo ' a'
A=`ps -C nginx --no-header |wc -l`
if [ $A -eq 0 ];then
        # 开启nginx服务
        /usr/local/nginx/sbin/nginx
        sleep 1
        # nginx没有启动成功
        if [ `ps -C nginx --no-header |wc -l` -eq 0 ];then
                # 杀死keepalived进程
                killall keepalived
        fi
fi

4.mail.rc

告警邮件发送配置，需要安装相关依赖

1	yum -y install mailx

配置/etc/mail.rc

# This is the configuration file for Heirloom mailx (formerly
# known under the name "nail".
# See mailx(1) for further options.
# This file is not overwritten when 'make install' is run in
# the mailx build process again.

# Sccsid @(#)nail.rc2.11 (gritter) 8/2/08

# Do not forward to mbox by default since this is likely to be
# irritating for most users today.


# 末尾追加6行配置即可

#发送邮件的邮箱
set from=******@126.com
#smtp邮件服务器
set smtp=smtp.126.com
#发送邮件的邮箱用户
set smtp-auth-user=******@126.com
#邮箱授权码
set smtp-auth-password=******
set smtp-auth=login
set ssl-verify=ignore

二、效果展示

keepalived 服务

启动
1
systemctl start keepalived
查看状态
1
systemctl status keepalived
关闭
1
systemctl stop keepalived
重启
1
systemctl restart keepalived
手动关闭nginx服务，keepalived自动检测并重启
注意

检测周期必须大于notify.sh脚本睡眠时间。

告警邮件

三、结束语

评论区可留言，可私信，可互相交流学习，共同进步，欢迎各位给出意见或评价，本人致力于做到优质文章，希望能有幸拜读各位的建议！

专注品质，热爱生活。
交流技术，寻求同志。

TCP三次握手和四次挥手

2023-01-09T09:43:24.000Z

三次握手

先ping域名为www.baidu.com，便于`DNS`解析。`ping`走的协议就包括`DNS`、`ARP`和`ICMP`。![image-20230109150250842](https://yupeng-tuchuang.oss-cn-shenzhen.aliyuncs.com/image-20230109150250842.png)
接着使用Wireshark去抓包，抓包这里导航栏直接过滤ip就可以了，输入ip.host == 183.232.231.174
接着直接在浏览器输入百度域名www.baidu.com访问请求，Wireshark就能抓取包来分析了![image-20230109150841554](https://yupeng-tuchuang.oss-cn-shenzhen.aliyuncs.com/image-20230109150841554.png)
这里我们可以看到，本地通过ipconfig就可以看到source那一列为自己的ip地址，而且是客户端为前后各一次，服务端是第二次。
- 第一次为SYN标记请求，全英文名我的理解是Synchronized，即为同步，表示同步连接请求；
- 第二次为SYN + ACK组合标记请求，准确来说是两次请求（SYN第一次，ACK第二次），只不过优化对它进行合并了，SYN也表示连接，显而易见，想建立连接两方都要与对方发送同步包请求连接，ACK表示百度接收到了你的同步包，但怎么告知人家？用ACK = SYN(第一次握手的Sequence) + 1，算是一种默契，你收到该包后客户端完成了连接，但百度还未连接成功；
- 第三次为ACK标记请求，百度第二次握手发了一个ACK标记，说明这个包是对你前一个包的回应，由前两个图可知。剩下的一个SYN标记，是表明这个包也是一个连接请求包，需要你发回ACK包，即表明我收到了，但得告知你，最后你收到后，你也成功完成连接。

四次挥手

三次挥手需要客户端与服务端断开连接，我这里使用vmware去连接虚拟机centos来演示。跟三次握手一样，你要抓那个网络的包，你就要在这个网络中去连接，比如我的是192.168.10.1这个，用这个通过子网分配给了一台虚拟机192.168.10.100
通过xsell连接后，使用命令init 0来断开连接，这会让服务器和客户端都断开连接。分清楚我是虚拟机，服务器是虚拟适配器VMnet8，因为我是在虚拟机里主动命令断开的。抓取信息如下：（将FIN顺带的ACK忽略，就是标准的四次挥手）
- 第一次为FIN标记请求，表示自己要断开连接了，不会再发送消息。
- 第二次为ACK标记请求，表示服务器收到了，然后服务器不再接收消息，但还是会发送消息，所以这是还未发送FIN包。从这个时候我还是可以接收服务器的消息的，所以我这边还不能断开。而有些不用接收数据就可以是三次挥手，是将ACK与FIN结合一起，如上图就是，只不过是发FIN请求时带上了ACK，但第一次还是发了ACK，才不会让对方以为没收到导致重发，这样才不会对网络造成阻塞。
- 第三次为FIN 标记请求，这时FIN表示服务器收到我要断开连接的消息，那它也准备断开连接了，不再发送消息，那我也不必再接收了，于是我就完成挥手，原则上是可以断开了，但服务端还不知情，还是不能断开。这里要注意，其实第二次与第三次之间应该还是有很多次请求，这些请求是消息的发送和接收，不算入断开连接中的挥手，而且这些请求都跟第二次挥手以及本次挥手的Acknowledgment number相同。
- 第四次是ACK标记请求，就是我要告知VMnet8我已经完成挥手了，你可以断开了。VMnet8收到就可以立即断开，而我等待2MSL时间内没收到服务端重发包就可以断开。因为MSL即为包在网络中的最大生存时间，我发一次和对方未收到超时重发。

牛客必会SQL

2022-12-06T01:17:59.000Z

牛客SQL
1. SQL91 返回购买价格为 10 美元或以上产品的顾客列表
2. SQL92 确定哪些订单购买了 prod_id 为 BR01 的产品（一）
3. SQL93 返回购买 prod_id 为 BR01 的产品的所有顾客的电子邮件（一）
4. SQL94 返回每个顾客不同订单的总金额
- 描述
- 示例1
5. SQL100 确定最佳顾客的另一种方式（二）
6. SQL108 组合 Products 表中的产品名称和 Customers 表中的顾客名称

1. SQL91 返回购买价格为 10 美元或以上产品的顾客列表

描述

OrderItems表示订单商品表，含有字段订单号：order_num、订单价格：item_price；Orders表代表订单信息表，含有顾客id：cust_id和订单号：order_num

OrderItems表

`order_num`	`item_price`
`a1`	10
`a2`	1
`a2`	1
`a4`	2
`a5`	5
`a2`	1
`a7`	7

Orders表

`order_num`	`cust_id`
`a1`	`cust10`
`a2`	`cust1`
`a2`	`cust1`
`a4`	`cust2`
`a5`	`cust5`
`a2`	`cust1`
`a7`	`cust7`

【问题】使用子查询，返回购买价格为 10 美元或以上产品的顾客列表，结果无需排序。
注意：你需要使用 OrderItems 表查找匹配的订单号（order_num），然后使用Order 表检索这些匹配订单的顾客 ID（cust_id）。

【示例结果】返回顾客id cust_id

`cust_id`
`cust10`

【示例解析】

cust10顾客下单的订单为a1，a1的售出价格大于等于10

示例1

输入：

DROP TABLE IF EXISTS `OrderItems`;
  CREATE TABLE IF NOT EXISTS `OrderItems`(
    order_num VARCHAR(255) NOT NULL COMMENT '商品订单号',
    item_price INT(16) NOT NULL COMMENT '售出价格'
  );
  INSERT `OrderItems` VALUES ('a1',10),('a2',1),('a2',1),('a4',2),('a5',5),('a2',1),('a7',7);

  DROP TABLE IF EXISTS `Orders`;
  CREATE TABLE IF NOT EXISTS `Orders`(
    order_num VARCHAR(255) NOT NULL COMMENT '商品订单号',
    cust_id VARCHAR(255) NOT NULL COMMENT '顾客id'
  );
  INSERT `Orders` VALUES ('a1','cust10'),('a2','cust1'),('a2','cust1'),('a4','cust2'),('a5','cust5'),('a2','cust1'),('a7','cust7');

输出：

cust10

解法1 - 内联

select cust_id
from OrderItems oi
inner join Orders o
on oi.order_num = o.order_num
where item_price >= 10

解法2 - 子查询

select cust_id
from Orders
where order_num in
(
    select order_num
    from OrderItems
    where item_price >= 10
)

数据量大的情况下，使用连接查询效率更高，因为子查询相当于for循环，要执行多次子查询，而连接只需要查询一次;
数据量小的情况下，子查询更容易控制和操作。

2. SQL92 确定哪些订单购买了 prod_id 为 BR01 的产品（一）

描述

表OrderItems代表订单商品信息表，prod_id为产品id；Orders表代表订单表有cust_id代表顾客id和订单日期order_date

OrderItems表

`prod_id`	`order_num`
`BR01`	`a0001`
`BR01`	`a0002`
`BR02`	`a0003`
BR02	`a0013`

Orders表

`order_num`	`cust_id`	`order_date`
`a0001`	`cust10`	`2022-01-01 00:00:00`
`a0002`	`cust1`	`2022-01-01 00:01:00`
`a0003`	`cust1`	`2022-01-02 00:00:00`
`a0013`	`cust2`	`2022-01-01 00:20:00`

【问题】

编写 SQL 语句，使用子查询来确定哪些订单（在 OrderItems 中）购买了 prod_id 为 “BR01“ 的产品，然后从 Orders 表中返回每个产品对应的顾客 ID（cust_id）和订单日期（order_date），按订购日期对结果进行升序排序。

【示例结果】返回顾客id cust_id和定单日期order_date。

`cust_id`	`order_date`
`cust10`	`2022-01-01 00:00:00`
`cust1`	`2022-01-01 00:01:00`

【示例解析】

产品id为”BR01“的订单a0001和a002的下单顾客cust10和cust1的下单时间分别为2022-01-01 00:00:00和2022-01-01 00:01:00

示例1

输入：

DROP TABLE IF EXISTS `OrderItems`;
  CREATE TABLE IF NOT EXISTS `OrderItems`(
    prod_id VARCHAR(255) NOT NULL COMMENT '产品id',
    order_num VARCHAR(255) NOT NULL COMMENT '商品订单号'
  );
  INSERT `OrderItems` VALUES ('BR01','a0001'),('BR01','a0002'),('BR02','a0003'),('BR02','a0013');

  DROP TABLE IF EXISTS `Orders`;
  CREATE TABLE IF NOT EXISTS `Orders`(
    order_num VARCHAR(255) NOT NULL COMMENT '商品订单号',
    cust_id VARCHAR(255) NOT NULL COMMENT '顾客id',
    order_date TIMESTAMP NOT NULL COMMENT '下单时间'
  );
  INSERT `Orders` VALUES ('a0001','cust10','2022-01-01 00:00:00'),('a0002','cust1','2022-01-01 00:01:00'),('a0003','cust1','2022-01-02 00:00:00'),('a0013','cust2','2022-01-01 00:20:00');

复制

输出：

1 2	cust10\|2022-01-01 00:00:00 cust1\|2022-01-01 00:01:00

解法1 - 内联

select cust_id, order_date
from OrderItems oi
inner join
Orders o
on oi.order_num = o.order_num
where prod_id = 'BR01'
order by order_date

解法2 - 子查询

select cust_id, order_date
from Orders
where order_num in
(
    select order_num
    from OrderItems
    where prod_id = 'BR01'
)
order by order_date

3. SQL93 返回购买 prod_id 为 BR01 的产品的所有顾客的电子邮件（一）

描述

你想知道订购 BR01 产品的日期，有表OrderItems代表订单商品信息表，prod_id为产品id；Orders表代表订单表有cust_id代表顾客id和订单日期order_date；Customers表含有cust_email 顾客邮件和cust_id顾客id

OrderItems表

`prod_id`	`order_num`
`BR01`	`a0001`
`BR01`	`a0002`
`BR02`	`a0003`
`BR02`	`a0013`

Orders表

`order_num`	`cust_id`	`order_date`
`a0001`	`cust10`	`2022-01-01 00:00:00`
`a0002`	`cust1`	`2022-01-01 00:01:00`
`a0003`	`cust1`	`2022-01-02 00:00:00`
`a0013`	`cust2`	`2022-01-01 00:20:00`

Customers表代表顾客信息，cust_id为顾客id，cust_email为顾客email

`cust_id`	`cust_email`
`cust10`	`cust10@cust.com`
`cust1`	`cust1@cust.com`
`cust2`	`cust2@cust.com`

【问题】返回购买 prod_id 为BR01 的产品的所有顾客的电子邮件（Customers 表中的 cust_email），结果无需排序。

提示：这涉及 SELECT 语句，最内层的从 OrderItems 表返回 order_num，中间的从 Customers 表返回 cust_id。

【示例结果】

返回顾客email cust_email

`cust_email`
`cust10@cust.com`
`cust1@cust.com`

`【示例解析】

产品id为BR01的订单a0001和a002的下单顾客cust10和cust1的顾客email cust_email分别是：cust10@cust.com 、cust1@cust.com

示例1

输入：

DROP TABLE IF EXISTS `OrderItems`;
  CREATE TABLE IF NOT EXISTS `OrderItems`(
    prod_id VARCHAR(255) NOT NULL COMMENT '产品id',
    order_num VARCHAR(255) NOT NULL COMMENT '商品订单号'
  );
  INSERT `OrderItems` VALUES ('BR01','a0001'),('BR01','a0002'),('BR02','a0003'),('BR02','a0013');

  DROP TABLE IF EXISTS `Orders`;
  CREATE TABLE IF NOT EXISTS `Orders`(
    order_num VARCHAR(255) NOT NULL COMMENT '商品订单号',
    cust_id VARCHAR(255) NOT NULL COMMENT '顾客id',
    order_date TIMESTAMP NOT NULL COMMENT '下单时间'
  );
  INSERT `Orders` VALUES ('a0001','cust10','2022-01-01 00:00:00'),('a0002','cust1','2022-01-01 00:01:00'),('a0003','cust1','2022-01-02 00:00:00'),('a0013','cust2','2022-01-01 00:20:00');

DROP TABLE IF EXISTS `Customers`;
CREATE TABLE IF NOT EXISTS `Customers`(
    cust_id VARCHAR(255) NOT NULL COMMENT '顾客id',
    cust_email VARCHAR(255) NOT NULL COMMENT '顾客email'
  );
INSERT `Customers` VALUES ('cust10','cust10@cust.com'),('cust1','cust1@cust.com'),('cust2','cust2@cust.com');

输出：

1 2	cust10@cust.com cust1@cust.com

解法1

select cust_email
from OrderItems oi
inner join Orders o
inner join Customers c
on oi.order_num = o.order_num and
o.cust_id = c.cust_id
where prod_id = 'BR01'

解法2

select cust_email
from Customers
where cust_id in
(
    select cust_id
    from Orders
    where order_num in
    (
        select order_num
        from OrderItems
        where prod_id = 'BR01'
    )
)

4. SQL94 返回每个顾客不同订单的总金额

描述

我们需要一个顾客 ID 列表，其中包含他们已订购的总金额。

OrderItems表代表订单信息，OrderItems表有订单号：order_num和商品售出价格：item_price、商品数量：quantity。

`order_num`	`item_price`	`quantity`
`a0001`	`10`	`105`
`a0002`	`1`	`1100`
`a0002`	`1`	`200`
`a0013`	`2`	`1121`
`a0003`	`5`	`10`
`a0003`	`1`	`19`
`a0003`	`7`	`5`

Orders表订单号：order_num、顾客id：cust_id

`order_num`	`cust_id`
`a0001`	`cust10`
`a0002`	`cust1`
`a0003`	`cust1`
`a0013`	`cust2`

【问题】

编写 SQL语句，返回顾客 ID（Orders 表中的 cust_id），并使用子查询返回total_ordered 以便返回每个顾客的订单总数，将结果按金额从大到小排序。

提示：你之前已经使用 SUM()计算订单总数。

【示例结果】返回顾客id cust_id和total_order下单总额

`cust_id`	`total_ordered`
`cust2`	`2242`
`cust1`	`1300`
`cust10`	`1050`
`cust2`	`104`

【示例解析】cust2在Orders里面的订单a0013，a0013的售出价格是2售出数量是1121，总额是2242，最后返回cust2的支付总额是2242。

示例1

输入：

DROP TABLE IF EXISTS `OrderItems`;
CREATE TABLE IF NOT EXISTS `OrderItems`(
order_num VARCHAR(255) NOT NULL COMMENT '商品订单号',
item_price INT(16) NOT NULL COMMENT '售出价格',
quantity INT(16) NOT NULL COMMENT '商品数量'
);
INSERT `OrderItems` VALUES ('a0001',10,105),('a0002',1,1100),('a0002',1,200),('a0013',2,1121),('a0003',5,10),('a0003',1,19),('a0003',7,5);

DROP TABLE IF EXISTS `Orders`;
CREATE TABLE IF NOT EXISTS `Orders`(
  order_num VARCHAR(255) NOT NULL COMMENT '商品订单号',
  cust_id VARCHAR(255) NOT NULL COMMENT '顾客id'
);
INSERT `Orders` VALUES ('a0001','cust10'),('a0003','cust1'),('a0013','cust2');

输出：

1
2
3

cust2|2242.000
cust10|1050.000
cust1|104.000

解法

select cust_id, sum(item_price * quantity) as total_ordered
from OrderItems oi
inner join Orders o
on oi.order_num = o.order_num
group by cust_id
order by sum(item_price * quantity) desc

5. SQL100 确定最佳顾客的另一种方式（二）

描述

OrderItems表代表订单信息，确定最佳顾客的另一种方式是看他们花了多少钱，OrderItems表有订单号order_num和item_price商品售出价格、quantity商品数量

`order_num`	`item_price`	`quantity`
`a1`	`10`	`105`
`a2`	`1`	`1100`
`a2`	`1`	`200`
`a4`	`2`	`1121`
`a5`	`5`	`10`
`a2`	`1`	`19`
`a7`	`7`	`5`

Orders表含有字段order_num 订单号、cust_id顾客id

`order_num`	`cust_id`
`a1`	`cust10`
`a2`	`cust1`
`a3`	`cust2`
`a4`	`cust22`
`a5`	`cust221`
`a7`	`cust2217`

顾客表Customers有字段cust_id 客户id、cust_name 客户姓名

`cust_id`	`cust_name`
`cust10`	`andy`
`cust1`	`ben`
`cust2`	`tony`
`cust22`	`tom`
`cust221`	`an`
`cust2217`	`hex`

【问题】编写 SQL 语句，返回订单总价不小于1000 的客户名称和总额（OrderItems 表中的order_num）。

提示：需要计算总和（item_price 乘以 quantity）。按总额对结果进行排序，请使用INNER JOIN 语法。

【示例结果】

`cust_name`	`total_price`
`andy`	`1050`
`ben`	`1319`
`tom`	`2242`

【示例解析】

总额（item_price 乘以 quantity）大于等于1000的订单号，例如a2对应的顾客id为cust1，cust1的顾客名称cust_name是ben，最后返回ben作为order_num a2的quantity * item_price总和的结果1319。

示例1

输入：

DROP TABLE IF EXISTS `OrderItems`;
CREATE TABLE IF NOT EXISTS `OrderItems`(
order_num VARCHAR(255) NOT NULL COMMENT '商品订单号',
item_price INT(16) NOT NULL COMMENT '售出价格',
quantity INT(16) NOT NULL COMMENT '商品数量'
);
INSERT `OrderItems` VALUES ('a1',10,105),('a2',1,1100),('a2',1,200),('a4',2,1121),('a5',5,10),('a2',1,19),('a7',7,5);


DROP TABLE IF EXISTS `Customers`;
CREATE TABLE IF NOT EXISTS `Customers`(
cust_id VARCHAR(255) NOT NULL COMMENT '客户id',
cust_name VARCHAR(255) NOT NULL COMMENT '客户姓名'
);
INSERT `Customers` VALUES ('cust10','andy'),('cust1','ben'),('cust2','tony'),('cust22','tom'),('cust221','an'),('cust2217','hex');

DROP TABLE IF EXISTS `Orders`;
CREATE TABLE IF NOT EXISTS `Orders`(
  order_num VARCHAR(255) NOT NULL COMMENT '商品订单号',
  cust_id VARCHAR(255) NOT NULL COMMENT '顾客id'
);
INSERT `Orders` VALUES ('a1','cust10'),('a2','cust1'),('a3','cust2'),('a4','cust22'),('a5','cust221'),('a7','cust2217');

输出：

1
2
3

andy|1050.000
ben|1319.000
tom|2242.000

解法

select cust_name, sum(item_price * quantity) as total_price
from OrderItems oi
inner join Orders o
inner join Customers c
on oi.order_num = o.order_num
and o.cust_id = c.cust_id
group by cust_name
having sum(item_price * quantity) >= 1000
order by total_price

6. SQL108 组合 Products 表中的产品名称和 Customers 表中的顾客名称

描述

Products表含有字段prod_name代表产品名称

`prod_name`
`flower`
`rice`
`ring`
`umbrella`

Customers表代表顾客信息，cust_name代表顾客名称

`cust_name`
`andy`
`ben`
`tony`
`tom`
`an`
`lee`
`hex`

【问题】

编写 SQL 语句，组合 Products 表中的产品名称（prod_name）和 Customers 表中的顾客名称（cust_name）并返回，然后按产品名称对结果进行升序排序。

【示例结果】

`prod_name`
`an`
`andy`
`ben`
`flower`
`hex`
`lee`
`rice`
`ring`
`tom`
`tony`
`umbrella`

【示例解析】

拼接cust_name和prod_name并根据结果升序排序

示例1

输入：

DROP TABLE IF EXISTS `Products`;
CREATE TABLE IF NOT EXISTS `Products` (
`prod_name` VARCHAR(255) NOT NULL COMMENT '产品名称'
);
INSERT INTO `Products` VALUES ('flower'),
('rice'),
('ring'),
('umbrella');

DROP TABLE IF EXISTS `Customers`;
CREATE TABLE IF NOT EXISTS `Customers`(
cust_name VARCHAR(255) NOT NULL COMMENT '客户姓名'
);
INSERT `Customers` VALUES ('andy'),('ben'),('tony'),('tom'),('an'),('lee'),('hex');

输出：

an
andy
ben
flower
hex
lee
rice
ring
tom
tony
umbrella

解法

select prod_name
from Products
union
select cust_name as prod_name
from Customers
order by prod_name

腾讯一面

2022-11-29T13:08:12.000Z

自我介绍这里一笔带过，给对面介绍自己内在 + 外在 + 校园经历 + 校园项目 + 意向岗位

腾讯子公司云智研发一面

1. 有了解过C++吗？接受转语言吗？

2. 有没有了解过一些框架的底层原理、底层优化、数据库的索引优化

3. 了解过哪些Map，可以从底层简单说下嘛？

比如我最常使用的有HashMap、HashTable、CurrentHashMap这三种

HashMap它的底层是采用了数组+链表的数据结构

从源码中分析，HashMap有一个静态内部类Node，HashMap通过成员变量table（Node数组类型）来采取put和get操作，该成员变量用关键字transient加以修饰，表明禁止序列化。

而Node是table数组的一个结点，内部成员数据有hash、key、value和指向Node类的next

– 初始化阶段 –

在这里，put操作后，table会先调用resize方法进行扩展，扩展后table才从null变为16位的Node数组，初始化后的每一个下标依旧为null，并且初始化阈值threshold，默认为0.75 * size,作用是与成员变量size（成员变量size会在每次put而且要该key值为首次操作即不存在该Map中会自增）进行比较，如果size数即表明put的key-value对的数量超过阈值threshold，进行下一步操作，即resize方法另一作用。

– 扩容阶段 –

扩容阶段更简单，就是将阈值*2来扩容，然后遍历整个table即Node数组，如果发现有Node结点，那么这里就出现了两种情况，第一种为每个结点上是链表结构，另一种则是红黑树结构。

扩容操作是创建新table来扩容，没有在旧table上直接扩容，遍历旧table进行扩容时，将会对每个table槽位置空，多线程在扩容时会发生一些导致线程安全的问题。

ConcurrentHashMap在JDK7扩容时使用到了ReentrantLock对段加锁，这样该段的旧table也无法操作，JDK则通过一种手段设置标志位，后面操作使用CAS乐观锁来操作，成功则退出，不成功发现扩容标志后则参与扩容。

扩容成功的结果就是发生链表转移或者是红黑树转移，都是为了将节点分散，以至于发挥出Hash一次命中取出和保存的高性能。

当然刚开始没有结点数据，oldTable为null，不需要转移结点，然后什么事都没干，接着通过hash与table的长度进行&操作命中槽位，put操作会保存到数组对应下标处即槽位中的结点。

– 结点初始化 –

保存之前很简单，得判断对应Node数组下标结点是否为null，因为这里是懒加载嘛，刚开始没有初始化数组的每一个元素，resize初始化方法也只是new了个Node数组，而且这也一样是懒加载。

所以在这里会将put中key的hash、key和value值封装到Node结点中并实例化，然后赋值到对应的Node数组下标中。

如果结点已经实例化了，那么这里有两种方式，一是链表寻址，二是树寻址，然后就是找到就覆盖，找不到就追加。

– 链表寻址 –

寻址前会先判断结点类型，如果instanceof不是TreeNode，那么便是链表，然后就可以开始遍历链表了，如果找到了的话，key-value当然就是要覆盖了，但是这里对key的处理分为了两种：

分析之前，其实链表中所有结点都位于同一个数组下标，那么应该都必须满足每个结点的hash值相同，即槽位相同，所以会再一次判断hash值，才会用key去比较。

如果key为基本数据类型，那么是直接通过运算符==来比较的，为true，那么就直接跳出链表遍历了，然后将刚刚在链表访问后命中的Node结点value覆盖
如果key为复杂类型，那么仅仅通过==运算符比较是错误的，这里就需要我们去主动重写equals方法，让key值怎么比较才能相等，因为默认equals是Object比较，这里涉及到内存指针了，所以创建的对象一般内存都不同，除非浅拷贝。
只是我们一般都用String类型，而String类型已经帮我们重写过了，虽然String类型也算是复杂类型，它重写了Object的equals方法，使得不同对象可以进行比较，比较的是对应字符串序列的内容是否相同。

如果没找到，那么将实例化新的Node结点，然后追加到链表末尾，在JDK7中是追加到头结点，后来发现线程安全，即多线程情况下，有几率会导致链表出现死锁。

– 树寻址 –

首先了解下TreeNode，它继承了LinkedHashMap.Entry，而Entry又继承了HashMap.Node，归根结底还是跟链表的Node类似，只不过多了一些成员和方法。

树寻址是判断结点是否为树节点，一般在链表转变为红黑树之后才会进行，红黑树是一棵平衡的二叉有序树，即由哈希值排序的二叉树，从根节点依次比较哈希值并遍历到叶子节点依旧没有找到，通过哈希值比较的大小直接实例出一个新的树节点给原来叶子节点的左孩子节点或右孩子节点。

如果找到该节点，与链表一样的方法，则中断遍历并将该节点返回，在外部进行赋值操作。

– 链表转移 –

链表转移前会判断链表是否只有表头，即只有一个元素，那么通过寻找该结点Node的Hash值，与扩容后的lenth长度&操作命中新的槽位

/**
e : table即Node数组中的一个下标元素
newCap: 新table的容量
e.hash: 哈希值，常用于与table长度做&操作来命中寻址
newTab: 新table
*/
newTab[e.hash & (newCap - 1)] = e;

如果是链表结构，那么按照hash值对链表拆成高位和低位链表，这里的高低位不是字面意思，我是直译源码字面意思，从代码分析：

/** 
如果 hash 二进制数中 与 旧table的容量表示的二进制数 所在的 位为1 & 为 真，则表示为高位链表
如果 hash 二进制数中 与 旧table的容量表示的二进制数 所在的 位为1 & 为 假，则表示为低位链表
从随机性角度考虑，这两种散列均匀的话各占一半
hash: 4字节的 int 类型
oldCap: 4字节的 int 类型，默认初始化为 16，二进制表示为 10000
*/
e.hash & oldCap) == 0

由于新table是旧table的两倍，那么低位链表命中赋值给新table中与旧table相同的下标，而高位从字面上理解，就要比低位更靠右，所以它的下标是原下标+oldCap，oldCap大小也是新table大小的一半，看图

– 转化红黑树 –

转化红黑树刚开始是不会触发的，在put操作的时候，在table中某个槽遍历链表时，如果链表长度达到扩展树阈值8，并且table长度要大于64。

链表满足长度8是树转移的必要条件，在table初始化后且发生转化红黑树前，会先去判断table长度是否达到64，没有则会扩容，扩容前面也详细说了，上面的图就很明确，达到8个节点的链表，扩容后链表拆成两部分，很明显没有必要再次去转化了。

如果长度满足，这时会先转变为双向链表，用于辅助树节点增加和删除以及维护树根节点。

转换红黑树是从遍历该链表开始，特殊处理第一个链表节点转成树节点，遍历这棵树，通过哈希值构造一颗排序树，每次构造新节点都是从叶子节点开始，不平衡就利用红黑标记来转为平衡树。

– 树转移 –

树转移发生在resize方法中，触发的事件是当前put成功后的所有元素个数大于table的阈值（容量 * 负载因子），接着会先扩容table的容量，树转移时，在put时hash命中的table中一个插槽发现是树节点，就开始转移，转移不是从树的逻辑转移，跟链表一样，只不过还有考虑前置节点，也就是跟树转移一样构造双向链表，拆成两条待转移成树的双向链表。

拆成的子双向链表，长度小于6就直接退化为链表，否则才将红黑树转移到新table的高低位上。

– 特殊key –

对于key为null值，JDK7与JDK8做法不同，但结果都是从table的0下标开始遍历。

JDK7的做法是对Null做了单独的put处理，不与非空的key放一起，直接单独在一个方法里面遍历table的0下标。

public V put(K key, V value) {
    if (key == null)
        return putForNullKey(value);
    int hash = hash(key);

所以常常说JDK7版本可读性比JDK8版本要强，这是无须质疑的。

JDK8的做法更绝了，是对Null做了单独的hash处理，因为前面的JDK7版本对key做单独处理，无外乎就是null没法调用本地native方法hashCode取的哈希值，所以干脆就在外面传入hash值，并且将为null的key哈希值处理为0。

1	return putVal(hash(key), key, value, false, true);

– 哈希定位 –

在HashMap中其实哈希的影响还是蛮大的，所以版本迭代对哈希也做了一些改进。

JDK7版本的做法其实也是将32位的int哈希类型在命中table中的下标是能够分布均衡，因为table的数组长度没有像哈希值一样每个位随机均匀，它高位字节一般为0，这就导致很多时候不同的哈希值高位虽然不同，但结果命中了同一个下标，JDK的做法通过无符号右移，让每12位无差别异或，即高低位能够很好的利用到了。

h ^= k.hashCode();

// This function ensures that hashCodes that differ only by
// constant multiples at each bit position have a bounded
// number of collisions (approximately 8 at default load factor).
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);

但这种做法还不够极致，JDK8版本的做法，更加简单明了。

1	return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);

4. 你项目中是如何去实现幂等性的？

先说下我对幂等性的理解，这样再去理解我项目对幂等性的处理。

定义

用户对于同一操作发起的一次请求或者多次请求的结果是一致的，不会因为多次点击而产生了副作用。

实现

幂等性在RPC上的实现，不仅要考虑结果一致性，还有考虑请求失败后负载到其他机器依旧保证幂等性，这就不能使用本地缓存来实现，而要用到分布式缓存，推荐的分布式缓存可以是Redis。

需要考虑到重试的时机来恰当设置缓存的失效时间，一般逻辑上只要保证请求次数达到阈值后重试请求成功即可失效，可从逻辑成功调用后去手动失效，或者是达到阈值后手动失效，不过这种做法增大了Redis的阻塞，因为Redis是单线程，没法做到并发，Jedis虽然可以并发，但会导致线程安全问题，而Jedis每次请求都需要建立连接，所以可以考虑共享一个连接，不过请求速度将大大降低。

而考虑Lettuce则需要提前准备线程池，后面就可以直接从从线程池取连接，连接数更好管控，性能也相对高一些。

5. RPC的协议讲一讲，怎么处理的？

RPC的请求过程：

服务端启动，并将服务注册到注册中心；
客户端启动通过代理调用所需的远程方法；
代理从注册中心拉取服务，并使用某种负载策略调用其中一个服务；
代理将客户端想要调用的方法等调用信息序列化，然后通过网络传输给服务端；
服务端接收到数据后，进行反序列化；
服务端得到反序列化的数据，包含需要调用的方法、参数数据，接着调用本地方法；
服务端调用完成将结果进行序列化，然后通过网络传输给代理；
代理拿到结果后，将结果反序列化，然后返回给客户端；
客户端接收到服务端远程方法调用的结果；

6. 项目中是怎么序列化的？

项目中使用到了两种序列化方式，一种是Jackson，另一种是Kryo序列化；

这两种序列化工具都提供对Java对象的序列化，即转成二进制，然后进行网络传输；

接收到网络传输的二进制，再反过来进行反序列化成对象；

不过项目序列化的是核心数据，对一些请求包头协议，是使用了自定义编解码的方式；

对特定的字节码进行编解码解析，从而可以避免出现粘包的问题；

拆完包之后，对包中的核心数据进行反序列化操作;

当然具体的操作还有考虑到包的其他安全问题，比如重发包和校验码失败包。

7.说一说深拷贝和浅拷贝

浅拷贝主要拷贝了对象的指针，本身数据引用的是同一块内存；

深拷贝则拷贝了对象本身，引用的是不同的内存。

在Java中，深拷贝和浅拷贝有Object的clone拷贝方法（浅拷贝）；

Arrays.copy（浅拷贝）和System.arraycopy（浅拷贝）

序列化则是深拷贝，比如Java内置的ObjectOutputStream的writeObject方法和ObjectInputStream的readObject方法；

更深入来讲，浅拷贝中，目标对象对内存的操作会影响到原对象，而深拷贝则受影响。

8. TCP和UDP了解下？

TCP与UDP都是传输层协议，TCP基于连接的，UDP基于非连接的；

从连接上看，TCP需要有三次握手才能完成连接，之后才能进行通信，是可靠的连接；

而UDP不需要连接，没有TCP严谨的三次握手、确认连接和四次挥手过程，是不可靠的连接；

TCP可以保证服务的可靠，一般用于高可靠服务，UDP不能保证服务是否可靠。

特点

TCP：

稳定可靠，适用于要求较高的场景，需要准确无误的传输给对方，比如文件传输、发送邮件和浏览网页等；

UDP：

速度快，性能损耗少、资源占用少，但是可能产生丢包，所以适用于对实时性要求较高，但是对少量丢包，并没有太大的要求的场景，比如域名查询、电话通信和视频直播等。

9. Http底层使用了什么：

TCP协议，是基于连接的。

http请求报文

HTTP请求报文由请求行（request line）、请求头部（header）、空行和请求数据等4个部分组成。

请求行：（get/post 方法，url中的path路径，http版本）

请求头部（header）关键字/值对组成，每行一对，关键字和值用英文冒号

请求数据 (body)

http响应报文

HTTP响应报文由四个部分组成：

状态码（Status Code）：描述了响应的状态。可以用来检查是否成功完成了请求。请求失败的情况下，状态码可用来找出失败的原因。如果Servlet没有返回状态码，默认会返回成功的状态码HttpServletResponse SC OK。
HTTP头部（HTTP Header）：它们包含了更多关于响应的信息。比如：头部可以指定任务响应过期的过期日期，或者是指定用来给用户安全的传输实体内容的编码格式。如何在Servlet中检索HTTP的头部看这里。
空行
主体（Body）：它包含了响应的内容。它可以包含HTML代码、图片等。主体是由传输在HTTP消息中紧跟在头部后面的数据字节组成的。

请求过程

客户端连接服务器：

客户端一般为Web浏览器，通过url访问服务端，与服务端建立一个TCP的套接字。

发送HTTP请求：

通过TCP套接字，发送HTTP请求时，客户端向服务端发送了一个文本的请求报文，一个请求报文由请求行、请求头部、空行和请求数据四部分组成。

返回HTTP响应：

Web服务器解析请求，定位请求资源。服务器将资源副本写到TCP套接字，有客户端读取。一个响应由状态行、响应头部、空行和响应数据四部分组成。

释放TCP连接：

当connection模式为close，主动关闭方为服务端，客户端被动关闭连接，释放TCP连接；
当connection模式为keepalive，则该连接会保持一段时间，在该时间可以继续接收其他请求，长连接复用，与2.0的多路复用目的都是为了重用连接，减少连接开销。

10. 三次挥手说下？

三次挥手与四次挥手很像，先说下四次挥手。

四次挥手

由主动关闭方(Client)发起中断连接请求，也就是FIN报文，被动关闭方(Server)接收到FIN报文后，从协议上来说是主动关闭方在等待收到FIN + ACK报文段，被动关闭方由于有数据要方法，第二次挥手只发了ACK确认号，接着主动关闭方进入FIN_WAIT状态，继续等待被动关闭方的FIN报文。

当被动关闭方数据发送完成后，将发送FIN报文给主动关闭方，主动关闭方收到FIN报文后，主动关闭方完成关闭，但被动关闭方并不知道FIN报文是否被接收成功，所以主动关闭方关闭前还需发送ACK给被动关闭方，表示已成功接收被动关闭方的FIN报文，这时被动关闭方就可以断开连接了。

如果没收到将再次发送FIN报文给主动关闭方，最后主动关闭方也不知道被动关闭方是否接收，需要等待2MSL时间，如果没收到重发包即成功了。

三次挥手

三次挥手不同于四次挥手，不同是第二次与第三次挥手合并了，如果服务端没有数据要发送，就可以将第二次与第三次挥手合并，而如果有数据要发，并且客户端允许延迟收到确认，那么服务端可以将结果封装到第二次与第三次合并的报文段中一起发送。

11. 进程和线程的关系？

定义

进程是资源分配的基本单位，线程是CPU调度和分派的基本单位。

包含关系

线程是进程的一部分，一个线程只能属于一个进行，一个进程可以有多个线程，但至少有一个线程。

内存角度

每个进程分配了不同的内存空间，每个进程都有独立的代码和数据空间，多个进程可以同时运行在内存中，而同一个进程的多个线程（简称同类线程）在其分配的指定内存中运行，需要CPU来调度这一块内存区域。

系统不会为线程分配资源，只能通过CPU来调度和分派资源，也就是说，进程分配内存资源，然后线程需要CPU来过渡使用这块内存。

进程切换开销大，线程切换开销小。

共享角度

同类线程之间可以共享堆空间和方法区和运行时常量池，每个线程都有自己独立的虚拟机栈和程序计数器。

进行共享的方式

线程共享环境：进程代码段、进程公有数据、进程打开的文件描述符、信号处理器、进程当前目录和进程用户ID与进程组ID

进程通信的方式

匿名管道 (PIPE)

半双工，即不能同时在两个方向上传输数据，有的系统可能支持全双工。

速度慢，容量有限，且只能在父子进程间。经典的形式就是管道由父进程创建，进程fork子进程之后，就可以在父子进程之间使用了。

命名管道 (FIFO)

不想关的进程也能够进行数据交换。

消息队列

消息队列，就是一个消息的链表，是一系列保存在内核中消息的列表。

信号量

信号量是互斥信号量，能够用来同步通信。

共享内存

通过共享内存机制来实现。

套接字

套接字通过Socket绑定套接字，服务端开启监听被动连接，客户端主动连接，向套接字读写数据实现通信。

信号

一种异步通信方式，可在用户态和内核态中交互，也可以在内核态中通知用户态事件的发生。

12. 了解过CAS嘛？

CAS是一种乐观锁的实现，CAS操作包含三个操作数——内存位置（V）、预期原值（A）期待值（B）。

如果内存位置的值与预期值向匹配，那么处理器会自动将该位置值更新为期待值，否则不做任何操作。

缺陷：无法解决ABA问题，在Java中解决该问题使用到了AtomicStampReference和AtomicMarkableReference来解决

数据库中MySQL的锁机制也是通过乐观锁来实现，更具体的实现则是MVCC多版本并发控制。

具体是两个数据结构，一个为undo log日志，一个为readView可读视图。

每张表中都会有隐藏的两列，一列是undo log指针，指向当前行数据操作指向的数据链表结构，另一列为事务版本号id，即每次事务开启后都会获取一个自增长的事务id，这样在ReadView可读视图中实现乐观操作，回到最先定义乐观锁三个操作数，实现方式差不多。

undo log 主要对所有并发修改结果保存了下来，并以链表的形式组织。
ReadView主要处理事务id的可见性，包含当前活跃事务版本Id列表，活跃最小事务id（up_limit_id）即已提交最大事务id + 1，活跃最大事务id（low_limit_id）即最小不可见事务id - 1和creator_trx_id表示当前事务开启的版本号。
活跃事务即为同一时间并发下，所有发生了交叉的事务。

13. 你的RPC项目怎么怎么划分模块的？

服务发现（从注册中心获取服务及对应地址、使用负载均衡策略选择服务）
服务注册者（注册服务名和对应地址到注册中心、连接注册中心、清除服务）
服务提供者（存放服务实例、获取服务实例）
客户端代理（处理客户端请求、处理超时重试、负责分布式请求id生成）
服务端（启动服务时将服务所有类实例化并存放到服务提供者，将所有服务类对应服务名注册到服务注册者、处理客户端请求方法、处理超时包、处理重发包、处理异常包）
服务端处理器（从服务提供者获取服务实例、读取请求包代理执行服务对应方法）
异步请求池（客户端请求调用后立马返回future结果，由netty客户端正确读取结果后返回给异步请求池）
编码与解码器（对请求包和响应包的封包和拆包）
包检查器（对请求包和响应包的安全检验）
注册中心（暴露服务真实地址和端口号、提供服务注册与发现）
分布式缓存（缓存时间戳与序列号、重试请求号与请求结果、机器码）
服务宕机钩子（中心服务下线与本地服务清除、下线机器码、线程池关闭）

14. 做一套算法题

如有升序链表：list1 = [1,2,3]，list2 = [1,4,5]，则合并后的链表：list = [1,1,2,3,4,5]

private List concat(List list1, List list2) {
// 头结点存储数据
List p = list1;
List q = list2;

List newNode = new List();
List head = newNode;
while(p.next != null && q.next != null) {
if (p.data < q.data) {
newNode.next = p;
p = p.next;
} else {
newNode.next = q;
q = q.next;
}
newNode = newNode.next;
}
    // list2 仍存在节点
if (p.next == null && q.next != null) {
newNode.next = q;
}
    // list1 仍存在节点
if (p.next != null && q.next == null) {
newNode.next = p;
}
return head.next;
}

SpringBoot整合rpc-netty-framework

2022-10-20T09:15:08.000Z

一个分布式微服务RPC框架 | 返回

使用效果：

用户访问客户端：GET http://localhost:8081/user/hello?name="张三来访"

浏览器访问客户端：

服务端接收情况：

服务端负载注册服务：

上面的实现就好比客户端只拿到服务端的api接口，加上配置中心地址即可调用远程服务！

1. 创建工程

创建两个工程，一个作为服务端SpringBoot、一个作为客户端SpringBoot，同时作为后端接口服务

创建Maven工程的时候推荐使用父子工程依赖，而且要注意子模块之间的相互依赖关系，其中：

父模块（root项目）：负责管理SpringBoot版本、统一版本、JDK版本、日志依赖

<profiles>
    <profile>
        <id>jdk1.8id>
        <activation>
            <activeByDefault>trueactiveByDefault>
            <jdk>1.8jdk>
        activation>
        <properties>
            <maven-compiler-source>1.8maven-compiler-source>
            <maven-compiler-target>1.8maven-compiler-target>
            <maven-copiler-compilerVersion>1.8maven-copiler-compilerVersion>
        properties>
    profile>
profiles>

<parent>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-parentartifactId>
<version>2.1.2.RELEASEversion>
<relativePath/>
parent>
<dependencies>

<dependency>
    <groupId>org.projectlombokgroupId>
    <artifactId>lombokartifactId>
    <version>1.18.10version>
dependency>

<dependency>
    <groupId>ch.qos.logbackgroupId>
    <artifactId>logback-classicartifactId>
    <version>1.2.3version>
dependency>
dependencies>

主模块（启动类所在模块）应配置maven打包插件，SpringBootStarterWeb，rpc-core和依赖Service/Controller模块，客户端只有Service模块，服务端只有Controller模块

<dependencies>

    <dependency>
        <groupId>cn.fyupenggroupId>
        <artifactId>springboot-rpc-serviceartifactId>
        <version>1.0-SNAPSHOTversion>
    dependency>

    <dependency>
        <groupId>cn.fyupenggroupId>
        <artifactId>rpc-coreartifactId>
        <version>2.0.0version>
    dependency>

    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-webartifactId>
    dependency>
dependencies>

<build>
<plugins>
    <plugin>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-maven-pluginartifactId>
    plugin>
plugins>
build>

Service/Controller模块：依赖api模块和common模块，客户端请求服务端调用服务，当然没有Service模块，让主模块依赖Controller模块，Controller模块还要与主模块一样依赖SpringBootStarterWeb和rpc-core

<dependencies>
    <dependency>
        <groupId>cn.fyupenggroupId>
        <artifactId>springboot-rpc-commonartifactId>
        <version>1.0-SNAPSHOTversion>
    dependency>
    <dependency>
        <groupId>cn.fyupenggroupId>
        <artifactId>springboot-rpc-apiartifactId>
        <version>1.0-SNAPSHOTversion>
    dependency>
dependencies>

Common模块，依赖rpc-common模块

<dependencies>
    <dependency>
        <groupId>cn.fyupenggroupId>
        <artifactId>rpc-commonartifactId>
        <version>2.0.0version>
    dependency>
dependencies>

项目在准备测试服务端的自动发现服务功能时，要保证cn.fyupeng.@Service注解类能够被扫描，使用cn.fyupeng.util.ReflectUtil类即可。

public class Test {
    public static void main(String[] args) throws IOException {
        Set> classes = ReflectUtil.getClasses("cn.fyupeng");
        for (Class aClass : classes) {
            System.out.println(aClass);
        }
    }
}

2. 客户端

2.1 编写启动器

新建cn.fyupeng包，包下新建启动器类

@SpringBootApplication
@ComponentScan(basePackages = {"cn.fyupeng","org.utils"})
public class SpringBootClientStarter {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootClientStarter.class, args);
    }
}

2.2 编写配置文件

# 单机模式
cn.fyupeng.nacos.register-addr=192.168.10.1:8848
# 集群模式
cn.fyupeng.nacos.cluster.use=true
cn.fyupeng.nacos.cluster.load-balancer=round
cn.fyupeng.nacos.cluster.nodes=192.168.10.1:8847|192.168.10.1:8848;192.168.10.1:8849

2.3 编写自定义配置类

2.4 编写api

注意与客户端包名完全相同

package cn.fyupeng.service;

/**
 * @Auther: fyp
 * @Date: 2022/10/19
 * @Description: HelloWorld接口
 * @Package: cn.fyupeng.cn.fyupeng.controller
 * @Version: 1.0
 */
public interface HelloService {
    String sayHello(String name);
}

2.5 编写控制器

@PostConstruct注解不要与@Autowire公用，因为@Autowire是本地依赖的，而我@PostConstruct会在该变量使用前调用，不过需要自行去实现，我的实现是远程依赖。

而@Reference没有依赖注入的功能，只有在超时重试才需要标记上！

@PostContruct与@Autowire在51cto博客中有所讲解，请自行到我的github主页get

package cn.fyupeng.controller;

import cn.fyupeng.anotion.Reference;
import cn.fyupeng.loadbalancer.RandomLoadBalancer;
import cn.fyupeng.net.netty.client.NettyClient;
import cn.fyupeng.proxy.RpcClientProxy;
import cn.fyupeng.serializer.CommonSerializer;
import cn.fyupeng.service.HelloService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.utils.JSONResult;

import javax.annotation.PostConstruct;


/**
 * @Auther: fyp
 * @Date: 2022/10/19
 * @Description: HelloWorld控制器
 * @Package: cn.fyupeng.cn.fyupeng.controller
 * @Version: 1.0
 */

@RequestMapping("/user")
@RestController
public class HelloController {

    //@Autowired
    //private HelloService helloService;

    private static final RandomLoadBalancer randomLoadBalancer = new RandomLoadBalancer();
    private static final NettyClient nettyClient = new NettyClient(randomLoadBalancer, CommonSerializer.KRYO_SERIALIZER);
    private static final RpcClientProxy rpcClientProxy = new RpcClientProxy(nettyClient);

    @Reference(retries = 5, timeout = 600, asyncTime = 3000)
    //@Autowired
    private HelloService helloService;

    @PostConstruct
    public void init() {
        helloService = rpcClientProxy.getProxy(HelloService.class, HelloController.class);
    }

    @GetMapping("/hello")
    public JSONResult sayHello(String name) {
        return JSONResult.ok(helloService.sayHello(name));
    }

}

3. 服务端

3.1 编写配置类

新建cn.fyupeng.config包，在包下新建资源配置类，用于注入绑定端口

@Configuration
@ConfigurationProperties(prefix="cn.fyupeng.config")
//不使用默认配置文件application.properties和application.yml
@PropertySource("classpath:resource.properties")
public class ResourceConfig {
    private int serverPort;

    public int getServerPort() {
        return serverPort;
    }

    public void setServerPort(int serverPort) {
        this.serverPort = serverPort;
    }
}

3.2 编写启动器

@Slf4j
@ServiceScan
@SpringBootApplication
@ComponentScan(basePackages = {"cn.fyupeng", "org.utils"})
public class RpcServerStarter implements CommandLineRunner {

    @Autowired
    private ResourceConfig resourceConfig;

    @PostConstruct
    public void init() {
        Map resourceLoaders = ResourceLoadUtils.load("resource.properties");
        if (resourceLoaders != null) {
            String serverPort = resourceLoaders.get("cn.fyupeng.config.serverPort");
            resourceConfig.setServerPort(Integer.parseInt(serverPort));
        }
    }

    public static void main(String[] args) {
        SpringApplication.run(RpcServerStarter.class,args);
    }

    @Override
    public void run(String... args) throws Exception {
        //这里也可以添加一些业务处理方法，比如一些初始化参数等
        while(true){
            NettyServer nettyServer = null;
            try {
                nettyServer = new NettyServer("192.168.2.185", resourceConfig.getServerPort(), SerializerCode.KRYO.getCode());
            } catch (RpcException e) {
                e.printStackTrace();
            }
            log.info("Service bind in port with "+ resourceConfig.getServerPort() +" and start successfully!");
            nettyServer.start();
            log.error("RegisterAndLoginService is died，Service is restarting....");
        }
    }

}

3.3 编写配置文件

注意config/resource.properties与资源目录下的resource.properties不能同时公用，前者优先级高于后者

# 用于启动 jar 包端口
cn.fyupeng.config.serverPort=8082

# 用于配置中心单机
cn.fyupeng.nacos.register-addr=192.168.2.185:8848
# 用于配置中心集群
cn.fyupeng.nacos.cluster.use=true
cn.fyupeng.nacos.cluster.load-balancer=round
cn.fyupeng.nacos.cluster.nodes=192.168.2.185:8847|192.168.2.185:8848;192.168.2.185:8849

3.4 编写api

注意与客户端包名完全相同

package cn.fyupeng.service;

/**
 * @Auther: fyp
 * @Date: 2022/10/19
 * @Description: HelloWorld接口
 * @Package: cn.fyupeng.cn.fyupeng.controller
 * @Version: 1.0
 */
public interface HelloService {
    String sayHello(String name);
}

3.5 编写业务

注意Service注解为cn.fyupeng.service.HelloService

package cn.fyupeng.service.impl;


import cn.fyupeng.anotion.Service;
import cn.fyupeng.service.HelloService;

/**
 * @Auther: fyp
 * @Date: 2022/10/19
 * @Description: HelloWorld实现类
 * @Package: cn.fyupeng.cn.fyupeng.controller.impl
 * @Version: 1.0
 */

@Service
public class HelloServiceImpl implements HelloService {
    @Override
    public String sayHello(String name) {
        return "hello, my name is " + name;
    }
}

为了使用配置文件注入来启动服务对应的端口

小迈科技一面

2022-09-29T08:00:20.000Z

简单三分钟自我介绍

自我介绍这里一笔带过，给对面介绍自己内在 + 外在 + 校园经历 + 校园项目 + 意向岗位

一面

1. Java基础

1.1 序列化和反序列化

首先了解一下序列化和反序列化的概念

序列化：将Java对象以二进制即字节码的形式保存在磁盘文件中，可以说是保存Java对象状态的过程，序列化可以实现对象保存的持久化；

反序列化：将保存在磁盘文件中的Java字节码重新转换为Java对象的过程；

其他特点：一般RPC框架底层协议通信就是通过序列化和反序列化在网络上传输Java对象。

序列化和反序列化的实现主要有两种，准确来说有三种方法：

采用默认的序列化方式，即通过ObjectOutPutStream类的writeObject(OutputStream out)方法来序列化到输出流中

输出流可以选择文件流、也可以选择管道流，甚至是二进制流

文件流是直接写到文件中再读取转成对象，管道流是通过管道缓存数据，然后再通过输入流连接管道读取转成对象

序列化的对象必须实现Seriablized接口，才能完成序列化和反序列化操作

class Student implements Serializable {
   private String name;
   private Integer age;
}

第一种实现（采用默认）

//FileOutputStream fos = new FileOutputStream("D:\\student.txt");
      PipedOutputStream pos = new PipedOutputStream();
      PipedInputStream pis = new PipedInputStream();
      pis.connect(pos);
      ObjectOutputStream oos = new ObjectOutputStream(pos);

      Student student = new Student();
      student.setAge(21);
      student.setName("zs");
      oos.writeObject(student);

      //FileInputStream fis = new FileInputStream("D:\\student.txt");
      ObjectInputStream ois = new ObjectInputStream(pis);
      Student res = (Student) ois.readObject();
      System.out.println(res);

第二种实现（自定义）

// 自定义协议 比如我可以将加入对象头 cafe babe
   private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
      System.out.println("自定义反序列化");
      int magic = in.readInt();
      this.name = (String) in.readObject();
      this.age = (Integer) in.readObject();
   }

   // 自定义协议 比如我可以将加入对象头 cafe babe
   private void writeObject(ObjectOutputStream out) throws IOException {
      System.out.println("自定义序列化");
      // 4 字节 魔数
      out.writeInt(0xCAFEBABE);
      out.writeObject(this.name);
      out.writeObject(this.age);
   }

第三种（自定义）

实现接口Externalizable并重写方法，其实跟第二种差别不大，只是第二种有默认的私有方法

@Override
   public void writeExternal(ObjectOutput out) throws IOException {
      System.out.println("实现 Externalizable 接口的自定义序列化");
      out.writeObject(this.name);
      out.writeObject(this.age);
   }

   @Override
   public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
      System.out.println("实现 Externalizable 接口的自定义反序列化");
      this.name = (String) in.readObject();
      this.age = (Integer) in.readObject();
   }

解决反序列化破坏单例

在单例模式中，序列化可以破坏单例，这是需要重写readResolve() 方法，将之前的单例实例对象返回即可保证单例。

解决反射破坏单例

反射创建对象根本也是要调用构造方法，而且可以无视构造方法的访问修饰符（public、private）

Java规定反射不能破坏枚举类型，采用枚举构造单例
构造方法执行前，单例实例逻辑上不应该创建而且只执行一次，可判断是否已创建来避免反射创建多个实例，前提单例已先于反射

1.2 说一说数据类型有哪些

Java有八种基本数据类型 + String

1个位的bit，布尔类型的boolean，2个字节的short，4个字节的int、char，8个字节的long、double、float

其中基本类型中的包装类型常用的有Integer、Long

其中Integer会自动进行拆封装处理，也就是可以直接跟int类型比较数值上的大小

底层在-128-127之间会做缓存，在这之间通过Integer.valueOf(int)创建的对象都是同一个,使用了享元设计模式

1
2
3

System.out.println(new Integer(1) == 1);
System.out.println(Integer.valueOf(1) == Integer.valueOf(1));
System.out.println(Integer.valueOf(128) == Integer.valueOf(128));

结果

1
2
3

true
true
false

1.3 数据结构

给你你个浏览器，要求设计前进和后退的数据结构，优先考虑性能

那么由于浏览器前进后退访问，是一种FIFO的结构，比如你连续点击前进几个页面，最先进的页面最后返回，即LIFO

那么可以考虑栈的结构设计，栈结构设计要考虑性能，首先我们可以分析到，浏览器页面跳转没有涉及到页面的修改，即用于查询

那么优先考虑数组而不考虑链表

我们可以设计两个栈数组，一个用于入栈已前进的页面，一个用于入栈已后退的页面，取其中一个栈顶元素作为当前页面

2. MySQL

2.1 索引

在MySQL中，直接影响索引类型的是数据库的存储引擎

使用MyIsam存储引擎，数据文件和索引是分开的，索引会另外存储在另一个文件中

使用InnoDB存储引擎，数据和索引都存储在同一个文件中，而且是以B+数的数据结构存储，非叶子节点存储索引，叶子节点存储索引和索引对应的数据

就MyIsam引擎来说，索引中最主要的是聚簇索引，也就是主键的默认索引

单值索引和多值索引，这里是指组合索引，好的组合索引可以达到覆盖索引，可以做到避免回表，这里是因为叶子节点通过覆盖索引带了数据，因为B+树只有叶子节点带有数据，非叶子节点都是索引

而多个组合索引下，有效索引要做到左匹配，也就是必须从左顺序匹配到右查询，否则索引将失效

2.2 口述 sql

给你一张表，有三个字段，id、产品id、备注信息，现在需要你查询相同产品id的记录，然后id值相同的记录数大于等于5的产品id

首先呢，我们可以先定义这张表为S

因为涉及相同字段的记录，可以考虑直接分组，使用聚合函数

1
2
3

select pro_id from S
group by pro_id
having count(pro_id) >= 5

3. JVM

3.1 线程的死锁了解过吗？

比如有两个线程t1和t2，t1线程有资源r1，t2有资源r2，t1线程执行代码中需要资源r2，不过这段代码需要t2线程把资源r2释放才能执行，此时t2线程也执行代码中，释放资源前需要获取资源r1，但t2又需要r2，此时处于相互等待的状态，就导致了死锁。

从Java角度来说，资源相当于Java的锁对象，是互斥的，一个线程获取锁对象后，另一个线程只能等待，t1线程获取锁对象r1，也就是占有了锁r1，这时线程t2也是占有了锁对象r2，而线程t1需要获取锁对象r2才能往下执行代码，使得线程t1阻塞，而线程t2处于阻塞等待锁对象r1释放，才能释放锁对象r2，这样就导致死锁。（互相等待）

4. JUC

4.1 线程池有了解过吗？

线程池主要有核心线程数、救急线程和队列，队列分为阻塞队列和非阻塞队列。

目前线程池主要可以分为几类：

只有核心线程、无救急线程的线程池，此时等待队列中有要执行的任务，而核心线程在轮询地执行等待队列中的任务，如果队列满或者队列是无界队列，可能导致内存溢出问题。

一般这种线程池的做法就是使用了拒绝策略，拒绝策略可分为直接丢弃新任务、异常抛出（主动逻辑处理）、丢弃等待队列头结点、提交任务线程执行。

最后一个是推荐使用的

不会造成数据丢失，也就不会出现业务损失；
提交任务的线程被占用，新的任务不可提交，减缓任务提交的速度，相当于负反馈，能给到线程池一定的缓冲期；

只有救急线程的线程池，这种的话有线程池newCachedThreadPool，它能无限创建救急线程，队列采用SynchronousQueue ，是一个没有容量的队列，只有线程取任务时才能提交任务；

最后是一种核心线程数只有1的线程池，没有救急线程，任务队列无界，一般作为单线程任务，这样就不会有CPU的轮询切换，任务的执行效率最高，不过请求数太多的情况下，也是容易导致内存溢出。

非阻塞队列实现的有CurrentLinkedQueue，它是通过CAS无锁化机制的线程池队列，每个线程通过for(;;)执行，是一个单向且通过GC自动回收出队节点的，利用可达性算法分析，将next指向自己，即可触发延迟回收，利用元素的不可重用性，规避ABA问题

5. Linux

给你一个日志文件，要求你查询最近一天内中，匹配到关键字的所有记录数据

一般日志实时查询可以使用该命令，它会实时更新，而且会处于fg模式，tail打印文件末尾记录，也就是最近

1	tail -100f catalina.log \| grep "关键字"

而使用cat是查询历史，只能打印日志到屏幕

比如按照tail或head来查询关键字为20:的后5条数据并显示行号

1	cat -n log.log4j \| grep "20:" \| tail -n 5

时间段查询

1	grep '2022-08-21 20:1[1-9]' log.log4j

右岸物联面经

2022-09-25T10:28:50.000Z

简单三分钟自我介绍

自我介绍这里一笔带过，给对面介绍自己内在 + 外在 + 校园经历 + 校园项目 + 意向岗位

技术面

1. Java基础篇

1.1 `Object`你知道哪些方法?

我就回答了自己常用的 wait、notify、notifyAll 这三个方法，其他自己不怎么使用，就跟技术官说抱歉，其他不怎么使用，就回答不上来，面试官也不停留在这个问题上，直接带到下一个话题。

所以这里总结下，Object其实还有一个 clone()方法，这个回答不上了其实真不应该，当前想不起来，还有一个获取类信息getClass()，可以做映射的东西。

1.2 你了解过哪些list 类型吗

嗯，有两种，一种是数组，一种是链表，即ArrayList和LinkedList

1.3 这两种怎么选择使用？

一般的话，如果读操作大于增删改的话，使用数组效率要比链表的好，而如果要频繁修改操作，那么使用链表更好一点

所谓层层递进，就在这里了

1.4 那为什么这么说？

呃，因为数组如果你要增加一个元素的话，比如举例，你有十个元素，那么你要在0号下标增加一个元素，那么你得把后面10个元素整体向后挪到一位，这里我还用手势比划了一下，面试官点头，然后示意我继续，我就说链表的话，只需要修改一下指针就可以了，不用对整体移动，其实这里应该回调内存的连续跟分散会更好一点，因为数组是开辟的连续内存空间，而链表不需要，它是零散的，所以链表读要使用指针，自然而然数组读效率更高。

2. Spring 篇

2.1 Spring 是干什么用到？

Spring可以方便地给我们管理创建、获取和kill对象，不需要我们去额外做这一份工作。

2.2 了解过 `IOC`吗？

IOC是控制反转的意思，在Spring 容器中，创建对象的工作不再由我们来负责，而是交由 Spring 容器去管理各个对象的生命周期。

2.3 说一说 Spring 容器管理对象生命周期有什么用？

由于 Spring容器默认使用的是 Single单例创建对象，这样各个线程对同一个对象是共享的，就可以做到多个用户请求访问是拿的是同一个实例，不用总去创建对象，导致频繁的 GC垃圾回收。

2.4 说一说 Spring 中容器它的创建实例的作用域

在 Spring容器中，有一个属性 scope，就是一个作用域，它可以指明创建对象是采用单例还是其他方式

单例的话多个线程下是共享实例的，当时只想到 Request，但这个不是线程级别的，没回答上来，没想到 Prototype（原型），技术官帮我解围了，说知道我知道想说什么，就是说不出来哈哈。

Prototype 它是一个原型，在多个线程中的创建的单例是互不干扰的，也就是生命周期的处于线程。

当然还有其他，因为不怎么使用，所以就没有怎么说。

MySQL 篇

MySQL 你了解过哪些引擎

嗯？这个我了解过两个，INNODB和Myisam

这两个是有什么区别？

我就说了第一个默认会使用行锁，Myisam 使用的是表锁

面试官继续追问，为什么？怎么判断的？

这个我真不知道该怎么回答，我就瞎扯了锁升级，就说 INNODB因为默认使用行锁，但是如果因为没有索引优化或者语句优化等问题，可能会出现锁升级现象，这是 Myisam 没有的。

面试官一头雾水，但没有反驳，好，继续下个问题。

事务有了解吗？

我说有有，这就来劲了，就说INODB 有事务，但Myisam 没有事务这说法，现在才明白面试官说这两个引擎的区别原来在这里。

面试官没有为难，知道问的差不多了，就开始手撕 SQL

口述SQL

给你一个表，这个表有三个字段，一个是学生 id，一个是课程名 cname，一个是课程成绩 cscore

要求：如果有三门课程，要求找出学生的总成绩大于270，并且返回学生id和总成绩

纳尼，第一个想法就是想着连表查询，当时觉得没戏了，就很挣扎

口述：就是通过三张表自然关联，关联三门成绩，然后关联条件是学生id，where 是三门成绩之和大于270

面试官觉得有问题，这种做法不通用，要我再想想其他方法

想了两分钟，没有思绪，给我个提示：可以使用 group by

分组？那就简单了，我就直接口述了，说可以先分组，然后在每个分组里面使用聚合函数sum，将总成绩这个条件满足270的查询出来

当时很紧张，怕错了，面试官一脸微笑的说，是的，思路是对的，你可以用在纸上用笔写下来吗？

他知道我口述可以，但还是不相信我动手能力，瞧不起了，可能之前用那个关联的SQL 手写SQL，出现了一点问题，但在他提出问题的时候，我立马说我可以修改下sql吗，改了再给他看了下，可能就是因为这个原因，自己不仔细写，给自己埋坑，让面试官对我有了质疑

于是这次我就好好捋了捋思绪，面试官看我迟迟未动笔，说不用紧张，慢慢想，当然我肯定不这么想，当时已经有想法了，只是怕又写错了SQL，因为当时已经有一个月没刷力扣 SQL题型了，想了两分钟左右，写了出来

select sc.sid, sum(sc.score) as sum_score
from SC sc
group by sc.sid
having on sum(sc.score) > 270

就这样，面试官比较满意，就问我为什么当时没想出来，我就说当时他说给三科成绩，很容易就让人想到用联表

到这里 SQL 也没继续写了

长城软件面经

2022-09-25T10:28:40.000Z

简单三分钟自我介绍

自我介绍这里一笔带过，给对面介绍自己内在 + 外在 + 校园经历 + 校园项目 + 意向岗位

技术面

1. Java基础篇

1.1 说一说数据结构

说下链表的属性，指针属性

树结构了解过吗？

叶子节点怎么存储的？

2. Spring 篇

2.1 Spring MVC 的原理

主要有5个组件，前端控制器、映射器、处理器、处理器适配器、视图解析器

前端控制器也就是中央处理器，它主要负责前端用户的请求和对其他组件的转发调用；
前端控制器接收到请求后，会把请求转发给处理器映射器，处理器会根据配置或注解（@Controller）找到最终要执行的Handler；
然后将Handler（自己的业务处理）对象以及其对应的拦截器，封装到HandlerExecutionChain对象中并以它的形式放回；
前端控制器根据获取到的Handler（Controller），去选择一个合适的HandlerAdapter（它还支持Servlet、HttpRequestHandler、ThrowawayController），成功获取到会先去执行拦截器；
这时将开始对提取Request中的模型数据，并且将Handler的入参进行数据填充，以至于我们写控制层方法时，入参是前端传来的值，在填充过程中，根据自己的配置，Spring还可以帮你做一些额外操作：
- Json/Xml 数据转换成对象
- 格式化请求数据
- 校验
Handler执行完成后，返回一个ModelAndView（视图和视图需要填充的模型数据）
前端控制器根据返回的ModelAndView，选择合适的ViewResolver
ViewResolver 结合Model和View，来渲染视图
最终前端控制器将渲染结果返回给客户端

3. JVM 篇

3.1 说一说你对jvm内存结构的理解

jvm 内存模型由程序计数器、方法区、虚拟机栈、本地方法栈、堆和运行常量池组成。

方法区：主要是存储类变量，静态变量，常量以及class描述信息（会在类加载后加载到方法区中）

虚拟机栈：虚拟机栈跟线程是直接挂钩的，它的生命周期跟线程一样，而且虚拟机栈设置的大小（-Xss1024k，1024个字节1M单词缩写Stack Size），当设置过大时，在堆大小固定的情况下，总内存 = 堆内存 + 线程数 * 虚拟机栈大小，可线程数就会相应减少；

本地方法栈：跟虚拟机栈相似，不过不是用Java写的；

程序计数器：线程私有，每个线程在让出CPU会由它来记录当前位置，以便恢复CPU还在原位置执行；

堆：存放Java对象实例，在JDK7版本中，由新生代（Eden区、Survivor区）和老年代组成，也是GC垃圾收集器处理的主要区域，俗称GC堆，是管理内存中最大的一块；

运行时常量池是放在方法区中的，作为方法区的一部分。

3.2 对象创建和销毁的过程

对象创建的过程其实在 jvm 中包括了加载、链接（包含验证（虚拟机的安全性、对象头、父类与子类中final等声明的安全性校验等等）、准备、解析）、初始化；

准备阶段：申请内存空间并完成默认的初始化，比如int类型默认初始化为4个字节的内存空间，并初始化为0；

解析阶段：将常量池中的引用解析为直接引用，也就是将类中的常量池放到了运行时常量池中，这样我们在直接调用方法或者引用类的时候，是需要符号引用的，只不过jvm帮我们自动引用了常量中的符号，就成直接引用。

初始化阶段：用户真正的赋值操作，即调用相应的构造器构造对象，构造对象创建的时候，如果是比较复杂的，由于虚拟机优化机制，会出现指令重排序问题，什么问题？

在该场景中，构造过程分为几个步骤：申请内存 -> 构造块构造 -> 内存地址返回，这里面的指令为了性能上的提示，而不改变结果，jvm可能会将内存地址也就是构造函数创建的对象指向的内存地址放到构造块过程中返回，而没有等到最后。

引用：编译器可以自由地以优化的名义对指令的顺序进行随意处理。

那么怎么解决？

当然是保证原子性呀！

怎么保证？

final声明不仅能保证类不可继承，方法不可重写，变量不可变，还有一个重要的特点就是能保证可见性，媲美volatile

可见性保证就是对象如果已经可见（地址已经返回了，那么保证它构造的完整性，也就是指令不会发生重排）性

文章分享：https://qa.1r1g.com/sf/ask/451997661/

内存模型官方讲解：http://www.cs.umd.edu/~pugh/java/memoryModel/jsr-133-faq.html

推荐比较好的网站：https://qa.1r1g.com/

补充

如果类中的成员变量声明为final并且是基本类型，那么赋值阶段会在准备阶段就完成了，这些可实现一些并发安全性应用；

3.2 GC 垃圾回收了解过吗

了解过一点点，没了，他就不问了……

我就是专门去看了gc中的一些原理，比如复制算法、并发标记、并发清除、分代回收，还有Serial、parNew、parallel Scavenge和g1这些，看來不能太低调了。

3.3 JVM 调优了解过吗

答案是没有，所以没有下文了，可惜这篇面经比较卑微，味道不够香。

因为就是简单使用过，没有在具体项目场景用到，不敢吹嘘。

3.4 volatile 能保证原子性吗

不能，volatile可以保证可见性，它是在jvm优化后，出现指令重排序后才有的，能够防止指令的重排序，也就是说指令重排序可能会先将对象在执行构造函数中，提前把对象所在地址给返回了，这就可能导致成员变量出现为null的情况，有了volatile就不会发生。

volatile一般修饰于变量

当然除了这个，volatile保证可见性还体现在内存与高速缓存之间，如果一个变量通过for循环去执行，那么jvm将进行性能优化，将内存中的变量放到高速缓存中，这样容易出现内存与高速缓存的不一致性问题，volatile可以保证对内存中变量的修改及时同步到高速缓存中。

4. SQL 篇

4.1 聊一聊你对SQL中的优化

主要分为语句优化和索引优化

语句优化比如避免使用or，可能导致全盘遍历，我是说了join连接和子查询，前一个只需要查询一次，后一个会多次遍历全表，如果数据量大的表将很严重。

索引优化的话，面试官很耐心给我讲了组合索引、失效的问题

4.2 SQL 中的函数的处理

SQL中的函数比如时间的yyyy-MM-dd hh-mm-ss,通过这种设置可以来处理相应的时间

可以看看这篇文章：https://blog.csdn.net/chentaocba/article/details/7539409

可以这样自定义去处理拼接时间

5. Redis 篇

5.1 聊一聊哨兵模式

哨兵模式的应用其实是Redis集群中故障恢复和高可用的应用，在Redis读写分离也就是主从复制中，哨兵节点作为独立节点，不参与选举。

在主节点也就是master节点宕机后，多个哨兵节点一致发现主节点下线，通过投票选举哪一个从节点选举为主节点。

其实就是一种监控主节点是否故障的行为。

5. 分布式

3.1 说一说服务降级

在请求超时、资源不足、CPU、数据库IO达到瓶颈时，采取的一种补救措施。

服务降级主要有Dubbbo的Mock和Spring Cloud的Hystrix，屏蔽对远程的调用，一般使用SpringBoot比较推荐整合Hystrix来实现服务降级容错。

3.2 聊一聊你的项目分布式中怎么解决出现的问题

我做的是一个分布式的博客管理项目，在搭建并部署分布式项目时，调用远程服务的时候，注册中心Nacos很容易出现宕机，当时排查的原因是内存不够，当时使用了阿里的两台服务器、一台腾讯云服务器来搭建分布式项目，阿里一台作为前端和Nginx做反向代理，一台运行着博客的文章、评论、分类标签和用户的五个服务，一台作为代理服务器，处理前端的请求、远程调用腾讯云服务器的服务，但我把注册中心放到了腾讯云上，因为腾讯云上的服务需要进行服务注册，而且注册中心Nacos启动是带有Web后台管理页面的，所以就作为一个内部的服务器使用。

于是解决方案就是将多个服务进行横向拆分，将文章和用户的服务放到代理服务器上运行，解决了在远程调用服务的时候因为请求超时或资源不足导致Nacos注册中心出现宕机的情况。

6. 网络编程

6.1 Tomcat 与 Netty 有什么区别

Tomcat是一种使用http协议的web容器，是用来启动web应用的，而Netty是一种自定义处理各种字节流数据做相应的编解码，也就是可以自定义通信协议，Netty是一款基于NIO的网络通信框架，而且Tomcat的话其实也支持NIO模式。

华资面经

2022-09-25T10:28:30.000Z

华资一面

—— 人力面（挂）

1. Spring

1.1 Spring 的生命周期

推荐学习链接：https://blog.csdn.net/shijinjins/article/details/124071095

Spring 生命周期会经历过四个阶段，分别是实例化、属性赋值、初始化、销毁

其他的一些阶段就是通过AOP面向切面扩展来的，能够让你在实例化、初始化和销毁前后做一些逻辑。

初始化阶段，有一个特别重要的接口BeanPostProcessor

postProcessorBeforeInitialization(); // 初始化前调用
postProcessorAfterInitialization(); // 初始化后调用

初始化方式有三个

InitializingBean类的afterPropertiesSet方法
@PostConstruct注解标注的方法 // Spring支持javax包中的@PostConstruct，会在属性值注入成功后执行
Spring配置文件applicationContext.xml的标签属性init-method="initMethod"

这里提醒，@PostConstruct是通过Spring的BeanPostProcessor#postProcessBeforeInitialization(Object, String)来完成调用的

如果是使用到了Spring自动注入来使用创建的Bean，那么如果使用反射的方式创建对象执行构造方法，先后顺序是这样的：

flowchart LR

A[服务器加载Servlet]--> B[Servlet构造函数]
B --> C["@Autowire"]
C --> D["@PostConstruct"]

反射的方式会在执行构造器后返回，所以你要通过反射使用Bean，可在@PostConstruct注解的方法保存该Bean，再去调用使用。

销毁方式有三个

@PreDestroy注解标注的方法 // // Spring支持javax包中的@preDestroy，会在销毁前执行
DisposableBean接口的destroy方法
Spring配置文件applicationContext.xml的标签属性destroy-method=;"destroyMethod"

这里提醒，@preDestroy执行是通过Spring的DestructionAwareBeanPostProcessor#postProcessBeforeDestruction(Object, String)来完成调用的

简要步骤

1.当程序加载运行时会根据spring中配置文件找到bean配置的属性和方法，并通过java反射机制创建实例化bean对象。

Bean实现了BeanNameAware接口，执行了setBeanName方法，实现注入对象。

2.实现了BeanFactoryAware工厂接口，执行了setBeanFactory方法。

3.实现了ApplicationContext接口类，执行了setsetApplicationContest方法。

4.实现了BeanPostProcessor接口类，执行postProcessBeforeInitialization方法

5.实现了InitiliazingBean 执行afterPropertiesSet方法，并加载配置文件定义了init-method 则执行对应初始化方法BeanPostProcessor 执行postProcessorfterInitilization方法，完成 Bean的初始化，使得bean可以使用。

6.实现了DisposabileBean接口执行destroy方法，加载配置文件中的destroy-method方法销毁bean对象实例。

1.2 Spring 作用域

单例（默认Single）和多例（Prototype）

单例在一个容器里面只存在一个对象，多例的Bean生命周期在容器产生时并不创建，对象使用时才创建，最后由JVM垃圾回收期回收

生命周期出生和销毁还可以自己指定，比如

init-method 对象出生之后立刻执行什么方法
destroy-method对象销毁之前执行什么方法

1.3 Spring 依赖注入方式

有三种：属性注入、构造函数注入、工厂方法（通过标签属性配置静态或实例工厂）注入

而基于这三种方式有多种实现：配置文件实现、注解实现、

2. 集合

集合的性质: 唯一性、无序性、确定性

唯一性指的是集合元素是不重复的、无序性指的是集合插入元素的顺序性、确定性是指集合中元素是确定的，不是相对性的。

集合类型按类型划分可以划分为可重复集合不可重复集

可重复集合：List实现类
不可重复集合：Set实现类、Map实现类（key）

按照有序性（添加和访问）划分可以划分为有序集和无序集

有序集：List实现类、TreeSet、LinkedHashSet、LinkedHashMap、TreeMap
无序集：HashSet、HashMap、

按照结构划分可以划分为列表List、Set、Map（Stack 和 Queue）

List：ArrayList、LinkedList

Set：HashSet、LinkedHashSet、TreeSet

Map：HashMap、HashTable、TreeMap、LinkedHashMap、CurrentHashMap、

按照存储连续性划分可以划分为连续集和散列集

连续集：ArrayList
散列集：LinkedList、Map实现类、Set实现类

3. 线程安全

3.1 线程安全的集合有哪些？

HashTable、CurrentHashMap、CurrentLinkedQueue、ArrayBlockingQueue、LinkedBlockingQueue

HashTable：它的方法都使用了重量级锁synchronized修饰来保证方法执行的线程安全。

CurrentHashMap：有JDK迭代版本；

7使用了分段锁Segment（继承可重入锁ReentrantLock）实现线程安全，是真正意义上实现了并发
8使用了synchronized + CAS，因为在1.6版本之后，synchronized一步步得到优化
- 包含了偏向锁、轻量级锁、重量级锁
- 处于偏向锁的对象，是指可以在获得该偏向锁的同一个线程中，多次执行同步代码块时相当于无锁
- 而如果处于偏向锁的对象被其他线程获取了，偏向锁将不再偏向，就升级为轻量级锁
- 升级为轻量级锁还是有机会继续偏向锁的，是怎么个原理？
- 在对象头前8个字节中，存储了偏向线程id，前提得是该线程未获取锁对象，获取锁对象后设置的是当前线程id
- 所以想让对象头上的偏向线程id重新偏向为当前线程id，得让该线程重复获取锁对象达到阈值20次才会偏向，不过只能偏向一次
- 这就是锁降级，如果有第三个线程参与了，同样执行第二个线程的操作，将不再偏向（对象头偏向线程id重置为0）
- 这是由再次升级为轻量级锁，前面是不发生竞争，如果多个线程发生竞争，竞争失败会自旋CAS再次尝试获取锁，如果还是失败
- 这时升级为重量级锁，重量级锁将不再通过乐观锁CAS操作，而是会发生阻塞，必须等获得锁的线程释放锁才能让给下一个线程

CurrentLinkedQueue：使用了非阻塞的方式实现了线程安全，是一个无锁化的单向队列，使用到了CAS + for(;;)，而且这种单向队列巧妙利用节点的不可重用 + CAS + next 指向本身 + GC垃圾回收，规避掉了ABA问题

因为节点出队列并不会马上出队列，而是通过next指向自己让GC垃圾回收掉，这样有线程刻意去ABA操作时，发现还有旧值，没法做修改达到ABA的目的，这说专业点就是延迟出队。

LinkedBlockingQueue：与CurrentLinkedQueue非常像，也是一个无界队列，这样如果入队快于出队的情况容易出现栈溢出

ArrayBlockingQueue：是有界队列

4. 谈谈自己的项目

略

第一场面试

2022-09-25T10:26:54.000Z

简单三分钟自我介绍

自我介绍这里一笔带过，给对面介绍自己内在 + 外在 + 校园经历 + 校园项目 + 意向岗位

技术面

1. Spring 原理篇

1.1 有使用过Spring吗，说一说它的 SpringMVC 原理

主要有5个组件，前端控制器、映射器、处理器、处理器适配器、视图解析器

前端控制器也就是中央处理器，它主要负责前端用户的请求和对其他组件的转发调用；
前端控制器接收到请求后，会把请求转发给处理器映射器，处理器会根据配置或注解（@Controller）找到最终要执行的Handler；
然后将Handler（自己的业务处理）对象以及其对应的拦截器，封装到HandlerExecutionChain对象中并以它的形式放回；
前端控制器根据获取到的Handler（Controller），去选择一个合适的HandlerAdapter（它还支持Servlet、HttpRequestHandler、ThrowawayController），成功获取到会先去执行拦截器；
这时将开始对提取Request中的模型数据，并且将Handler的入参进行数据填充，以至于我们写控制层方法时，入参是前端传来的值，在填充过程中，根据自己的配置，Spring还可以帮你做一些额外操作：
- Json/Xml 数据转换成对象
- 格式化请求数据
- 校验
Handler执行完成后，返回一个ModelAndView（视图和视图需要填充的模型数据）
前端控制器根据返回的ModelAndView，选择合适的ViewResolver
ViewResolver 结合Model和View，来渲染视图
最终前端控制器将渲染结果返回给客户端

1.2 springboot 有什么优点

springboot 它可以帮我快速、使用最低代码最少时间开发出一个项目，不想 SpringMVC，需要繁琐写很多配置信息，我们只关注写业务代码即可。

通过配置文件解耦代码，在一些可能改动的配置信息，可以不通过修改代码再打包部署，而是让代码去外部读取该配置文件，再去运行。

还有SpringBoot是使用了maven 可以方便对版本的管理，能够让自己不需要考虑版本依赖问题和兼容版本的问题。

Redis 篇

有使用过 Redis吗

有，它是一个缓存数据库，主要存储的是k-v类型的数据。

那说说它的一个缓存雪崩？

嗯？缓存雪崩的话，就是key集中失效，导致 Redis 相当于宕机，大量请求依旧打到mysql数据库上了。

这里总结一下，其实雪崩Redis服务基本不可用了，存储层的调用量会暴增，造成存储层也会挂掉的情况，而且雪崩会出现周期性的峰值，因为就算缓存失效了，请求到了存储层，获取到数据后，是会再做一次缓存的，所以会出现周期性峰值。

致命的原因是存储层在暴增的情况下扛不住调用后，导致数据库直接挂掉了。

有什么解决措施？

嗯？我们可以对那个 key 的缓存时间设置更长一些，缓存雪崩导致的原因是因为太过于集中失效，导致暴增，那么如果我们均摊一下时间，就能避免出现该情况，所以我们可以对缓存时效设置的更随机性一些，且对一些热点数据缓存时间设置永久性。

ConCurrentHashMap底层原理透析

2022-08-06T05:56:54.000Z

创作宗旨：化繁为简，绝不冗余，点到为止

ConcurrentHashMap 继承了AbstractMap，实现了ConcurrentMap和Serializable。
说明：
AbstractMap实现了基本的Map操作
ConcurrentMap规范了对k-v的并发操作的方法

一、介绍

ConCurrentHashMap是如何做到线程安全的？
通俗来讲，ConcurrentHashMap已经迭代了几个版本，我们先从JDK7说起,起初为了实现了对HashMap真正意义上的并发，在ConcurrentHashMap引入了一个静态内部类Segment(段)，而且ConcurrentHashMap也聚合了一个Segment的成员变量数组来维护，每一个Segment数组的下标元素相当于一个HashMap，也就是一个HashEntry数组 + 每位下标元素构成一个HashEntry链的头结点（依旧保存值），每次存在线程安全的操作都会去使用该数组的其中一个下标，并锁住该下标（其他线程无法访问），而不同[下标之间的操作是不会相互影响的，也就不存在冲突的情况。
Segment继承了ReentrantLock（可重入锁），用法其实用到加锁和解锁，保证每一个线程使用前加锁，使用完成后释放锁。
ConcurrentHashMap中Segment与Entries的示意图

更专业来讲，ConcurrentHashMap使用了分段锁Segment来解决线程安全。
2. JDK7 的 get 和 put 以及扩容

get
get 操作没有任何加锁，所以在ConCurrent是非常高效的。

static final class HashEntry {
        final int hash;
        final K key;
        volatile V value;
        volatile HashEntry next;
}

就算获取key之前value被改变了，由于volatile修饰了value变量，所以对内容是及时更新的，新增和删除操作亦是如此。

public V get(Object key) {
    Segment s; // manually integrate access methods to reduce overhead
    HashEntry[] tab;
    int h = hash(key);
    long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
    // Concurrent 初始化时会初始 Segment数组和 第 0 位下标即Segment[0]（包括 HashEntry数组 的初始化）
    // 如果 segment 对应的 HashEntry 数组不为空，则往下遍历
    if ((s = (Segment)UNSAFE.getObjectVolatile(segments, u)) != null &&
        (tab = s.table) != null) {
        // 遍历 HashEntry 数组 哈希命中的下标元素（链表）
        for (HashEntry e = (HashEntry) UNSAFE.getObjectVolatile
             (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
             e != null; e = e.next) {
            K k;
            // 如果找到了 key就返回对应的value，否则往下继续遍历链表
            // 这里前面匹配的是 基本数据类型，
            //如果是 复杂对象，则使用的是先 hash筛选桶下标，相等再去 比较 “值”
            if ((k = e.key) == key || (e.hash == h && key.equals(k)))
                return e.value;
        }
    }
    return null;
}

post
在ConcurrentHashMap中post操作是不允许设置value为null。
Concurrent初始化时会初始Segment数组和第0位下标即Segment[0]（其中包括HashEntry数组的初始化），所以这里会出现命中到另外15个未初始化的Segment锁段，即当前Segment为null的情况

public V put(K key, V value) {
    Segment s;
    // 不允许对 value 设置为 null
    if (value == null)
        throw new NullPointerException();
    int hash = hash(key);
    int j = (hash >>> segmentShift) & segmentMask;
    // 没有找到，即说明未初始化
    if ((s = (Segment)UNSAFE.getObject          // nonvolatile; recheck
         (segments, (j << SSHIFT) + SBASE)) == null) //  in ensureSegment
        // 初始化当前 Segment 对应的 HashEntry 数组
        s = ensureSegment(j);
    return s.put(key, hash, value, false);
}

post细节

final V put(K key, int hash, V value, boolean onlyIfAbsent) {
    // 尝试加锁
    HashEntry node = tryLock() ? null :
    // 如果不成功, 进入 scanAndLockForPut 流程
    // 如果是多核 cpu 最多 tryLock 64 次, 进入 lock 流程
    // 在尝试期间, 还可以顺便看该节点在链表中有没有, 如果没有顺便创建出来
    scanAndLockForPut(key, hash, value);
    // 执行到这里 segment 已经被成功加锁, 可以安全执行
    V oldValue;
    try {
        HashEntry[] tab = table;
        int index = (tab.length - 1) & hash;
        HashEntry first = entryAt(tab, index);
        for (HashEntry e = first;;) {
            if (e != null) {
                // 更新
                K k;
                if ((k = e.key) == key ||
                    (e.hash == hash && key.equals(k))) {
                    oldValue = e.value;
                    if (!onlyIfAbsent) {
                        e.value = value;
                        ++modCount;
                    }
                    break;
                }
                e = e.next;
            }
            else {
                // 新增
                // 1) 之前等待锁时, node 已经被创建, next 指向链表头
                if (node != null)
                    node.setNext(first);
                else
                    // 2) 创建新 node
                    node = new HashEntry(hash, key, value, first);
                int c = count + 1;
                // 3) 扩容
                // 必须 是 达到阈值 并且 HashEntry 数组还没被扩容，也就是长度依旧是旧值
                if (c > threshold && tab.length < MAXIMUM_CAPACITY)
                    rehash(node);
                else
                    // tab已更新，即扩容已经完毕，将 node 作为链表头
                    setEntryAt(tab, index, node);
                ++modCount;
                count = c;
                oldValue = null;
                break;
            }
        }
    } finally {
        unlock();
    }
    return oldValue;
}

扩容

private void rehash(HashEntry node) {
    // 每个 Segment 对应的一个 HashEntry数组
    HashEntry[] oldTable = table;
    // 扩容前 HashEntry数组的长度
    int oldCapacity = oldTable.length;
    // 扩容后 HashEntry数组的长度 = 扩容前 HashEntry数组的长度 * 2
    int newCapacity = oldCapacity << 1;
    // 扩容阈值的元素数量，HashEntry数组 中元素的个数到 某个数量（低于最大数）时的数量
    threshold = (int)(newCapacity * loadFactor);
    // 初始化一个新的 HashEntry 数组，每个下标表示的 HashEntry 都为 null，后面会用到这个 null 做头插法 put 元素
    HashEntry[] newTable =
        (HashEntry[]) new HashEntry[newCapacity];
    // hash 命中 & 操作要用的掩码（计算hash结果的长度）
    int sizeMask = newCapacity - 1;
    // 遍历 扩容前 HashEntry数组
    for (int i = 0; i < oldCapacity ; i++) {
        HashEntry e = oldTable[i];
        if (e != null) {
            HashEntry next = e.next;
            int idx = e.hash & sizeMask;
            // 当前 HashEntry数组 下标只有一个元素，则直接赋值给 新数组对应下标
            // 这里对应的新的下标跟 原下标已经不一样了，因为是按照 扩容后 的长度来计算得到的
            if (next == null)   //  Single node on list
                newTable[idx] = e;
            // 如果链表长度 大于等于两个元素以上
            else { // Reuse consecutive sequence at same slot
                HashEntry lastRun = e;
                int lastIdx = idx;
                // 重用 链表最后面 新命中值 相同的
                for (HashEntry last = next;
                     last != null;
                     last = last.next) {
                    int k = last.hash & sizeMask;
                    if (k != lastIdx) {
                        lastIdx = k;
                        lastRun = last;
                    }
                }
                // 将重用的链表头结点 转移到 新的 数组中
                newTable[lastIdx] = lastRun;
                // Clone remaining nodes
                // 链表剩下的 部分，挨个按照头插法 命中到 新的数组中 
                for (HashEntry p = e; p != lastRun; p = p.next) {
                    V v = p.value;
                    int h = p.hash;
                    int k = h & sizeMask;
                    HashEntry n = newTable[k];
                    newTable[k] = new HashEntry(h, p.key, v, n);
                }
            }
        }
    }
    // 最后再 把要 put 的值 头插法 加入到 新的数组中
    int nodeIndex = node.hash & sizeMask; // add the new node
    node.setNext(newTable[nodeIndex]);
    newTable[nodeIndex] = node;
    // 这里通过 暂时 数组操作完毕再 赋值，能够避免操作中途 被其他 线程再次重复操作
    // 在这之前 其他 线程无法进入
    // 一赋值 其他线程 就算判断 达到阈值，但newTable 的大小改变
    // tab.length < MAXIMUM_CAPACITY 也会让 其他线程直接去 新的数组 put 操作
    table = newTable;
}

JDK8抛弃了Segment分段锁，转而使用CAS+synchronized来保证并发安全性。
并且，不再单纯使用链表，JDK8在HashEntry数组中的链表长度大于8的时候会去转化为红黑树结构。
在这里，链表长度大于8时，才会去进一步判断阈值是否达到。
与JDK7扩容的区别在上一篇深入浅出~HashMap的底层原理透析详细讲过了，其实与ConCurrentHashMap大同小异，也就是多做了CAS的操作、链表转化红黑树和等待的put会帮忙扩容。

二、附语

谢谢大家，我会继续努力，只为力争创作高质量的文章，分享给各位有需要的读者。
你们的阅读和评论是对作者最大的支持！
我的技术专栏：https://github.com/fyupeng

专注品质，热爱生活。
交流技术，寻求同志。

贪心算法

2022-08-06T03:57:51.000Z

贪心算法

1. 455. 分发饼干

问题

假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。

对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j] 。如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。

示例 1:

输入: g = [1,2,3], s = [1,1]
输出: 1
解释: 
你有三个孩子和两块小饼干，3个孩子的胃口值分别是：1,2,3。
虽然你有两块小饼干，由于他们的尺寸都是1，你只能让胃口值是1的孩子满足。
所以你应该输出1。

示例 2:

输入: g = [1,2], s = [1,2,3]
输出: 2
解释: 
你有两个孩子和三块小饼干，2个孩子的胃口值分别是1,2。
你拥有的饼干数量和尺寸都足以让所有孩子满足。
所以你应该输出2.

提示：

1 <= g.length <= 3 * 104
0 <= s.length <= 3 * 104
1 <= g[i], s[j] <= 231 - 1

代码

class Solution {
    public int findContentChildren(int[] g, int[] s) {
        Arrays.sort(g);
        Arrays.sort(s);
        int index = 0;
        int result = 0;
        for(int i = 0; i < g.length && index < s.length; i++){
            if(g[i] <= s[index]) {
                // 吃掉
                result++;
            } else {
                i--;
            }
            index++;
        }
        return result;
    }
}

2. 376. 摆动序列

问题

如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为摆动序列。第一个差（如果存在的话）可能是正数或负数。仅有一个元素或者含两个不等元素的序列也视作摆动序列。

例如， [1, 7, 4, 9, 2, 5] 是一个摆动序列，因为差值 (6, -3, 5, -7, 3) 是正负交替出现的。

相反，[1, 4, 7, 2, 5] 和 [1, 7, 4, 5, 5] 不是摆动序列，第一个序列是因为它的前两个差值都是正数，第二个序列是因为它的最后一个差值为零。
子序列可以通过从原始序列中删除一些（也可以不删除）元素来获得，剩下的元素保持其原始顺序。

给你一个整数数组 nums ，返回 nums 中作为摆动序列的最长子序列的长度。

示例 1：

1
2
3

输入：nums = [1,7,4,9,2,5]
输出：6
解释：整个序列均为摆动序列，各元素之间的差值为 (6, -3, 5, -7, 3) 。

示例 2：

输入：nums = [1,17,5,10,13,15,10,5,16,8]
输出：7
解释：这个序列包含几个长度为 7 摆动序列。
其中一个是 [1, 17, 10, 13, 10, 16, 8] ，各元素之间的差值为 (16, -7, 3, -3, 6, -8) 。

示例 3：

1 2	输入：nums = [1,2,3,4,5,6,7,8,9] 输出：2

提示：

1 <= nums.length <= 1000
0 <= nums[i] <= 1000

代码

贪心法

class Solution {
    public int wiggleMaxLength(int[] nums) {
        int curDiff = 0;
        int preDiff = 0;
        int result = 1; // 考虑 右 边界值 特殊情况
        for(int i = 0; i < nums.length - 1; i++) {
            // 考虑了 左边界值 特殊情况
            curDiff = nums[i] - nums[i + 1];
            if(curDiff < 0 && preDiff >= 0 || curDiff > 0 && preDiff <= 0) {
                result++;
                preDiff = curDiff;
            }
        }
        return result;
    }
}

动态规划

class Solution {
    public int wiggleMaxLength(int[] nums) {
        int n = nums.length;
        if(n < 2) return n;
        int up = 1;
        int down = 1;
        for(int i = 1; i < n; i++) {
            if(nums[i] < nums[i - 1]) {
                down = up + 1;
            }
            if(nums[i] > nums[i - 1]) {
                up = down + 1;
            }
        }
        return Math.max(up, down);
    }
}

3. 53. 最大子数组和

问题

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

子数组是数组中的一个连续部分。

示例 1：

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

示例 2：

1 2	输入：nums = [1] 输出：1

示例 3：

1 2	输入：nums = [5,4,-1,7,8] 输出：23

提示：

1 <= nums.length <= 105
-104 <= nums[i] <= 104

代码

class Solution {
    public int maxSubArray(int[] nums) {
        int res = - 10000;
        int sum = 0;
        for(int i = 0; i < nums.length; i++) {
            sum += nums[i];
            if(sum > res) {
                res = sum;
            }
            if(sum < 0) {
                sum = 0;
            }      
        }
        return res;
    }
}

4. 122. 买卖股票的最佳时机 II

问题

给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。

在每一天，你可以决定是否购买和/或出售股票。你在任何时候最多只能持有一股股票。你也可以先购买，然后在 同一天 出售。

返回你能获得的最大利润。

示例 1：

输入：prices = [7,1,5,3,6,4]
输出：7
解释：在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。
     随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3 。
     总利润为 4 + 3 = 7 。

示例 2：

输入：prices = [1,2,3,4,5]
输出：4
解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。
     总利润为 4 。

示例 3：

1
2
3

输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 交易无法获得正利润，所以不参与交易可以获得最大利润，最大利润为 0 。

提示：

1 <= prices.length <= 3 * 104
0 <= prices[i] <= 104

代码

直接写法

class Solution {
    public int maxProfit(int[] prices) {
        if(prices.length < 2) {
            return 0;
        }
        int res = 0;
        for(int i = 0; i < prices.length - 1; i++) {
            int pricesDiff = prices[i + 1] - prices[i];
            if(pricesDiff > 0) {
                res += pricesDiff;
            }
        }
        return res;
    }
}

贪心写法

class Solution {
    public int maxProfit(int[] prices) {
        if(prices.length < 2) {
            return 0;
        }
        int res = 0;
        for(int i = 0; i < prices.length - 1; i++) {
            res += Math.max(prices[i + 1] - prices[i], 0);
        }
        return res;
    }
}

动态规划

class Solution {
    public int maxProfit(int[] prices) {
        int n = prices.length;
        if(n < 2) {
            return 0;
        }
        int[][] dp = new int[n][2];
        // 表示 买进第 0 天的股
        dp[0][0] -= prices[0];
        //默认初始：dp[0][1] = 0; 表示初始收益为 0 
        for(int i = 1; i < n; i++) {
            // 股票下跌，买进
            dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
            // 股票上涨，卖出
            dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
        }
        return Math.max(dp[n - 1][0], dp[n - 1][1]);
    }
}

5. 55. 跳跃游戏

问题

给定一个非负整数数组 nums ，你最初位于数组的 第一个下标 。

数组中的每个元素代表你在该位置可以跳跃的最大长度。

判断你是否能够到达最后一个下标。

示例 1：

1
2
3

输入：nums = [2,3,1,1,4]
输出：true
解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。

示例 2：

1
2
3

输入：nums = [3,2,1,0,4]
输出：false
解释：无论怎样，总会到达下标为 3 的位置。但该下标的最大跳跃长度是 0 ， 所以永远不可能到达最后一个下标。

提示：

1 <= nums.length <= 3 * 104
0 <= nums[i] <= 105

代码

class Solution {
    public boolean canJump(int[] nums) {
        if(nums.length == 1) return true;
        // 可到达的 最长下标
        int cover = 0;
        for(int i = 0; i <= cover; i++) {
            cover = Math.max(cover, i + nums[i]);
            if(cover >= nums.length - 1) return true;
        }
        return false;
    }
}

6. 45. 跳跃游戏 II

问题

给你一个非负整数数组 nums ，你最初位于数组的第一个位置。

数组中的每个元素代表你在该位置可以跳跃的最大长度。

你的目标是使用最少的跳跃次数到达数组的最后一个位置。

假设你总是可以到达数组的最后一个位置。

示例 1:

输入: nums = [2,3,1,1,4]
输出: 2
解释: 跳到最后一个位置的最小跳跃数是 2。
     从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。

示例 2:

1 2	输入: nums = [2,3,0,1,4] 输出: 2

提示:

1 <= nums.length <= 104
0 <= nums[i] <= 1000

代码

版本一

class Solution {
    public int jump(int[] nums) {
        if(nums.length == 1) {
            return 0;
        }
        int curDistance = nums[0];
        int nextDistance = 0;
        int ans = 0;;
        int n = nums.length;
        for(int i = 0; i < n; i++) {
            nextDistance = Math.max(nextDistance, nums[i] + i);
            // 如果当前 最远步长 已经达到终点下标了，
            if(curDistance >= n - 1) {
                ans++;
                break;
            }
            //否则 看是否已经 满足 当前下标是 最远步长
            // 主要是为了更新 nextDistance 为 在当前下标到 最远步长中 找到 下一个最远步长下标最远的
            if(i == curDistance) {
                ans++;          
                curDistance = nextDistance;            
            }
        }
        return ans;
    }
}

版本二

class Solution {
    public int jump(int[] nums) {
        if(nums.length == 1) {
            return 0;
        }
        int curDistance = 0;
        int nextDistance = 0;
        int ans = 0;;
        int n = nums.length;
        for(int i = 0; i < n - 1; i++) {
            nextDistance = Math.max(nextDistance, nums[i] + i);
            //否则 看是否已经 满足 当前下标是 最远步长
            // 主要是为了更新 nextDistance 为 在当前下标到 最远步长中 找到 下一个最远步长下标最远的
            if(i == curDistance) {
                ans++;          
                curDistance = nextDistance;            
            }
        }
        return ans;
    }
}

7. 1005. K 次取反后最大化的数组和

问题

给你一个整数数组 nums 和一个整数 k ，按以下方法修改该数组：

选择某个下标 i 并将 nums[i] 替换为 -nums[i] 。
重复这个过程恰好 k 次。可以多次选择同一个下标 i 。

以这种方式修改数组后，返回数组可能的最大和。

示例 1：

输入：nums = [4,2,3], k = 1
输出：5
解释：选择下标 1 ，nums 变为 [4,-2,3] 。

示例 2：

1
2
3

输入：nums = [3,-1,0,2], k = 3
输出：6
解释：选择下标 (1, 2, 2) ，nums 变为 [3,1,0,2] 。

示例 3：

1
2
3

输入：nums = [2,-3,-1,5,-4], k = 2
输出：13
解释：选择下标 (1, 4) ，nums 变为 [2,3,-1,5,4] 。

提示：

1 <= nums.length <= 104
-100 <= nums[i] <= 100
1 <= k <= 104

代码

绝对值排序

class Solution {
    public int largestSumAfterKNegations(int[] nums, int k) {
        nums = IntStream.of(nums).boxed().sorted((t1, t2) -> Math.abs(t2) - Math.abs(t1)).mapToInt(Integer::intValue).toArray();
        for(int i = 0; i < nums.length; i++) {
            if(nums[i] < 0 && k > 0) {
                nums[i] = - nums[i];
                k--;
            }
        }
        if(k % 2 == 1) {
            nums[nums.length - 1] = - nums[nums.length - 1];
        }
        return Arrays.stream(nums).sum();
    }
}

从小到大排序

class Solution {
    public int largestSumAfterKNegations(int[] nums, int k) {
        int n = nums.length;
        if(n == 1) return k % 2 == 0 ? nums[0] : -nums[0];
        int sum = 0;
        int index = 0;
        Arrays.sort(nums);
        for(int i = 0; i < k; i++) {
            if(i < nums.length - 1 && nums[i] < 0) {
                nums[i] = -nums[i];
                if(nums[i] >= Math.abs(nums[i + 1])) index++;
                continue;
            }
            nums[index] = -nums[index];
        }

        for(int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        return sum;
    }
}

8. 134. 加油站

问题

在一条环路上有 n 个加油站，其中第 i 个加油站有汽油 gas[i] 升。

你有一辆油箱容量无限的的汽车，从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i] 升。你从其中的一个加油站出发，开始时油箱为空。

给定两个整数数组 gas 和 cost ，如果你可以绕环路行驶一周，则返回出发时加油站的编号，否则返回 -1 。如果存在解，则 保证 它是 唯一 的。

示例 1:

输入: gas = [1,2,3,4,5], cost = [3,4,5,1,2]
输出: 3
解释:
从 3 号加油站(索引为 3 处)出发，可获得 4 升汽油。此时油箱有 = 0 + 4 = 4 升汽油
开往 4 号加油站，此时油箱有 4 - 1 + 5 = 8 升汽油
开往 0 号加油站，此时油箱有 8 - 2 + 1 = 7 升汽油
开往 1 号加油站，此时油箱有 7 - 3 + 2 = 6 升汽油
开往 2 号加油站，此时油箱有 6 - 4 + 3 = 5 升汽油
开往 3 号加油站，你需要消耗 5 升汽油，正好足够你返回到 3 号加油站。
因此，3 可为起始索引。

示例 2:

输入: gas = [2,3,4], cost = [3,4,3]
输出: -1
解释:
你不能从 0 号或 1 号加油站出发，因为没有足够的汽油可以让你行驶到下一个加油站。
我们从 2 号加油站出发，可以获得 4 升汽油。 此时油箱有 = 0 + 4 = 4 升汽油
开往 0 号加油站，此时油箱有 4 - 3 + 2 = 3 升汽油
开往 1 号加油站，此时油箱有 3 - 3 + 3 = 3 升汽油
你无法返回 2 号加油站，因为返程需要消耗 4 升汽油，但是你的油箱只有 3 升汽油。
因此，无论怎样，你都不可能绕环路行驶一周。

提示:

gas.length == n
cost.length == n
1 <= n <= 105
0 <= gas[i], cost[i] <= 104

代码

暴力法

class Solution {
    public int canCompleteCircuit(int[] gas, int[] cost) {
        int curGas = 0;
        for(int i = 0; i < gas.length; i++) {
            curGas = gas[i] - cost[i];
            int index = (i + 1) % gas.length;
            while(curGas >= 0 && index != i) {
                curGas += gas[index] - cost[index];
                index = (index + 1) % gas.length;
            }
            if(curGas >= 0) {
                return i;
            }
        }
        return -1;
    }
}

贪心算法1

class Solution {
    public int canCompleteCircuit(int[] gas, int[] cost) {
        int curSum = 0;
        int min = Integer.MAX_VALUE;
        for(int i = 0; i < gas.length; i++) {
            int res = gas[i] - cost[i];
            curSum += res;
            if(curSum < min) {
                min = curSum;
            }
        }
        if(curSum < 0) return -1;
        if(min >= 0) return 0;
        for(int i = gas.length - 1; i >= 0; i--) {
            int res = gas[i] - cost[i];
            min += res;
            if(min >= 0) return i;
        }
        return -1;
    }
}

贪心算法2

class Solution {
    public int canCompleteCircuit(int[] gas, int[] cost) {
        int curSum = 0;
        int totalSum = 0;
        int startIndex = 0;
        for(int i = 0; i < gas.length; i++) {
            int res = gas[i] - cost[i];
            curSum += res;
            totalSum += res;
            if(curSum < 0) {
                startIndex = i + 1;
                curSum = 0;
            }     
        }
        if(totalSum < 0) return -1;
        return startIndex;

    }
}

9. 135. 分发糖果

问题

n 个孩子站成一排。给你一个整数数组 ratings 表示每个孩子的评分。

你需要按照以下要求，给这些孩子分发糖果：

每个孩子至少分配到 1 个糖果。
相邻两个孩子评分更高的孩子会获得更多的糖果。
请你给每个孩子分发糖果，计算并返回需要准备的 最少糖果数目 。

示例 1：

1
2
3

输入：ratings = [1,0,2]
输出：5
解释：你可以分别给第一个、第二个、第三个孩子分发 2、1、2 颗糖果。

示例 2：

输入：ratings = [1,2,2]
输出：4
解释：你可以分别给第一个、第二个、第三个孩子分发 1、2、1 颗糖果。
第三个孩子只得到 1 颗糖果，这满足题面中的两个条件。

提示：

n == ratings.length
1 <= n <= 2 * 104
0 <= ratings[i] <= 2 * 104

代码

class Solution {
    public int candy(int[] ratings) {
        if(ratings.length == 1) {
            return 1;
        }
        int n = ratings.length;
        int[] candyArg = new int[n];
        for(int i = 0; i < n; i++) {
            candyArg[i] = 1;
        }
        for(int i = 0; i < n - 1; i++) {
            if(ratings[i + 1] > ratings[i]) candyArg[i + 1] = candyArg[i] + 1;
        }
        for(int i = n - 2; i >= 0; i--) {
            if(ratings[i] > ratings[i + 1]) candyArg[i] = Math.max(candyArg[i], candyArg[i + 1] + 1);
        }
        int sum = 0;
        for(int i = 0;  i < n; i++) {
            sum += candyArg[i];
        }
        return sum;
    }
}

10. 860. 柠檬水找零

问题

在柠檬水摊上，每一杯柠檬水的售价为 5 美元。顾客排队购买你的产品，（按账单 bills 支付的顺序）一次购买一杯。

每位顾客只买一杯柠檬水，然后向你付 5 美元、10 美元或 20 美元。你必须给每个顾客正确找零，也就是说净交易是每位顾客向你支付 5 美元。

注意，一开始你手头没有任何零钱。

给你一个整数数组 bills ，其中 bills[i] 是第 i 位顾客付的账。如果你能给每位顾客正确找零，返回 true ，否则返回 false 。

示例1：

输入：bills = [5,5,5,10,20]
输出：true
解释：
前 3 位顾客那里，我们按顺序收取 3 张 5 美元的钞票。
第 4 位顾客那里，我们收取一张 10 美元的钞票，并返还 5 美元。
第 5 位顾客那里，我们找还一张 10 美元的钞票和一张 5 美元的钞票。
由于所有客户都得到了正确的找零，所以我们输出 true。

示例2：

输入：bills = [5,5,10,10,20]
输出：false
解释：
前 2 位顾客那里，我们按顺序收取 2 张 5 美元的钞票。
对于接下来的 2 位顾客，我们收取一张 10 美元的钞票，然后返还 5 美元。
对于最后一位顾客，我们无法退回 15 美元，因为我们现在只有两张 10 美元的钞票。
由于不是每位顾客都得到了正确的找零，所以答案是 false。

提示：

1 <= bills.length <= 105
bills[i] 不是 5 就是 10 或是 20

代码

class Solution {
    public boolean lemonadeChange(int[] bills) {
        int five = 0, ten = 0, twenty = 0;
        for(int i = 0; i < bills.length; i++) {
            if(bills[i] == 5) {
                five++;
            }
            if(bills[i] == 10) {
                if(five <= 0) return false;
                ten++;
                five--;
            }
            if(bills[i] == 20) {
                if(five > 0 && ten > 0) {
                    five--;
                    ten--;
                    twenty++;
                } else if(five >= 3) {
                    five -= 3;
                    twenty++;
                } else {
                    return false;
                }
            }
        }
        return true;
    }
}

11. 406. 根据身高重建队列

问题

假设有打乱顺序的一群人站成一个队列，数组 people 表示队列中一些人的属性（不一定按顺序）。每个 people[i] = [hi, ki] 表示第 i 个人的身高为 hi ，前面正好有 ki 个身高大于或等于 hi 的人。

请你重新构造并返回输入数组 people 所表示的队列。返回的队列应该格式化为数组 queue ，其中 queue[j] = [hj, kj] 是队列中第 j 个人的属性（queue[0] 是排在队列前面的人）。

示例 1：

输入：people = [[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]]
输出：[[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]]
解释：
编号为 0 的人身高为 5 ，没有身高更高或者相同的人排在他前面。
编号为 1 的人身高为 7 ，没有身高更高或者相同的人排在他前面。
编号为 2 的人身高为 5 ，有 2 个身高更高或者相同的人排在他前面，即编号为 0 和 1 的人。
编号为 3 的人身高为 6 ，有 1 个身高更高或者相同的人排在他前面，即编号为 1 的人。
编号为 4 的人身高为 4 ，有 4 个身高更高或者相同的人排在他前面，即编号为 0、1、2、3 的人。
编号为 5 的人身高为 7 ，有 1 个身高更高或者相同的人排在他前面，即编号为 1 的人。
因此 [[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]] 是重新构造后的队列。

示例 2：

1 2	输入：people = [[6,0],[5,0],[4,0],[3,2],[2,2],[1,4]] 输出：[[4,0],[5,0],[2,2],[3,2],[1,4],[6,0]]

提示：

1 <= people.length <= 2000
0 <= hi <= 106
0 <= ki < people.length
题目数据确保队列可以被重建

代码

class Solution {
    public int[][] reconstructQueue(int[][] people) {
        int length = people.length;
        Arrays.sort(people, new Comparator<int[]>(){
            public int compare(int[] people1, int[] people2) {
                // 从大到小 排序
                if(people2[0] == people1[0]) {
                    return people1[1] - people2[1];
                }else {
                    return people2[0] - people1[0];
                }
            }
        });
        for(int i = 0; i < length; i++) {
            inset(people, i, people[i][1]);
        }
        return people;
    }

    private void inset(int[][] people, int sourceIndex,  int destIndex) {
        int[] temp = people[sourceIndex];
        if(sourceIndex <= destIndex) {
            for(int i = sourceIndex; i < destIndex; i++) {
                people[i] = people[i + 1];
            }
            people[destIndex] = temp;
        } else {
            for(int i = sourceIndex; i > destIndex; i--) {
                people[i] = people[i - 1];
            }
            people[destIndex] = temp;
        }
    }
}

12. 452. 用最少数量的箭引爆气球

问题

有一些球形气球贴在一堵用 XY 平面表示的墙面上。墙面上的气球记录在整数数组 points ，其中points[i] = [xstart, xend] 表示水平直径在 xstart 和 xend之间的气球。你不知道气球的确切 y 坐标。

一支弓箭可以沿着 x 轴从不同点完全垂直地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 xstart，xend，且满足 xstart ≤ x ≤ xend，则该气球会被引爆。可以射出的弓箭的数量没有限制。弓箭一旦被射出之后，可以无限地前进。

给你一个数组 points ，返回引爆所有气球所必须射出的最小弓箭数。

示例 1：

输入：points = [[10,16],[2,8],[1,6],[7,12]]
输出：2
解释：气球可以用2支箭来爆破:
-在x = 6处射出箭，击破气球[2,8]和[1,6]。
-在x = 11处发射箭，击破气球[10,16]和[7,12]。

示例 2：

1
2
3

输入：points = [[1,2],[3,4],[5,6],[7,8]]
输出：4
解释：每个气球需要射出一支箭，总共需要4支箭。

示例 3：

输入：points = [[1,2],[2,3],[3,4],[4,5]]
输出：2
解释：气球可以用2支箭来爆破:
- 在x = 2处发射箭，击破气球[1,2]和[2,3]。
- 在x = 4处射出箭，击破气球[3,4]和[4,5]。

提示:

1 <= points.length <= 105
points[i].length == 2
-231 <= xstart < xend <= 231 - 1

代码

class Solution {
    public int findMinArrowShots(int[][] points) {
        Arrays.sort(points, (a,b) -> {
            if(a[0] != b[0]) {
                return (long)a[0] - (long)b[0] > 0 ? 1 : -1;
            }
            return  (long)a[0] - (long)b[0] > 0 ? 1 : -1;
        });
        int count = 0;
        for(int i = 1; i < points.length; i++) {
            if(points[i][0] > points[i - 1][1]) {
                count++;
            } else {
                points[i][1] = Math.min(points[i][1], points[i - 1][1]);
            }
        }
        return count + 1;
    }
}

先排序（按元素0号下标升序）后贪左边，因为排完后，前面的肯定包含后面的元素，再去贪右边边界，贪最小边界。

13. 435. 无重叠区间

问题

给定一个区间的集合 intervals ，其中 intervals[i] = [starti, endi] 。返回需要移除区间的最小数量，使剩余区间互不重叠。

示例 1:

1
2
3

输入: intervals = [[1,2],[2,3],[3,4],[1,3]]
输出: 1
解释: 移除 [1,3] 后，剩下的区间没有重叠。

示例 2:

1
2
3

输入: intervals = [ [1,2], [1,2], [1,2] ]
输出: 2
解释: 你需要移除两个 [1,2] 来使剩下的区间没有重叠。

示例 3:

1
2
3

输入: intervals = [ [1,2], [2,3] ]
输出: 0
解释: 你不需要移除任何区间，因为它们已经是无重叠的了。

提示:

1 <= intervals.length <= 105
intervals[i].length == 2
-5 * 104 <= starti < endi <= 5 * 104

代码

class Solution {
    public int eraseOverlapIntervals(int[][] intervals) {
        // 对右区间升序，
        Arrays.sort(intervals, (a,b) -> {
            return a[1] - b[1];
        });
        int removeCount = 0;
        for(int i = 1; i < intervals.length; i++) {
            if(intervals[i][0] < intervals[i - 1][1]) {
                removeCount++;
                // 更新当前状态下不重叠右区间上限
                // 不用理会两个区间中间可能留下的空白区域，因为已经排序
                // 所以后面的区间不会重叠中间那块空白区域
                intervals[i][1] = intervals[i - 1][1];
            }
        }
        return removeCount;
    }
}

14. 714. 买卖股票的最佳时机含手续费

问题

给定一个整数数组 prices，其中 prices[i]表示第 i 天的股票价格；整数 fee 代表了交易股票的手续费用。

你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。

返回获得利润的最大值。

注意：这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。

示例 1：

输入：prices = [1, 3, 2, 8, 4, 9], fee = 2
输出：8
解释：能够达到的最大利润:  
在此处买入 prices[0] = 1
在此处卖出 prices[3] = 8
在此处买入 prices[4] = 4
在此处卖出 prices[5] = 9
总利润: ((8 - 1) - 2) + ((9 - 4) - 2) = 8

示例 2：

1 2	输入：prices = [1,3,7,5,10,3], fee = 3 输出：6

提示：

1 <= prices.length <= 5 * 104
1 <= prices[i] < 5 * 104
0 <= fee < 5 * 104

代码

class Solution {
    public int maxProfit(int[] prices, int fee) {
        // 买入是先 算手续费，buy 是买入+手续费
        int buy = prices[0] + fee;
        int result = 0;
        for(int i = 1; i < prices.length; i++) {
            // buy 已经更新为能否继续收益的更高水准
            // 如果不能继续收益了，也就是跌股了，那就卖掉上一股，重新买入新股
            // 因为相比 同一股 会有更大的收益
            if(prices[i] + fee < buy) {
                buy = prices[i] + fee;
            }
            if(prices[i] > buy) {
                result += prices[i] - buy;
                // 连续涨股就持股
                buy = prices[i];
            }
        }
        return result;
    }
}

15. 968. 监控二叉树

问题

给定一个二叉树，我们在树的节点上安装摄像头。

节点上的每个摄影头都可以监视其父对象、自身及其直接子对象。

计算监控树的所有节点所需的最小摄像头数量。

示例 1：

1
2
3

输入：[0,0,null,0,0]
输出：1
解释：如图所示，一台摄像头足以监控所有节点。

示例 2：

1
2
3

输入：[0,0,null,0,null,0,null,null,0]
输出：2
解释：需要至少两个摄像头来监视树的所有节点。 上图显示了摄像头放置的有效位置之一。

提示：

给定树的节点数的范围是 [1, 1000]。
每个节点的值都是 0。

代码

class Solution {
    int res = 0;
    public int minCameraCover(TreeNode root) {
        if(traversal(root) == 0) return ++res;
        return res;
    }
    // 0 - 无覆盖 1 - 有摄像头 2 - 有覆盖
    private int traversal(TreeNode node) {
        // 终止条件
        if(node == null) return 2;

        // 后序递归遍历
        int left = traversal(node.left);
        int right = traversal(node.right);
        // 设置叶子节点为 未覆盖，或者是 两个子节点均已覆盖。那么设置该节点为未覆盖
        if(left == 2 && right == 2) {
            return 0;
        }
        // 存在子节点还未覆盖，该节点设置摄像头
        if(left == 0 || right == 0) {
            res++;
            return 1;
        }
        // 子节点有摄像头，该节点设置为覆盖
        if(left == 1 || right == 1) {
            return 2;
        }
        // 因为逻辑返回需要，虽然不会到这一步但还是要写
        return -1;
    }
}

HashMap底层原理透析

2022-07-31T05:50:18.000Z

创作宗旨：化繁为简，绝不冗余，点到为止

直接开门见山，就事论事！

什么是 HashMap?

HashMap类继承了父类AbstractMap，实现了接口Map, Cloneable, Serializable,AbstractMap实现了对Map的基本操作，Serializable是序列化接口，可实现序列化，Map接口规范了k-v对操作的抽象方法，Cloneable规范了继承了Object后去使用clone()方法前必须得实现Cloneable接口，否则抛出CloneNotSupportedException错误。

一、介绍

1. HashMap 的线程不安全的场景

死锁

扩容产生死锁的原因关键有两点：
第一点：链表的头插法转移结点，JDK8版本就改成了尾插法；
第二点：多线程环境下，CPU的让出使得头结点的指针指向发生变化，但原线程重新占有CPU时仍然采取原先的做法；
解读：JDK8下使用尾插法，就算头结点已经转移了，但还是在头结点位置，也就是转移前后链表顺序不改变，只是多了一次重复的操作，结果不影响。
我不会用篇幅很长而做这么点事情，没必要，很简单的事 5 幅图就可以啦。
由于HashMap是数组+链表的数据结构，旧桶是指数组下标所在位置。
线程 1 扩容操作

线程 1 转移结点A

线程1结点转移完毕

线程2开始转移结点A
因为是线程2首先要扩容的，不过CPU时间却让给了线程2,线程2也发觉需要扩容，等扩容完毕后再把CPU还给线程1

线程2转移结点A结束，环形链产生，也就是产生死锁。

所以原因的头插法得以佐证，CPU的轮询切换也演绎的很到位。
线程不安全讲完，下面就将原理，去潜移默化它。

2. HashMap 实现哈希命中均匀

哈希也就是k的hashcode计算后得到的下标，而hashcode是一个32位的int类型，要让分布均匀，即让不同的k不能出现有相同的效果，也就是得有唯一性，就要完全去利用高16位和低16位，而如果直接用32位去取模运算，高16就可能会用不到，导致hashcode高16位不同的k依旧命中同一个桶位。
所以JDK8采取的做法是对高16位与低16位进行异或运算，这样就变相保留了高位和低位的所有特征了。
哈希均匀，JDK8之后

1	return (key == null) ? h = key.hashCode() ^ (h >>> 16);

取模运算，JDK7之前

1	h & (length - 1)

3. HashMap 参数以及扩容机制

初始容量16，达到阈值扩容，阈值等于最大容量 * 负载因子，扩容每次2倍，总是2的n次方。

扩容机制
使用一个容量更大的数组来代替已有的容量小的数组，transfer()方法将原有Entry数组元素拷贝到新的Entry数组里，Java1.7重新计算每个元素在数组中的位置。
而Java1.8它不需要重新计算每个元素，它会先比较元素的hashcode & 原来数组的大小的结果，如果为0，就以元素的原下标加入到新数组中，如果为1，就在原下标加上原数组的大小加入到新数组中，这样这两种情况就命中到新数组的前一半和后一半了，也就是将原本全在原数组大小的所有元素又均匀分布一些元素到扩容未使用的下标中。
那么就解释一下，假设加入的元素是随机的，也就是所有情况的hash值是均等出现的，而&原数组大小可以这样比如，有64个元素均等的从0到63，那么0到15分配给了扩容后数组大小为32的左半部分，16-31分配给了右半部分，32-48分配给了左半部分，48-63分配给了右半部分，就比较均匀分散在了两侧，而且机会均等，很巧妙！

// 分布到左侧
if ((e.hash & oldCap) == 0) {
    if (loTail == null)
        loHead = e;
    else
        loTail.next = e;
    loTail = e;
}
// 分布到右侧
else {
    if (hiTail == null)
// 初始化
        hiHead = e;
    else
// 尾插法
        hiTail.next = e;
    // 自增，下次尾插法必要的变量
    hiTail = e;
}

4. HashMap 的 get 和 put 操作

让我们见识下此时无图胜有图的效果吧！

get由源码解读是先获取key的hashCode，然后定位到对应的数组位置，再去遍历该元素处的链表
在这里才讲equals我觉得是最合适的，可以区分它与hashCode的区别，如果hashCode相同的两个元素在同一个数组下标，equals就开始发挥作用了，
不得不说，当然别说我是话痨，我觉得HashMap加入这两个的初衷是如果在一个庞大的Map中，要去get某一个key的value，有一种最直接的做法，就是直接整个Map去equals比较，这没错，而且还是有用的，但加入hashCode之后，hashCode能够给equals先筛选一番，因为不同的key，它的hash值一般是不同的，理解这里的一般，所以hash值不同的equals肯定就不同，就没必要再去对不同下标元素来equals比较了，好理解吧！
由于HashMap中新加入了红黑树，就多了一种get到key的方法，是一种二分法，对于大量数据的链表是不推荐的，所以采用红黑树（总是平衡的二叉树）更加地高效！

put的实现主要针对两种key，一种是不存在的key，一种是已存在的key
局部源码

public V put(K key, V value) {
    //采用hash(key)来计算key的hashCode值。
    return putVal(hash(key), key, value, false, true);
}

static final int hash(Object key) {
    int h;
    //当key等于null的时候，不走hashCode()方法
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

如果为前者，而且key值为null，就在数组下标为0的链表中去寻找key为null的值，当然找不到，就创建key为null的结点。
如果为前者，而且key值不为null，就调用该元素hash计算具体的下标，在该下标的链表中寻找，当然也寻找不到，就尾插法加入该k-v结点。
如果为后者，即找到了，直接赋值就可以了，不需要考虑是否为null。

这里要分开来put是因为，在HashTable上，是不允许有key为null的情况出现，因为当key为null时，key.hashCode()会报空指针异常。
所以在HashMap做了特别的处理，对key为null做了单独处理，这样就解决了key为null的情况。
还有一点，HashMap的value如果设置为null，虽然你put了，但再去取key的时候，依旧是不存在！

二、附语

不足之处请大佬予以佐证，不希望哪个地方出现的错误误导同行，结果闹出笑话来，总之你们的阅读和评论是对作者最大的支持！
谢谢大家，我会继续努力，只为力争创作高质量的文章，分享给各位有需要的读者。
我的技术专栏：https://github.com/fyupeng

专注品质，热爱生活。
交流技术，寻求同志。

fyupeng

利用OpenResty统计网站访问量

系列运维文章目录

前言

一、openresty是什么？

1.核心特点

2.典型应用场景

3.基础示例

4.学习资源

二、使用步骤

1.脚本编写

2.代理配置

3.启动程序

3.1启动OpenResty服务

3.2验证配置

3.3热重载配置不中断服务

3.4接口调试

总结

ES索引重建（零工具纯脚本执行）

第一步：拷贝源索引上的数据 到 临时索引上

第二步：验证临时索引是否创建，数据是否与原数据一致

第三步：删除原索引（谨慎操作，临时索引要保留，为了重建索引）

第四步：波塞冬重新部署 SCS 服务

第五步：临时索引把数据重新复制回新索引

使用EasyExcel自定义导出表格

一、介绍

二、代码

三、总结

使用EasyExcel导出明细数据

一、介绍

二、代码

1. 实体注解

2. 核心代码

三、总结

nacos一键启动、停止、查看状态脚本

一、直接给代码

1. start.sh

2. status.sh

3.stop.sh

二、结束语

vue一键启动、停止、查看状态实用工具

一、直接给代码

1. start.sh

2. stop.sh

3.status.sh

二、结束语

jar包批量启动、查看状态、关闭脚本

一、直接给代码

1. start.sh

2. status.sh

3.stop.sh

二、结束语

宕机检测、重启、告警开发工具

一、直接给代码

1. keepalived.conf

2. notify.sh

3.nginx_check.sh

4.mail.rc

二、效果展示

三、结束语

TCP三次握手和四次挥手

三次握手

四次挥手

牛客必会SQL

1. SQL91 返回购买价格为 10 美元或以上产品的顾客列表

描述

示例1

解法1 - 内联

解法2 - 子查询

2. SQL92 确定哪些订单购买了 prod_id 为 BR01 的产品（一）

描述

示例1

解法1 - 内联

解法2 - 子查询

3. SQL93 返回购买 prod_id 为 BR01 的产品的所有顾客的电子邮件（一）

描述

示例1

解法1

解法2

4. SQL94 返回每个顾客不同订单的总金额

第一步：拷贝源索引上的数据到临时索引上

1.1 `Object`你知道哪些方法?

2.2 了解过 `IOC`吗？