ssh登录

ssh <user_name>@<remote_ip> -p <remote_port> -i <your_key>

ssh端口映射

可以用于不保留端口的情况下,远程连接数据库等。

ssh -N -L <local_port>:localhost:<remote_port> <user_name>@<remote_ip> -p <remote_port> -i <your_key> 

脚本批量映射

需要注意,Nacos有gRPC,除了8848端口外,9848端口也要一起开放。

# Port Mapping
PORTS=(
"ulocalport:localhost:uremoteport"
# MySQL
"53306:localhost:3306"
# Nacos
"58848:localhost:8848"
"59848:localhost:9848"
# Redis
"56379:localhost:6379"
# RocketMQ namesrv
"59876:localhost:9876"
# RocketMQ broker
"510911:localhost:10911"
)

ARGS=()
for port in "${PORTS[@]}"; do
ARGS+=(-L "$port")
done

ssh -o ServerAliveInterval=60 -N "${ARGS[@]}" <username>@<remote_ip>

密钥登录

  1. 首先在本地生成一份密钥,然后将公钥上传到remote的~/.ssh/authorized_keys
  2. 修改remote/etc/ssh/sshd_config
# 新端口
Port 22
# 启用密钥认证
PubkeyAuthentication yes
# 禁用密码登录
PasswordAuthentication no
# 允许Root登录但禁止密码验证
PermitRootLogin prohibit-password
  1. 重启ssh
# Ubuntu/Debian
sudo systemctl restart ssh

# CentOS/RHEL
sudo systemctl restart sshd

线程资源通过线程池提供

线程池可以减少创建、销毁线程的开销,解决资源不足问题。
如果手动创建线程,容易造成系统存在大量同类线程而导致内存耗尽、过度切换问题。

不使用Executors

Executors.newFixedThreadPool() 固定大小线程池
Executors.newSingleThreadExecutor() 单线程池
Executors.newCachedThreadPool() 动态线程池

Executors底层仍然使用new来创建线程,容易造成OOM。

自己调用ThreadPoolExecutor

推荐的方法使,直接自己调用new ThreadPoolExecutor来创建线程池,设置自己的参数

public ThreadPoolExecutor(
@Range(from = 0, to = Integer.MAX_VALUE) int corePoolSize,
@Range(from = 1, to = Integer.MAX_VALUE) int maximumPoolSize,
@Range(from = 0, to = Long.MAX_VALUE) long keepAliveTime,
@NotNull TimeUnit unit,
@NotNull BlockingQueue<Runnable> workQueue,
@NotNull ThreadFactory threadFactory,
@NotNull RejectedExecutionHandler handler
) { ... }

// Example
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
5,
10,
0L,
TimeUnit.SECONDS,
new ArrayBlockingQueue<Runnable>(10), // 10为容量
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy()
);

corePoolSize 核心线程数量。
maximumPoolSize 最大线程数量(核心 + 临时)。只有核心线程满了,而且阻塞队列也满了,才会创建临时线程。
keepAliveTime 临时线程的空闲存活时间。
threadFactory 线程工厂,即以什么方式创建线程。
handler 核心线程、阻塞队列、临时线程都满了,触发拒绝策略。

Executors的问题在于,它指定的阻塞队列大小是Integer.MAX_VALUE,会导致内存溢出;而Executors.newCachedThreadPool()更是指定了maximumPoolSizeInteger.MAX_VALUE

拒绝策略,如何保证线程不丢

使用直接拒绝AbortPolicy策略,线程会丢失。此时可以使用

  • CallerRunsPolicy 直接在主线程同步执行(可能会阻塞主线程)
  • DiscardOldestPolicy 将队列头部删除,新线程尾部入队(保证新任务优先级)
  • DiscardPolicy 可以自己拓展,例如将任务放到redis、rocketmq中

ThreadPool工作流程

当前线程数没有达到corePoolSize之前,每个新任务都会触发创建新线程;
达到以后,才会放到阻塞队列里,等待线程任务执行完成,分发任务给核心线程。
阻塞队列满了,才会创建临时线程执行任务。

ThreadPool如何初始化?

供参考的经验值:

  • CPU密集任务(如数据统计、排序):
    核心线程 = 最大线程 = 核心数 + 1
    减少上下文切换开销
  • IO密集任务:
    核心线程 = 核心数 * 2;最大线程 = 核心数 * 4

动态线程池

参考教程: https://www.ruanyifeng.com/blog/2019/10/tmux.html
  • tmux使会话与窗口解绑,一个窗口source .bashrc更新了,另一个窗口可能没有
  • ctrl+b 前缀键
    % 分成左右两栏
    " 分成上下两栏
    up 选择上边的窗口
    [ 查看历史记录

窗口

  • <C-d> 删除窗口
  • <C-b> z 最大化/最小化一个窗口
  • <C-b> c 创建一个新的窗口,使用 <C-d>关闭
  • <C-b> N 跳转到第 N 个窗口,注意每个窗口都是有编号的
  • <C-b> p 切换到前一个窗口
  • <C-b> n 切换到下一个窗口
  • <C-b> w 列出当前所有窗口

Tmux-Path 双向绑定

使用tmux会存在一个问题:在1个窗口设置了环境变量,在其他窗口并不会生效。
下面的脚本会帮助我们解决问题,它将tmux白名单内的全局变量值自动同步到Shell环境变量。

阅读全文 »

Shortcuts 快捷键

  • CTRL+N|P 下、上一条命令
  • CTRL+A|E 跳到行首、行尾
  • ALT+F|BCTRL+←|→ 下、上一个单词(右ALT开始使用~)
  • CTRL+W 删除前面的单词
  • CTRL+D|H 删除一个字符(D向后删除=Delete,H向前删除=Backspace)
  • CTRL+U 删除整行
  • CTRL+R 搜索整行,Esc退出

Proxy

export https_proxy=http://host:port;
export http_proxy=http://host:port;
export all_proxy=socks5://host:port;

Bash prompt string配置

使用Windows CMD比使用MinTTY更快!

  • PS(prompt string): 是命令行的默认显示文本,如:
username@hostname /work_directory
$
  • 可以在~/.bash_profile.bashrc中修改默认显示(Windows Git Bash是git-prompt.sh
# Windows Git Bash默认配置,其中\007前面的$TITLEPREFIX和$PWD是标签栏的内容,git_ps1会显示git工作分支
export PS1='\[\e]0;$TITLEPREFIX:$PWD\007\]\n\[\e[32m\]\u@\h \[\e[35m\]$MSYSTEM \[\e[33m\]\w\[\e[36m\]`__git_ps1`\[\e[0m\]\n$ '
# 显示效果
username@hostname MINGW /work_directory
$

# 简洁配置,将\h换成了指定文本,保留了命令行前的换行,将标签名改为当前目录
# 注意,使用单引号才有动态解析效果
export PS1='\[\e]0;\W\007\] \n\[\e[32m\]\u@Host \[\e[33m\]\w\[\e[36m\]`__git_ps1`\[\e[0m\]\n$ '
# 显示效果
username@Host /work_directory
$
  • Windows虚拟环境后不会换行:设置venv/Scripts/activate
if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT-}" ] ; then
_OLD_VIRTUAL_PS1="${PS1-}"
PS1="\n(${VIRTUAL_ENV_PROMPT}) ${PS1-}" # 添加换行符
export PS1
fi
  • MSYS2显示git prompt
# etc/profile.d/git-prompt.sh
if test -f /etc/profile.d/git-sdk.sh
then
TITLEPREFIX=SDK-${MSYSTEM#MINGW}
else
TITLEPREFIX=$MSYSTEM
fi

if test -f ~/.config/git/git-prompt.sh
then
. ~/.config/git/git-prompt.sh
else
PS1='\[\033]0;$TITLEPREFIX:$PWD\007\]' # set window title
PS1="$PS1"'\n' # new line
PS1="$PS1"'\[\033[32m\]' # change to green
PS1="$PS1"'\u@\h ' # user@host<space>
PS1="$PS1"'\[\033[35m\]' # change to purple
PS1="$PS1"'$MSYSTEM ' # show MSYSTEM
PS1="$PS1"'\[\033[33m\]' # change to brownish yellow
PS1="$PS1"'\w' # current working directory
if test -z "$WINELOADERNOEXEC"
then
GIT_EXEC_PATH="$(git --exec-path 2>/dev/null)"
COMPLETION_PATH="${GIT_EXEC_PATH%/libexec/git-core}"
COMPLETION_PATH="${COMPLETION_PATH%/lib/git-core}"
COMPLETION_PATH="$COMPLETION_PATH/share/git/completion"
if test -f "$COMPLETION_PATH/git-prompt.sh"
then
. "$COMPLETION_PATH/git-completion.bash"
. "$COMPLETION_PATH/git-prompt.sh"
PS1="$PS1"'\[\033[36m\]' # change color to cyan
PS1="$PS1"'`__git_ps1`' # bash function
fi
fi
PS1="$PS1"'\[\033[0m\]' # change color
PS1="$PS1"'\n' # new line
PS1="$PS1"'$ ' # prompt: always $
fi

MSYS2_PS1="$PS1" # for detection by MSYS2 SDK's bash.basrc

# Evaluate all user-specific Bash completion scripts (if any)
if test -z "$WINELOADERNOEXEC"
then
for c in "$HOME"/bash_completion.d/*.bash
do
# Handle absence of any scripts (or the folder) gracefully
test ! -f "$c" ||
. "$c"
done
fi

# ~/.bashrc || ~/.bash_profile
shopt -q login_shell || . /etc/profile.d/git-prompt.sh
syntax description
\u username
\h hostname
\e set colors
\w work directory
\W current diretory
\n line feed
阅读全文 »

微服务

非单体项目,可以用下面的脚本启动微服务。

#!/bin/bash

# 获取服务名称和额外参数
SERVICE_NAME=$1
shift # 移除第一个参数(服务名),将剩余参数保存到 $@
EXTRA_ARGS="$@"

# 检查是否输入服务名称
if [ -z "$SERVICE_NAME" ]; then
echo "Usage: ./run.sh <servicename|all> [additional_maven_args]"
exit 1
fi

# 定义运行单个服务的函数
run_service() {
local service=$1
local args=$2
echo "Building and running $service with args: $args..."
mvn clean install -pl $service -am
if [ "$service" == "gateway/" ]; then
echo "Gateway starting..."
mvn spring-boot:run -pl $service -Dreactor.netty.http.server.accessLogEnabled=true $args
else
mvn spring-boot:run -pl $service $args
fi
}

# 如果输入 "all",运行所有服务(默认不传参)
if [ "$SERVICE_NAME" == "all" ]; then
echo "Building and running all services..."
mvn clean install -pl "!generator"
for module in $(mvn help:evaluate -Dexpression=project.modules -q -DforceStdout | sed -e 's/<[^>]*>//g' -e 's/\s*//g' | tr ',' '\n'); do
if [ "$module" != "generator" ]; then
echo "Running $module..."
mvn spring-boot:run -pl $module
fi
done
else
# 运行指定的单个服务,并传递额外参数
run_service $SERVICE_NAME "$EXTRA_ARGS"
fi

核心命令是这一条:

mvn spring-boot:run -pl $your_service

想要增加JVM参数,指定端口可以加上

-Dspring-boot.run.arguments=--server.port=$your_port

全局换源

找到 settings.xml 文件:

  • 全局配置:位于 Maven 安装目录的 conf 文件夹下(例如/usr/local/maven/conf/settings.xml)。
  • 用户配置:位于用户主目录下的 .m2 文件夹中(例如~/.m2/settings.xml)。
<settings>
<!-- 其他配置 -->
<mirrors>
<!-- 阿里云 Maven 镜像 -->
<mirror>
<id>aliyun-maven</id>
<name>阿里云公共仓库</name>
<url>https://maven.aliyun.com/repository/public</url>
<mirrorOf>central</mirrorOf> <!-- 指定替换中央仓库 -->
</mirror>
<!-- 华为云 Maven 镜像 -->
<mirror>
<id>huaweicloud</id>
<name>华为云 Maven</name>
<url>https://mirrors.huaweicloud.com/repository/maven/</url>
<mirrorOf>central</mirrorOf>
</mirror>
</mirrors>
<!-- 其他配置 -->
</settings>

上传文件

scp ./upload/path/file.postfix user@host.com:/path/to/file
scp -P <port> -i <key>
# 文件夹
scp -r ./upload/path/folder user@host.com:/path/to/folder

下载文件

scp user@host.com:/path/to/file.postfix ./download/path
# 文件夹
scp -r user@host.com:/path/to/folader ./download/path

基本操作

  • gg=G:代码格式化
  • GX, GF:打开链接/文件
  • :%y *:复制全部到系统剪贴板
  • <C-o>, <C-i>:回到前一个/后一个位置(例如,打开文件默认在第一行,<C-o>回到上次编辑位置)。注意这个操作是跨文件的
  • `0:返回上次位置
  • 词:w(下一个词),b(词初),e(词尾)
  • 行:0(行初),^(第一个非空格字符),$(行尾)
  • 文件:gg(文件头),G(文件尾)
  • 搜索:/{正则表达式},n/N用于导航匹配
  • x删除字符(等同于dl
  • :s(substitute)替换字符(等同于xi
    • 替换命令:{作用范围}s/{目标文本}/{替换文本}/{替换标志}
    • :%s/s_content/o_content/gc 全局替换,附带确认提示
Sign Range
% 整个文件
. 当前行
$ 最后一行
,n 当前行到n行
n, n行到当前行
+n 当前行后n行
  • 可视化模式 + 操作
    • 选中文字,d删除(剪切) 或者c改变
  • u撤销,<C-r>重做
  • y复制 / “yank” (其他一些命令比如d也会复制)
  • p粘贴
    • +p 粘贴系统剪贴板
  • 更多值得学习的:
    • :<line> 跳到line行,相当于<line>G
    • ~改变字符的大小写
    • 3w向前移动三个词
    • A(大写)可以迅速定位到行尾进行修改
    • :!python prog.py 使用!直接运行shell命令
  • %匹配括号

Change

ce 替换一个单词
cs"' 把当前词块的"全部替换成’

多行操作

<C-v> 选中多行,Shift + i输入后Esc,即可多行同步输入

Esc Map

Vim和NeoVim内置了<C-[>作为<Esc>的映射;
还可以通过<A->Alt加上任何键(Meta键)的方式触发<Esc>-

录制宏

命令模式下,

  1. q<marcoName>进行录制,<marcoName>是宏的名字,例如qa
  2. 执行一系列操作后,再次按q结束录制

使用宏

命令模式下,使用@<marcoName>即可执行;使用5@<marcoName>可以重复执行宏

文件操作

  • :e filename切换到filename文件
  • :bn/bp切换到下/上个文件
  • <C-x><C-f> 自动补全路径
阅读全文 »

Git配置

远程仓库 - 廖雪峰的官方网站 (liaoxuefeng.com)

  1. 创建ssh key,在c盘用户目录.git文件夹中
    ssh-keygen -t ed25519 -C "youremail@example.com"
    ssh-keygen -l -f ~/.ssh/id_rsa 可以查看秘钥的配置信息,包括邮箱
  2. 在GitHub账号设置页面,添加ssh key,复制.ssh/id_rsa.pub的信息,点击创建即可
  3. 测试是否成功:ssh -T git@github.com
    注意:如果测试不成功,可能是反向代理的问题

Github 远程仓库

  1. 在github上新建一个仓库
  2. git remote add origin git@github.com:github账号名称/仓库名称.git 关联仓库,origin是远程库的名字
  3. git push -u origin master把本地库内容(master分支)推送到远程库(oringin),-u 参数表示会把本地master分支和远程master分支关联起来,方便后面简化命令
  • git remote set-url origin <URL>更改仓库地址

github trending 热门软件

  • 项目含金量 stars 1k+
  • fork 拷贝项目到自己的仓库
  • pull request 合并分支

NJU

  • 学习编程语言如C、Rust
  • 精选精读论文
  • STFW:比百度更高效的办法

Java多线程

回顾:操作系统的进程概念。进程的问题:上下文切换开销。为了解决这个问题,出现了线程。

Thread thread = (() -> {
// ...
System.out.pirntln("Sub Thread");
});
thread.start();
System.out.println("Main Thread");
Main Thread # 主线程先输出结果,说明两个线程同时运行!
Sub Thread

线程优先级

Java使用抢占式调度,有以下三种优先级

MIN_PRIORITY
MAX_PRIORITY
NOM_PRIORITY

线程同步

共享内存会出现缓存一致性问题,因此需要线程锁机制保证数据安全性(原子性)。

synchronized // 悲观锁

synchronized (Class.class / this) { ... } // 类锁
synchronized (new Class() / instanceOfClass) { ... } // 实例锁
public synchronized void operation() { ... }

synchronized使用的锁存储在Java对象头中。

重量级锁

JDK6以前,synchronized被称为重量级锁。因为Java的线程是映射在OS原生线程上,上下文切换成本高;直到JDK6以后才优化了锁的实现。
简单来说,每个等待锁都会被封装成ObjectWaiter对象,分为三个区域

direction: right
Entry Set -> The Owner
The Owner <-> Wait Set

Entry Set会排队,直到它成为The Owner,享有资源。当The Owner调用wait()方法,就会挂起进入Wait Set,直到wait()所等待的操作完成。
但是每个线程占用同步代码块的时间并不长,完全不需要挂起又唤醒。
因此,可以使用自旋锁

自旋锁

调用wait(),自旋锁并不是被挂起,而是无限循环是否能够获取锁;当等待时间太长,会恢复重量锁机制。
JDK6以后,自旋时间是动态变化的。如果某个线程经常自旋失败,它会直接使用重量级锁;反之,则会延长自旋时间。

轻量级锁

JDK6后,为了减少获得和释放锁的消耗,引入了轻量级锁。
轻量级锁的设计目标是,在无竞争状态下减少重量级锁带来的性能消耗(切换内核态、线程阻塞引发线程切换)。

如果只有一个线程占用资源,那就不要加锁、解锁。
轻量级锁需要向系统申请互斥量。

CAS算法

Compare and Swap
CAS算法不是加锁,而是通过比较来判断对象是否已被修改,如果没有直接替换;如果被修改,那么修改失败。

轻量级锁就是使用CAS算法,如果CAS失败,那么进入重量级锁状态。

偏向锁

Biased Locking
-XX:UserBiasLock
当只有一个线程反复访问同步代码块,JVM直接让该线程获取锁,避免不必要的不同步操作。
根据对象头底层数据结构,如果对象调用过hashCode()通过哈希值来检查一致性,那么对象头就没有空间存放ThreadId了(JVM通过这个id判断是否频繁访问),此时该线程只能使用轻量级锁。

锁消除和锁粗化

如果在运行过程中,根本没有出现资源竞争,那就会直接把锁消除掉。
如果某个资源频繁地开锁解锁(比如在循环内部synchronized),JVM会把锁的范围放大,避免加锁解锁的开销。

Java Memory Model

Java Thread 1 <-> Working Memory 1 <-> Save/Load Operation 
Java Thread 2 <-> Working Memory 2 <-> Save/Load Operation
Java Thread 3 <-> Working Memory 3 <-> Save/Load Operation
Save/Load Operation <-> Main Memory

JMM内存模型中有以下规定:

  1. 所有变量存储在主内存
  2. 每条线程有自己的工作内存,不能直接操作主内存
  3. 不同线程间互相隔离,要传递内容,必须通过主内存

volatile

volatile的最大作用是保证变量可见性,即发生修改后强制刷新到主内存中,使其他线程的缓存失效;相当于通知了其他线程要更新变量为最新版本。
注意,volatile不能保证原子性。

Lock&Condition

Lock用法:

Lock lock = new ReentrantLock(); // 可重入锁
Runnable action = () -> {
for (int i = 0; i < 100000; i += 1) {
lock.lock();
i += 1; // 保证同一时刻只有一个线程操作i
lock.unlock();
}
}

new Thread(action).start();
new Thread(action).start();

Condition用法:

Condition cond = lock.newCondition();

Thread thread1 = () -> {
...
cond.await(); // 等待
...
}
Thread thread2 = () -> {
...
cond.signal(); // 唤醒await线程
...
}
new Thread(thread1).start();
new Thread(thread2).start();

LeetCode 1114 顺序打印123

class Foo {
    private Lock lock = new ReentrantLock();
    private Condition cond1 = lock.newCondition();
    private Condition cond2 = lock.newCondition();
    private volatile int state = 0;

    public Foo() { }

    public void first(Runnable printFirst) throws InterruptedException {
        lock.lock();
        try {
            // printFirst.run() outputs "first". Do not change or remove this line.
            printFirst.run();
            state = 1;
            cond1.signal();
        } finally {
            lock.unlock();
        }
    }

    public void second(Runnable printSecond) throws InterruptedException {
        lock.lock();
        try {
            while (state != 1) {
                cond1.await();
            }
            // printSecond.run() outputs "second". Do not change or remove this line.
            printSecond.run();
            state = 2;
            cond2.signal();
        } finally {
            lock.unlock();
        }
    }

    public void third(Runnable printThird) throws InterruptedException {
        lock.lock();
        try {
            while (state != 2) {
                cond2.await();
            }
            // printThird.run() outputs "third". Do not change or remove this line.
            printThird.run();
        } finally {
            lock.unlock();
        }
    }
}

可重入锁

Re-entrant-Lock
这种锁可以多次加锁,同时也要多次解锁才算真的解锁了。

可重入锁是一种排他锁,其他线程必须等锁释放了才可以获取到锁。

公平锁与非公平锁

  • 公平锁:按照申请锁的时间去获得锁,会进入队列排队
  • 非公平:抢占式获取锁

读写锁

读写锁在同一时刻,可以让多个线程获取到锁。

  • 读锁:没有线程占用写锁的情况下,同一时间可以有多个线程加读锁。
  • 写锁:没有线程占用读锁的情况下,只有一个线程可以加写锁。
Lock reEntLock = new ReentrantLockReadWriteLock();
reEntLock.readLock().lock();
reEntLock.writeLock().lock();

锁降级、锁升级

reEntLock.writeLock().lock();
// 先加写锁,后加读锁,降级
reEntLock.readLock().lock();

...

// 然后释放写锁,只留下读锁,锁降级
reEntLock.writeLock().unlock();

AQS实现

Abstract Queued Synchronizer
在AQS中,一个线程获取锁后,其他线程进入等待队列。
等待队列由双向链表实现。

  • 复杂度分析:数据结构和算法的评价维度与方法。时间复杂度、空间复杂度的推算方法、常见类型、示例等。
  • 数据结构:基本数据类型,数据结构的分类方法。数组、链表、栈、队列、哈希表、树、堆、图等数据结构的定义、优缺点、常用操作、常见类型、典型应用、实现方法等。
  • 算法:搜索、排序、分治、回溯、动态规划、贪心等算法的定义、优缺点、效率、应用场景、解题步骤、示例题目等。
阅读全文 »
0%