因为之前克隆系统 获知了 fstab 文件，用来在启动系统时挂载对应硬盘分区中的系统。打开我自己系统的文件之后也发现可以配置挂载其他 FAT 或者 NTFS 格式的 Windows 下的分区。而最近可能因为 SSD 挂掉的原因，系统无法启动，再次把 fstab 放到了重要的位置，所以才有了这样一篇文章，主要用来总结一下 /etc/fstab 文件的作用及配置。

fstab 的完整路径是 /etc/fstab，纯文本文件，root 用户用任意的文本编辑器打开即可。fstab 是启动时配置文件，实际文件挂载是记录到 /etc/mtab 和 /proc/mounts 两个文件。

文件配置格式

每一个硬盘分区都有一个 UUID，可以使用 blkid 命令来查看（需 root 权限），在确定每一个硬盘分区的 ID 之后再来查看 fstab 文件就能非常轻松的看到 fstab 中挂载的内容具体含义。

# <file system> <mount point>   <type>  <options>       <dump>  <pass>
UUID=b9999999-a25b-4ca0-b597-fc62e121aae1 none            swap    sw              0       0
UUID=89999999-e8f2-4e68-84a1-b82e79a041c7 / ext4 errors=remount-ro 0 1

上述两条配置可以看到一个挂载了 swap 分区，一个挂载了根分区，分别在两个分区中。其实 fstab 文件就是将 mount 命令挂载的参数写到了文件中。

各字段具体解释：

• file syste 挂载设备，指的是硬盘分区，光驱等设备，指定分区的名字
• mount point 挂载点，挂载到系统的位置
• type 文件系统类型，包括 ext3,ext4,swap,ntfs,auto 等等，auto 表示让 mount 命令自动判断文件类型
• options 参数，挂载的设备开机自动加载，显示，读写权限的配置等等，mount 命令用法相关，具体参数配置见 man mount
• dump 备份命令，dump utility 用来决定是否做备份，dump 检查 entry 并用数字来决定是否对文件系统进行备份。为 0，则忽略，为 1，则备份
• pass 是否 fsck 检查扇区，启动过程中，系统默认会用 fsck 检查文件系统是否完整。但是有些文件系统不需要检查，比如 swap 或者特殊文件系统 /proc 或者 /sys 等等。0 是不要检验，1 表示最早检验（根目录配置为 1），2 表示要检验

options 常用参数：

• defaults 使用默认设置，rw,suid,dev,exec,auto,nouser,async
• auto noauto 自动和手动挂载
• ro rw 只读和读写挂载
• exec noexec 二进制文件是否允许执行
• sync async I/O 同步，I/O 非同步
• user 允许任何用户挂载设备，nouser 只允许 root 用户挂载
• async 所有文件系统 I/O 异步进行，同理还有 sync 选项
• suid nosuid 是否允许 set-user-ID 和 set-group-ID 生效
• nodev do not interpret character or block special devices on the file system
• nofail 如果不存在错误就不报告

系统挂载的限制：

• 根目录 / 必须先于其他设备挂载
• 挂载点必须为已经创建的目录
• 挂载点在同一时间只能挂载一次
• 分区在同一时间只能挂载一次

设计模式中的结构模式可以让我们组合类或者对象形成比较大型的结构，但也能保证结构的可维护性和可扩展性。

适配器模式

适用场景：

• 复用一个已经存在的类，但是类提供的接口不符合使用场景，使用适配器重新定义接口
• 在不对每一个都进行子类化以匹配它们的接口的情况下，使用一些已经存在的子类

类适配器

类适配器把”被适配的类的 API” 转换成 “目标类的 API”。

三个角色：目标 (Target)，源 (Adaptee) 和适配器 (Adapter)

对象适配器

与类适配器一样，对象适配器也是把”被适配的类的 API” 转换成 “目标类的 API”。不同的是，类适配器中”Adapter 和 Adaptee 是继承关系”，而对象适配器中”Adapter 和 Adaptee 是关联关系 (Adapter 中存在 Adaptee 类型的成员变量）”。

适配器模式的缺点：

• 大量使用适配器容易造成系统结构混乱

合成模式

又称为“部分 - 整体模式”，合成模式将对象组织到树结构中，可以用来描述整体与部分的关系。

装饰模式

装饰 (Decorator) 模式又名包装 (Wrapper) 模式。装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案。

它以对客户透明的方式动态地给一个对象附加上更多的责任。换言之，客户端并不会觉得对象在装饰前和装饰后有什么不同。装饰模式可以在不使用创造更多子类的情况下，将对象的功能加以扩展。

Decorator 模式重点在于责任，在于保持对外接口一致的情况下扩展接口功能。这是符合开闭原则的一个模式。

[[decorator design pattern]]

代理模式

代理模式给某个对象提供代理，由代理对象控制原对象的引用。

代理模式包含：抽象主题，代理主题，真实主题

• 抽象主题，声明共同接口
• 真实主题，真正内容
• 代理主题，包含一个真实主题，传递调用

注意点：

• 代理模式并不改变接口，代理模式的用意是让客户端不用在意代理的存在
• 代理类将对接口的调用转发给真实的调用，代理起到一个传递请求的作用，同时在传递请求时可以额外的添加特定操作

享元模式

对象结构模式，以共享的方式高效地支持大量的细粒度对象，通过共享来避免大量拥有相同内容对象的开销。

享元模式中的对象称为享元对象，享元对象分为内蕴状态和外蕴状态。内蕴对象和外蕴对象是相互独立的：内蕴状态是存储在享元对象内部，并且不会随环境改变而有所不同的；内蕴状态是可以共享。外蕴状态是随环境改变而改变，不可以共享的状态；享云对象的外蕴状态必须由客户端保存，并在享元对象被创建之后，在需要使用的时候再传入到享云对象内部。

Java 中享元模式的一个典型应用就是 String 类的实现，假设

String a="hello";
String b="hello";

变量 a 和 b 都被赋值 “hello” 那么这个字面常量会存在常量池中，实际上是同一个对象。

享元模式分为”单纯享元模式” 和 “复合享元模式”。

单纯享元模式

单纯享元模式涉及到的角色：抽象享元 (Flyweight)，具体享元 (ConcreteFlyweight)，享元工厂 (FlyweightFactory)。

复合享元模式

• 复合享元由单纯享元复合而成
• 复合享元实现抽象享元定义的接口

门面模式

外部与一个子系统通过统一的门面对象进行交互，门面模式提供一个高层次的接口，使得子系统更加容易使用。

比如说一个病人去医院（子系统）看病，那么需要挂号，门诊，收费，取药等等步骤，如果引入门面模式，相当于在医院增加一个引导员，由引导员负责挂号，门诊，收费，取药等等，病人只需要与引导员打交道。那么这样依赖病人就会方便很多。

门面系统由门面和子系统两个部分。

桥梁模式

桥梁模式是对象的结构模式，桥梁模式的用意是“将抽象化 (Abstraction) 与实现化 (Implementation) 解耦合，使得二者可以独立地变化”。

一般情况下抽象化类中包含一个具体实现，通过包含关系将强关联解耦。

桥梁模式中的三个关键词：

• 抽象化，抽取出共同的、本质性的特征
• 实现，抽象化的具体实现
• 解耦合，将抽象化和具体实现之前的强耦合关系改为弱关联；所谓强关联，就是编译时已经确定的关系，比如继承关系；而弱关联则是可以动态的确定并且可以在运行时动态改变的关系，比如聚合关系

优点：

• 分离了抽象和实现，给扩展提供了灵活性
• 桥梁模式可以分别独立的扩展抽象部分和实现部分

桥梁模式一个非常典型的使用就是 JDBC 驱动器，JDBC 为所有关系型数据提供了通用界面，一个应用选择一个合适的驱动器，通过驱动器向数据库引擎发出指令，这个过程就是将抽象角色的行为委派给具体实现角色的过程。

因为 JDBC 驱动器的存在，应用系统可以不依赖数据库引擎细节而独立发展，而同时数据库引擎也可以独立于应用系统的细节而独立发展。

JDBC 这种架构，将抽象部分和具体部分分离，对于应用程序而言，只要选用不同的驱动器，就可以让程序操作不同的数据库，而无需更改应用程序，从而实现在不同的数据库中的移植。对于驱动器程序而言，为不同数据库实现不同的驱动程序，并不会影响应用程序。

reference

• http://wangkuiwu.github.io/2012/10/24/design_pattern/
• https://www.cnblogs.com/java-my-life/archive/2012/05/07/2480938.html

本文主要归纳设计模式中的创建模式 (creational pattern)，主要包括了工厂模式，单例多例，建造者模式，和原型模式等。

创建模式是指对象的实例化过程，这些模式都提供了一种将对象实例化从客户端分离的方法。

为什么要有创建模式，这也符合开闭原则，Java 自带的 new Object() 实例化对象没有任何问题，问题在于修改，一旦当具体实例涉及变化，那么就必须修改实例自身，不符合开闭原则，所以才有这么多的创建模式。将对外暴露的接口抽象起来，将对象创建的方式封装，对外接口尽量减少。

简单工厂

主要分为三个部分，工厂，抽象产品，具体产品。

工厂直接提供具体产品，也就是直接创建具体类。

工厂模式将产品的生产和其提供的功能隔离。

多态工厂方法

又称为工厂方法。

The Factory Method Pattern defines an interface for creating an object, but lets subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.

分为四个部分，抽象工厂，具体工厂，抽象产品，具体产品。将产品实例化放到具体工厂子类中实现，抽象出工厂的一般方法。通常一个具体工厂产出一种具体产品。

因此在添加具体产品后不需要修改具体工厂类，而只需要相应的添加具体工厂来产出产品。

抽象工厂

和多态工厂相同，包含四个部分。

The Abstract Factory Pattern provides an interface for creating families of related or dependent objects without specifying their concrete classes.

抽象工厂和工厂方法的区别在于，抽象工厂模式中，一个工厂可以提供多个抽象产品。在工厂方法模式中，由“具体工厂”决定提供哪一类具体产品；在抽象工厂中，由客户端决定返回哪一类产品。

单例

至始至终只有一个实例。

Eager initialization

The instance of Singleton is created at the time of class loading.

public class EagerSingletion {
	private static final EagerSingletion instance = new EagerSingletion();
	private EagerSingletion() {}
	public static EagerSingletion getInstance() {
		return instance;
	}
}

在 Singleton 不占用太多资源时可以使用 static 在类加载时使用这个方法。但是对于大对象这个方法就不是很好。

Static block initialization

Use static block to create instance

public class StaticBlockSingleton {
	private static StaticBlockSingleton instance = null;
	private StaticBlockSingleton() {}
	static {
		try {
			instance = new StaticBlockSingleton();
		} catch(Exception e) {
			throw new RunTimeException("Exception creating singleton");
		}
	}

	public static StaticBlockSingleton getInstance() {
		return instance;
	}
}

使用 static 字段和 static block 定义的实例都是在实例对象被使用之前就已经创建。

Lazy Initialization

在第一次使用时创建。

public class LazyInitialSingleton {
	public static LazyInitialSingleton instance = null;
	private LazyInitialSingleton() {}
	public static LazyInitialSingleton getInstance() {
		if (instance == null) {
			instance = new LazyInitialSingleton();
		}
		return instance;
	}
}

但是这个方法在单线程中是没有问题的，如果是多线程同时调用 getInstance 方法，就可能创建多个实例。

Thread Safe Singleton

public class ThreadSafeSingleton {
	public static ThreadSafeSingleton instance = null;
	private ThreadSafeSingleton() {}
	public static synchronized ThreadSafeSingleton getInstance() {
		if (instance == null) {
			instance = new ThreadSafeSingleton();
		}
		return instance;
	}
}

synchronized 作用于静态方法等同于对类加锁。

Double checked Singleton

public static ThreadSafeSingleton getInstance () {
	if (instance == null) {
		synchronized (ThreadSafeSingleton.class) {
			if (instance == null) {
				instance = new ThreadSafeSingleton();
			}
		}
	}
	return instance;
}

Bill Pugh Singleton

使用内部静态类

public class Singleton() {
	private Singleton() {}
	private static class Helper {
		private static final Singleton INSTANCE = new Singleton();
	}

	public static Singleton getInstance() {
		return Helper.INSTANCE;
	}
}

这里涉及到类加载机制，在类加载 Singleton 时，内部静态类是不会被加载的。只有当有调用 getInstance() 方法，实例才会初始化。

多例

一个类存在多个自身的实例，并且多例类需要自己创建，管理自己的实例，并向外提供自己的实例。

常见的线程池，数据库连接池就是多例的使用案例。

建造者模式

当需要创建的对象，创建步骤比较复杂时，可以将对象的”创建”和”表示”分离。Builder 模式允许用户将复杂对象的创建封装，允许使用者多个步骤来构造对象。

建造者模式包括：导演，抽象建造者，具体建造者，和产品

建造者模式的使用场景：

• 对象内部结构复杂，比如包含不同零件的汽车类，比如一个复杂的邮件类
• 对象内部属性有依赖，需要按照某一些顺序进行赋值
• 对象创建过程依赖系统其他对象，而这些依赖的对象不易获取

优点：

• 封装了内部构造细节
• 隐藏了内部表示
• 构造对象内部实现可以灵活改动，客户端只通过抽象接口来构造该对象

缺点：

• 相较于工厂模式，客户端需要额外的知识来创建对象

原型模式

通过原型指明要创建的对象类型，然后通过该原型创造更多的对象实例。Java 中可以通过 clone() ，或者反序列化来实现。原型模式允许客户端在不知道对象具体内部细节的情况下创建实例。

一个比较具体的使用场景，比如要对比两个对象修改前后的差异，可以在修改前复制一个对象实例，然后修改之后对比。再比如一次比较重的数据库查询，可以缓存该对象，再下一次请求到来时直接返回该对象的复制。

一些比较适合的场景：

• 当创建一个实例比较昂贵或者复杂时

原型模式的优点：

• 对客户端隐藏了构造对象的复杂细节
• 对客户端提供了一种在不确定类型情况下创建对象实例的方法
• 某一些场景下复制对象实例要比创建来的更有效率

缺点：

• 对于一些只有少量对象的系统来说并不太需要
• 每一个原型类的子类都需要实现 clone 方法，有些时候创建对象拷贝并不是非常轻松

reference

• https://www.geeksforgeeks.org/prototype-design-pattern/
• http://wangkuiwu.github.io/2012/10/17/design_pattern/
• https://www.tutorialspoint.com/design_pattern/prototype_pattern.htm
• 《Head First Design Patterns》
• https://www.journaldev.com/1377/java-singleton-design-pattern-best-practices-examples

阅读专题书籍

Kindle Unlimited 特别适合专题阅读，比如想要了解日本文化，那么通过搜索日本，可以获得一系列的关于日本的书籍，借阅自己喜欢的书阅读即可。比如日本就可以搜索到，《静观日本》，《牛津通识读本现代日本》，《日本人的活法》，《走遍日本》，《图说日本》，《日本论》，《日本常识》等等的书籍，如果变换关键词也会搜索到像《菊与刀》这样的关于日本文化的书籍。那么通读这一系列的图书就能够快速建立起对于日本这个国家的认识。 同样的道理如果想要了解，政治学，心理学，可以直接以关键词去搜索，当然不一定这一个门类的图书都是在书名中包含关键字的，但是 Kindle Unlimited 的一个好处就是可以快速浏览目录，再去判断要不要去精读这本书。

善用豆瓣

豆瓣之于我，更像是一个工具，一个长周期的，管理信息的 Todo list，我一般会在豆瓣提前标注好想看的书，然后按照自己的喜欢程度来依次阅读。所以一般不会有书荒，也不会因为想看的书太多而造成压迫感。

制定读书计划

如果一个月看不到 3 本书，确实没必要买 Kindle Unlimited 了。所以这就体现了计划的重要性，除了上面提及的专题阅读，以及豆瓣的规划，最好在用豆瓣的豆列来指定当月或者当季度想看的书单。

看自己喜欢看的书籍

看自己喜欢的书，虽然听起来很简单，但很多时候其实很难实现，往往有些时候在书单中的书这个时候看非常晦涩，而在另外一个时候再回来读却能读出不一样的东西。很多书可能很长时间躺在书单中，但是却一直没有找到阅读的理由，但是往往可能因为别人的一句话或者看过的一部电影而重新从书单中被找出来，然后获得更多的体验。读某个阶段自己最关心的一个话题的书籍，或者某一个阶段最喜欢的一类图书即可。大可直接拿起一些图书，然后略读一个大概然后记住，等到真正关心起这段内容再仔细阅读。

不要一次性借阅太多的图书

把借书还书当成一次仪式，Kindle Unlimited 一次也只能够借阅 10 本，所以没必要同时阅读超过 2 两本书。一本本看，看完一本做些笔记，写些感想。

Google Forms 是集成在 Google Docs 中可以用来快速创建调查问卷，建立报名系统，反馈调查等等的应用。Google Forms 原来属于 Google Docs，现在已经集成在了 Google Drive 中。

打开入口

Google Forms 的入口藏的有些深，如果不是之前就知道这个功能可能很多人用了多年 Google Docs 或者 Google Drive 都不曾知道有这个功能。在 Google Drive 中左上新建，然后在菜单中找到更多，然后其中有 Google Forms。

另外可以直接打开 Google Forms 的二级域名，也会跳转到对应的页面。

创建及修改

创建和修改部分其实非常简单，UI 也非常清晰。不过这里可以总结 Google Forms 支持的问题及答案类型：

• 简短答案，可以用来回答比如姓名，电话，电子邮件等等简单的文本，甚至可以用正则来验证
• 段落，比较长的文本
• 选择题
• 多选题
• 下拉列表，可以根据不同的选项转到不同的小节
• 上传文件
• 线性量表，会使用单选形式出现多个选项，可以用来设计评分等等
• 选择题网格，通常是每一行一问题，而每列中是不同的选择
• 日期
• 时间

通过组合这些功能能够设计出一个完整的调查问卷

收集结果

在 Forms 中能够直接查看回复，并且可以关联 Google Sheets，然后将结果在一张表中展示出来。

expect 是用来进行自动化控制和测试的工具。主要是和交互式软件 telnet ftp passwd fsck rlogin ssh tip 等进行自动化的交互。Linux 交互命令中经常需要输入 yes/no 或者 password 等操作，模拟这些输入，就可以使用 expect 脚本。expect 是由 tcl 语言演变而来的。简单地说，expect 是一个工具，可以根据用户设定的规则和系统进程进行自动化交互，例如远程登陆的密码输入、自动化的执行远程命令。

一个非常典型的使用场景就是一般在公司中都会使用 relay 来连接管理服务器的远程连接和使用，通常会需要在 SSH 登录的时候使用用户名和密码，甚至需要二步验证来增强安全性，但是如果不想每一次都重复输入用户名和密码就可以使用 expect 命令来快速实现登录。

安装

Debian/Ubuntu/Linux Mint 系安装非常简单

apt install expect

关键命令

expect 下几个非常重要的指令：

• spawn: 启动进程（由 spawn 启动的进程的输出可以被 expect 所捕获）
• expect: 从进程接收字符串，期望获得字符串
• send: 向进程发送字符串，用于模拟用户的输入，注意一定要加 \r 回车
• interact: 用户交互
• sleep n: 使脚本暂停给定的秒数

spawn 指令用来开启比如 Shell, FTP, SSH ,SCP 等等的交互指令。

命令行参数

$argc，$argv 0，$argv 1 ... $argv n

argc 表示命令行参数个数，后面分别表示各个参数项，0 表示第一个参数，1 表示第二个参数，以此类推，可以通过 lindex 获取对应参数值 (lindex $argv 0)。

if {$argc < 2} {
    puts stdout "$argv0 err params\n"
    exit 1
}

if {[llength $argv] == 0} {
    puts stdout "need server name as param"
    exit 1
}

输入输出

puts stderr "Usage: $argv0 login passwaord.n "
puts "hello world"
puts stdout "1234"

变量赋值

set argv [lindex $argv 0]
set user "einverne"
set count 3
set ip "192.168.2.1"

复合指令

比如要将脚本的参数赋值给变量

set my_var [lindex $argv 0]

命令调用

spawn ssh $user@$ip

spawn 启动一个进程，进程执行 ssh 命令，程序后面可以通过 expect/send 和新起的进程进行交互

分支语句

单一分支语法：

expect "hello" {send "you said hello"}

多分支模式语法：

expect {
    "lilei" {send "hello lilei"; exp_continue}
    "hanmeimei" {send "hello hanmeimei"; exp_continue}
    "how do you do ?" {send "how do you do ?"}
}

switch 分支

switch -- $var {
{
  }
{
  }
{
  }
}

if else 分支

set NUM 1
if { $NUM < 5 } {
    puts "\Smaller than 5\n"
} elseif { $NUM > 5 } {
    puts "\Bigger than 5\n"
} else {
    puts "\Equals 5\n"
}

循环

while 循环语法

#!/usr/bin/expect -f
set NUM 0
while { $NUM <= 5 } {
    puts "Number is $NUM"
    set NUM [ expr $NUM + 1 ]
}

for 循环

for {set NUM 0} {$NUM <= 5} {incr NUM} {
    puts "\nNUM = $NUM"
}
puts ""

自定义方法

定义

proc myfunc { TOTAL } {
    set TOTAL [expr $TOTAL + 1]
    return "$TOTAL"
}

使用

set NUM [myfunc $NUM]

使用正则表达式判断

if {[regexp {^[0-9]+$} $NUM]} {
  Do something
} else {
  Exit
}

其他表示

if {![regexp {\D+} $NUM]}
if {![string match {[^0-9]+} $NUM]}

实例

登录远程服务器并创建文件夹

#!/usr/bin/expect               // 告诉系统脚本的执行方式
set timeout -1                  // 等待超时时间， -1 为无限制等待
spawn ssh root@192.168.2.1      // spawn 执行 expect 内部命令，给 ssh 运行进程加壳，传递交互指令
expect {                        // expect 是 expect 内部命令，判断上次输出结果是否包含，如果有则立即执行操作
    "password" {send "123456\r";}           // send 执行交互动作，与手工输入密码等效
    "yes/no" {send "yes\r";exp_continue}
}
expect "root" {send "mkdir testFolder\r"}
expect eof
exit

expect eof 等待结束标志，spawn 启动的命令在结束时会产生一个 eof 标志。

带参数的脚本

如果脚本依赖外部输入，比如有输入参数，那么可以在后面添加参数：

./expect.ex 192.168.2.1 123456

脚本可以首先用 set 给变量赋值

#!/usr/bin/expect

set ip [lindex $argv 0]
set password [lindex $argv 1]
set timeout -1
spawn ssh root@ip
expect {
    "password" {send "$password\r";}
    "yes/no" {send "yes\r";exp_continue}
}
expect "root" {send "mkdir test1\r"}
send "exit\r"
expect eof
exit

等待手动操作

登录远程服务器之后使用 interact 来等待手动操作，比如：

./expect.ex 192.168.2.1 123456

脚本：

#!/usr/bin/expect
set ip [lindex $argv 0]
set password [lindex $argv 1]
set timeout -1
spawn ssh root@$ip
expect {
    "password" {send "$password\r";}
    "yes/no" {send "yes\r";exp_continue}
}
interact                // 完成后保持交互状态，把控制权交给控制台

注意最后的 interact

总结

expect 在 Linux 运维中非常有用，可以用来多机器重启，远程 copy 等等场景，shell 中受限于密码输入的操作，可以通过 expect 来节省很多工作。

涉及到脚本地址

reference

• http://expect.sourceforge.net/
• https://likegeeks.com/expect-command/
• http://tcl.tk/man/tcl8.6/TclCmd/contents.htm

记录一下从 mint 18.3 升级到 19, 然后小版本升级的过程。虽然总结这篇文章的时候比较早，但是一直没有发布出去，现在想想 Mint 20 都快出了，放在这里做个记录吧。

都知道 Ubuntu 大版本更新极有可能会让一些熟悉的应用没有及时维护而无法使用。Mint 也是一样从 18.3 升级到 19 的过程就比较痛苦，需要升级各种依赖版本。

备份

使用 Mint 自带的 timeshift 应用进行备份：

sudo apt install timeshift

查看当前的 dm, 并变更为 lightdm:

cat/etc/X11/default-display-manager
/usr/sbin/mdm
sudo apt install lightdm lightdm-settings slick-greeter

sudo dpkg-reconfigure lightdm

安装 mintupgrade:

sudo apt install mintupgrade
# 检查目前的依赖及安装包
sudo mintupgrade check
# 下载最新的安装包
sudo mintupgrade download
# 执行升级的过程
sudo mintupgrade upgrade

Update 工具中，选择 Edit, 然后选择升级到某某某版本。

在升级 Ubuntu 或者 Mint 的时候，千万小心，有很大的程度可能导致无法进入系统，最好做到资料的备份，如果进不去系统也不要担心，Linux 下提供了很多 Debug 工具，可以通过各种方法做到不丢数据。现在想一想我 MSI 笔记本上的系统升级过两次大版本，都或多或少的遇到过各种问题，但从来没有丢过数据，并通过一些配置都可以很快的进入桌面。

Arthas is a Java diagnostic tool that promises to help developers troubleshoot production issues for Java applications without modifying the code or restarting the server.

Main features:

• Useful for trouble-shooting jar file conflicts
• Decompile a class to ensure the code is running as expected
• View classloader statistics
• View the method invocation details
• Check the stack trace of specified method invocation
• Trace the method invocation to find slow sub-invocations
• Monitor method invocation statistics
• Monitor system metrics, thread states and CPU usage, gc statistics, and etc
• Support command line interactive mode, with auto-completed feature enabled.
• Support telnet and WebSocket, enabling both local and remote diagnostics with command line and browsers

Install

安装非常简单

curl -L https://alibaba.github.io/arthas/install.sh | sh

然后使用 ./as.sh 启动即可。

其他安装方式

实例

全局监控

进入 arthas 之后使用 dashboard 可以快速查看全局信息，包括系统基本信息，CPU 使用率，堆内存，gc 次数，gc 耗时等等

查看 JVM 线程堆栈信息

使用 thread 可以查看线程堆栈信息。当 thread 没有参数时会打印所有的线程信息。

thread 命令也支持打印当前最忙的前 N 个线程

thread -n 3

后面增加 id 可以打印指定线程堆栈

thread id

使用 -b 参数一键找出当前阻塞其他线程的线程

thread -b

目前只支持找出 synchronized 关键字阻塞住的线程， 如果是 java.util.concurrent.Lock， 目前还不支持。

查看类从哪一个 jar 加载

当知道类的路径时可以直接使用 sc -d package.Class 这样的方式来查看当前类的详细信息

$ sc -d demo.MathGame
 class-info        demo.MathGame
 code-source       /home/einverne/arthas/arthas-demo.jar
 name              demo.MathGame
 isInterface       false
 isAnnotation      false
 isEnum            false
 isAnonymousClass  false
 isArray           false
 isLocalClass      false
 isMemberClass     false
 isPrimitive       false
 isSynthetic       false
 simple-name       MathGame
 modifier          public
 annotation
 interfaces
 super-class       +-java.lang.Object
 class-loader      +-sun.misc.Launcher$AppClassLoader@5c647e05
                     +-sun.misc.Launcher$ExtClassLoader@197c17c6
 classLoaderHash   5c647e05

信息中可以清晰的看到加载的 jar 的路径等等一些信息。

代码为什么没有执行

要回答这个问题，最好的方法就是立马检查下当前正在跑的代码是否符合预期。使用如下命令：

jad demo.package.Class

直接查看当前运行的代码

查看函数调用栈耗时

如果特别关心某一函数的耗时情况，可以使用 trace 来查看

trace package.Class method

监控有异常的接口

使用 tt 命令可以记录下指定方法被调用时的入参和返回值。tt 是 TimeTunnel 的缩写，为了解决 watch 命令的复杂。

tt -t package.Class methodName -n 100
tt -t package.Class methodName -n 100 > temp.log

-n 表示会统计之后的多少请求，> temp.log 表示输出到 arthas 的 cache 中，地址在 ~/logs/arthas-cache/ 下

回放请求

上面使用 tt 命令记录的内容可以用来回放请求，在 temp.log 日志中找到 index 表示的即为该请求的入参，使用 tt 命令可以用来回放请求，下面命令中的 index 就是文件中的 index

tt --play -i index

在使用回放的时候需要注意：1. ThreadLocal 信息丢失 2. 引用对象， tt 命令将当前环境的对象引用保存，如果方法对入参进行了修改，那么 tt 命令无法查看到准确的值。

watch 命令查看有异常的入参

tt 命令可以一直监控方法的入参，但是有的时候并不关心正常运行的参数，而只关心有异常的方法的入参，这个时候就可以使用 watch 命令

watch package.Class method -e -x 2 '{params[0], params[1].toString, throwExp}'

监控 JVM 运行状态

使用 jvm 命令即可查看 JVM 的运行状态

jvm

sysprop sysenv 查看系统变量

sysprop 可以查看系统变量，sysenv 可以查看系统的环境变量。

reference

• https://alibaba.github.io/arthas/dashboard.html

HAProxy is free, open source software that provides a high availability load balancer and proxy server for TCP and HTTP-based applications that spreads requests across multiple servers. It is written in C and has a reputation for being fast and efficient.

Features:

• Layer 4 (TCP) and Layer 7 (HTTP) load balancing
• URL rewriting
• Rate limiting
• SSL/TLS termination
• Gzip compression
• Proxy Protocol support
• Health checking
• Connection and HTTP message logging
• HTTP/2
• Multithreading
• Hitless Reloads

Performance:

• http://www.haproxy.org/10g.html

Similiar:

• LVS
• Nginx

HAProxy 的负载均衡算法：

• roundrobin，表示简单的轮询
• static-rr，表示根据权重
• leastconn，表示最少连接者先处理
• source，表示根据请求源 IP，和 Nginx IP_hash 类似
• uri，请求 URI
• url_param，请求的 URI 参数
• hdr(name), name 指定的 HTTP 首部
• rdp-cookie(cookie), 根据 cookie(name) 哈希请求

HAProxy 关键配置

HAProxy 的配置文件共有 5 个域

• global：用于配置全局参数
• default：用于配置所有 frontend 和 backend 的默认属性
• frontend：用于配置前端服务（即 HAProxy 自身提供的服务）实例
• backend：用于配置后端服务（即 HAProxy 后面接的服务）实例组
• listen：frontend+backend 的组合配置，可以理解成更简洁的配置方法

配置举例

HTTP

global
    daemon
    maxconn 256

defaults
    mode http
    timeout connect 5000ms
    timeout client 50000ms
    timeout server 50000ms

frontend http-in
    bind *:80
    default_backend servers

backend servers
    server server1 127.0.0.1:8000 maxconn 32

定义监控

在配置文件中增加

listen stats    #定义监控页面
    bind *:1080                     # 绑定端口 1080
    mode http                       # http mode
    stats hide-version              # Hide HAProxy version
    stats refresh 30s               # 每 30 秒更新监控数据
    stats uri /stats                # 访问监控页面的 uri
    stats realm HAProxy\ Stats      # 监控页面的认证提示
    stats auth admin:admin          # 监控页面的用户名和密码

然后通过 http://ip:1080/stats 即可访问

HAProxy 主备

现在个人代理需求不强烈，等折腾到了再搞。

reference

• http://www.haproxy.org/
• https://cbonte.github.io/haproxy-dconv/
• https://cloud.google.com/load-balancing/docs/https/

所有下载链接建议有国外 VPS 的直接从国外的 VPS 下载，scp 拉回本地，浏览器下载太慢。

Recovery

• https://twrp.me/oneplus/oneplusthree.html

ROM

AOSP Extended

• https://forum.xda-developers.com/oneplus-3/oneplus-3--3t-cross-device-development/rom-aospextended-rom-v3-1-t3557363

LineageOS

• https://download.lineageos.org/oneplus3

Kernel

• https://forum.xda-developers.com/oneplus-3/oneplus-3--3t-cross-device-development/kernel-caesium-kernel-op3-op3t-t3672090

GApps

• https://opengapps.org/?arch=arm64
• https://github.com/opengapps/arm64

Magisk

• https://www.xda-developers.com/how-to-install-magisk/

Decryption Unsuccessful

在安装完新的 AOSP Extended ROM 之后启动突然出现了 “Decryption Unsuccessful” 的问题，一查可能是之前的数据分区加密过，新的系统无法解密读取这些文件了。

There’s some weird issues with the latest AOSP based ROM that makes encrypted ext4 based data partition unable to be decrypted in both system and older version of TWRP if you’re encrypted before (intentionally or unintentionally). This however doesn’t apply to F2FS and unencrypted ext4 data partition

xda 提供了两种解决方案：

推荐的方式是重新分配分区 F2FS，这需要提前备份所有 internal storage 数据，然后抹去所有数据

• 通过 TWRP 挂载 SD 卡，备份全部数据
• 格式化所有数据，在 TWRP 中选择 “Format”, 然后选择 “Wipe data”
• 然后 Flash ROM 和 GApps

第二种方式是安装一个第三方修改过的 Kernel，这种方式不需要抹除数据

• Xenial b25x or newer
• Revolt EAS-R13

这里补充下 F2FS，很多人可能好奇 F2FS 是什么，具体做什么用，F2FS 是 “Flash-Friendly File system”，是一种新的文件系统，用于 NAND 闪存一类的储存设备，F2FS 和主流的 ext3/4 相比，有更好的加密特性，更快的读取速度，对碎片小文件读写优化，增加了固态存储的寿命等等优点。但 F2FS 也有其缺点，就是在大文件读写上性能可能会波动。