我正在参加「掘金·启航计划」

本文从研发角度探讨下高质量软件应具备哪些特点，以及如何度量软件质量。

软件质量的分类

软件质量通常可以分为：内部质量和外部质量。

内部质量

内部质量是指软件的结构和代码质量，以及其是否适合维护、扩展和重构。它关注的是软件本身的特性和属性，包括：

• 可读性：代码易于阅读和理解；
• 易维护性：代码易于修改和维护；
• 可测试性：代码易于编写单元测试并进行自动化测试；
• 可靠性：代码稳定、不容易崩溃或出现错误；
• 可扩展性：代码能够方便地进行扩展；
• 可重用性：代码可被复用于其他项目中。

内部质量直接影响软件的可维护性和开发效率。如果软件的内部质量很差，那么开发人员可能需要花费更多的时间修复问题，而不是开发新功能。

外部质量

外部质量是指软件的用户体验和其符合用户需求的程度。它关注的是软件的功能和表现形式，包括：

• 功能性：软件是否具有所需的功能，并且这些功能是否能够正常工作；
• 易用性：软件是否易于使用，是否符合用户的期望；
• 性能：软件是否运行快速并响应迅速；
• 兼容性：软件是否能够在不同的操作系统和设备上正常工作。

外部质量如果很差，那么用户在使用软件过程中可能会遇到问题，而这些问题可能会影响用户体验，导致用户流失。

为什么内部质量更重要

内部质量高的核心降低了未来变更的成本。

可以参考下图的时间-功能累计关系图。

对于内部质量比较差的软件，虽然初期进展迅速，但是随着时间的流逝，添加新功能变得越来越困难。甚至一个小改动也需要程序员理解大量代码。当开发做代码变更时，还可能产生意想不到的缺陷，因此导致测试时间长，需要更高成本来做缺陷修复和验证。

对于内部质量高的软件，则与其相反，可以参考下图的比较。

内部质量高的软件更容易被实现。

内部质量高的软件特点之一就是易读性。 这样利于开发者更快弄清楚应用程序是如何运行的，这样就可以知道如何添加新功能。如果将软件很好地划分为不同的实现模块，则开发者没必要阅读所有代码，只需要快速找到涉及功能变动模块的代码就行。

如何衡量软件质量

Cyclomatic Complexity（圈复杂度）

Cyclomatic Complexity通过计算代码中不同路径的数量来衡量代码的复杂程度。圈复杂度越高，表示代码的控制流程越复杂，可能存在更多的错误和缺陷。

下面举例说明Cyclomatic Complexity如何计算。

public int calculate(x, y) {

    if (x >= 20) {

        if (y >= 20) {

            return y;

        }



        return x;

    }



    return x + y;

}

这段代码的流程图如下：

圈复杂度的公式如下：

E - N + 2

其中 E 表示图中的边数（上图中的所有形状），N 表示节点数（上图中的所有箭头）。因此，在我们的例子中，6 - 5 + 2 = 3，的确这段代码包含三条路径。

Maintainability Index（可维护性指数）

Maintainability Index（可维护性指数）是一种用于评估软件代码可维护性的指标。它通常考虑代码的复杂度、长度和注释等因素，并将这些因素整合成一个分数来衡量代码的可读性、可维护性和可重构性。

通常情况下，可维护性指数的分数范围是 [0,100]，分数越高表示代码的可维护性越好。可维护性指数可以帮助开发人员识别哪些代码需要改进，以提高代码的可维护性和可读性，从而减少维护成本、降低缺陷率，提高代码的质量。

Dependencies（依赖）

软件的开发过程势必会依赖外部框架和库，这些框架和库自身也会经常更新（维护者会添加和删除功能、修复错误、改进性能，并修补安全漏洞）。

旧版本库和框架通常会对依赖它的软件质量产生负面影响。例如安全漏洞是明显的风险（例如22年8月份的

Apachelog4j漏洞）。

SQALE评估法

SQALE评估法主要关注四个指标：

1. 技术债：即未来要花费的时间和资源去修复当前存在的问题
2. 可维护性：即代码的易读性、可理解性和可扩展性，从代码的模块化程度、命名规范、注释等因素，并对这些因素进行打分。
3. 可靠性：即软件的稳定性和可靠性，评估代码中存在的错误、漏洞和异常处理情况。如果存在较多的问题，他们就需要考虑重新设计代码或增加更多的测试用例。
4. 性能：即软件的响应速度和处理能力

能GET到的知识点

• 什么场景使用for和range

1. 从一个遍历开始

万能的range遍历

1. 遍历array/slice/strings

array

package main  

  

import "fmt"  

  

func main() {  

    var UserIDList = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}  



    for i, v := range UserIDList {  

        fmt.Println(i, v)  

    }  

}



0 1

1 2

2 3

3 4

4 5

5 6

6 7

7 8

8 9

9 10

slice

package main  

  

import "fmt"  

  

func main() {  

    var UserIDList = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}  

    var UerSlice = UserIDList[:]  



    for i, v := range UerSlice {  

        fmt.Println(i, v)  

    }  

}

0 1

1 2

2 3

3 4

4 5

5 6

6 7

7 8

8 9

9 10

字符串

func main(){

    var Username = "斑斑砖abc"  

    for i, v := range Username {  

        fmt.Println(i, v)  

    }

}





0 26001

3 26001

6 30742

9 97

10 98

11 99

range进行对array、slice类型遍历一切都正常，但是到了对字符串进行遍历时这里就出问题了,出问题主要在索引这一块。可以看出索引是每个字节的位置，在go语言中的字符串是UTF-8编码的字节序列。而不是单个的Unicode字符。遇到中文字符时需要使用多个字节表示，英文字符一个字节进行表示，索引0-3表示了一个字符及斑以此完后。

2. 遍历map

func ByMap() {  

    m := map[string]int{  

    "one": 1,  

    "two": 2,  

    "three": 3,  

    }  

    for k, v := range m {  

        delete(m, "two")  

        m["four"] = 4  

        fmt.Printf("%v: %v\n", k, v)  

    }  

}



one: 1

four: 4

three: 3

• 和切片不同的是，迭代过程中，删除还未迭代到的键值对，则该键值对不会被迭代。
• 在迭代过程中，如果创建新的键值对，那么新增键值对，可能被迭代，也可能不会被迭代。个人认为应该是hash的无序性问题
• 针对 nil 字典，迭代次数为 0

3. 遍历channel

func ByChannel() {  

    ch := make(chan string)  

    go func() {  

        ch <- "a"  

        ch <- "b"  

        ch <- "c"  

        ch <- "d"  

        close(ch)  

    }()  

    time.Sleep(time.Second)

    for n := range ch {  

        fmt.Println(n)  

    }  

}

• 针对于range对关闭channel的遍历，会直到把元素都读取完成。
• 但是在for遍历会造成阻塞，因为for变量读取一个关闭的管道并不会进行退出，而是一直进行等待，但是如果关闭了会返回一个状态值可以根据该状态值判断是否需要操作

2.for和range之间奇怪的问题

2.1 无限遍历现象

for

c := []int{1, 2, 3}  

for i := 0; i < len(c); i++ {  

    c = append(c, i)  

    fmt.Println(i)  

}



1

2

3

.

.

.

15096

15097

15098

15099

15100

15101

15102

15103

15104

range

c := []int{1, 2, 3}  

for _, v := range c {  

    c = append(c, v)  

    fmt.Println(v)  

}



1

2

3

可以看出for循环一直在永无止境的进行追加元素。 range循环正常。原因：for循环的i < len(c)-1都会进行重新计算一次，造成了永远都不成立。range循环遍历在开始前只会计算一次，如果在循环进行修改也不会影响正常变量。

2.2 在for和range进行修改操作

for

type UserInfo struct {  

    Name string  

    Age int  

}

var UserInfoList = [3]UserInfo{  

    {Name: "John", Age: 25},  

    {Name: "Jane", Age: 30},  

    {Name: "Mike", Age: 28},  

    }  

for i := 0; i < len(UserInfoList); i++ {  

 

    UserInfoList[i].Age += i  

}  

fmt.Println(UserInfoList)



0

1

2

[{John 25} {Jane 31} {Mike 30}]

range

var UserInfoList = [3]UserInfo{  

    {Name: "John", Age: 25},  

    {Name: "Jane", Age: 30},  

    {Name: "Mike", Age: 28},  

    }  



  

for i, info := range UserInfoList {  

    info.Age += i  

}  

fmt.Println(UserInfoList)



[{John 25} {Jane 30} {Mike 28}]

可以看出for循环进行修改了成功，但是在range循环修改失效，为什么呢？因为range循环返回的是对该值的拷贝，所以修改失效。for循环修相当于进行原地修改了。但如果在for循环里面进行赋值修改操作，那么修改也会进行失效 具体如下

var UserInfoList = [3]UserInfo{  

    {Name: "John", Age: 25},  

    {Name: "Jane", Age: 30},  

    {Name: "Mike", Age: 28},  

}  

for i := 0; i < len(UserInfoList); i++ {  

    fmt.Println(i)  

    item := UserInfoList[i]  

    item.Age += i  

  

}  

  



fmt.Println(UserInfoList)

> [{John 25} {Jane 30} {Mike 28}]

3. Benchmark大比拼

主要是针对大类型结构体

type Item struct {  

    id int  

    val [4096]byte  

}

for_test.go

func BenchmarkForStruct(b *testing.B) {  

    var items [1024]Item  

    for i := 0; i < b.N; i++ {  

        length := len(items)  

        var tmp int  

        for k := 0; k < length; k++ {  

            tmp = items[k].id  

        }  

        _ = tmp  

    }  

}

func BenchmarkRangeStruct(b *testing.B) {  

    var items [1024]Item  

    for i := 0; i < b.N; i++ {  

        var tmp int  

        for _, item := range items {  

            tmp = item.id  

        }  

        _ = tmp  

    }  

}

goos: windows

goarch: amd64

pkg: article/02fortest

cpu: AMD Ryzen 5 5600G with Radeon Graphics

BenchmarkForStruct-12            2503378               474.8 ns/op             0 B/op          0 allocs/op

BenchmarkRangeStruct-12             4983            232744 ns/op               0 B/op          0 allocs/op

PASS

ok      article/02fortest       3.268s

可以看出 for 的性能大约是 range 的 600 倍。

为什么会产生这么大呢？

上述也说过，range遍历会对迭代的值创建一个拷贝。在占据占用较大的结构时每次都需要进行做一次拷贝，取申请大约4kb的内存，显然是大可不必的。所以在对于占据较大的结构时，应该使用for进行变量操作。

总结

如何选择合适的遍历，在针对与测试场景的情况下，图便捷可以使用range，毕竟for循环需要写一堆的条件，初始值等。但是如果遍历的元素是个占用大个内存的结构的话，避免使用range进行遍历。且如果需要进行修改操作的话只能用for遍历来修改，其实range也可以进行索引遍历的，在本文为写，读者可以去尝试一下。

前言

  Java 编程语言的每一次重要更新，都引入了许多新功能和改进。 并且在String 类中引入了一些新的方法，能够更好地满足开发的需求，提高编程效率。

1. repeat(int count)：返回一个新的字符串，该字符串是由原字符串重复指定次数形成的。
2. isBlank()：检查字符串是否为空白字符序列，即长度为 0 或仅包含空格字符的字符串。
3. lines()：返回一个流，该流由字符串按行分隔而成。
4. strip()：返回一个新的字符串，该字符串是原字符串去除前导空格和尾随空格后形成的。
5. stripLeading()：返回一个新的字符串，该字符串是原字符串去除前导空格后形成的。
6. stripTrailing()：返回一个新的字符串，该字符串是原字符串去除尾随空格后形成的。
7. formatted(Object... args)：使用指定的参数格式化字符串，并返回格式化后的字符串。
8. translateEscapes()：将 Java 转义序列转换为相应的字符，并返回转换后的字符串。
9. transform() 方法：该方法可以将一个函数应用于字符串，并返回函数的结果。

示例

1. repeat(int count)

public class StringRepeatExample {

    public static void main(String[] args) {

        String str = "abc";

        String repeatedStr = str.repeat(3);

        System.out.println(repeatedStr);

    }

}

输出结果：

abcabcabc

2. isBlank()

public class StringIsBlankExample {

    public static void main(String[] args) {

        String str1 = "";

        String str2 = " ";

        String str3 = "  \t  ";



        System.out.println(str1.isBlank());

        System.out.println(str2.isBlank());

        System.out.println(str3.isBlank());

    }

}

输出结果：

true

true

true

3. lines()

import java.util.stream.Stream;



public class StringLinesExample {

    public static void main(String[] args) {

        String str = "Hello\nWorld\nJava";

        Stream<String> lines = str.lines();

        lines.forEach(System.out::println);

    }

}

输出结果：

Hello

World

Java

4. strip()

public class StringStripExample {

    public static void main(String[] args) {

        String str1 = "  abc   ";

        String str2 = "\t def \n";

        System.out.println(str1.strip());

        System.out.println(str2.strip());

    }

}

输出结果：

abc

def

5. stripLeading()

public class StringStripLeadingExample {

    public static void main(String[] args) {

        String str1 = "  abc   ";

        String str2 = "\t def \n";

        System.out.println(str1.stripLeading());

        System.out.println(str2.stripLeading());

    }

}

输出结果：

abc

def

6. stripTrailing()

public class StringStripTrailingExample {

    public static void main(String[] args) {

        String str1 = "  abc   ";

        String str2 = "\t def \n";

        System.out.println(str1.stripTrailing());

        System.out.println(str2.stripTrailing());

    }

}

输出结果：

abc

def

7. formatted(Object... args)

public class StringFormattedExample {

    public static void main(String[] args) {

        String str = "My name is %s, I'm %d years old.";

        String formattedStr = str.formatted( "John", 25);

        System.out.println(formattedStr);

    }

}

输出结果：

My name is John, I'm 25 years old.

8. translateEscapes()

public class StringTranslateEscapesExample {

    public static void main(String[] args) {

        String str = "Hello\\nWorld\\tJava";

        String translatedStr = str.translateEscapes();

        System.out.println(translatedStr);

    }

}

输出结果：

Hello

World   Java

9. transform()

public class StringTransformExample {

    public static void main(String[] args) {  

        String str = "hello world";  

        String result = str.transform(i -> i + "！");  

        System.out.println(result);  

    }

}

输出结果：

hello world！

结尾

  如果觉得对你有帮助，可以多多评论，多多点赞哦，也可以到我的主页看看，说不定有你喜欢的文章，也可以随手点个关注哦，谢谢。

  我是不一样的科技宅，每天进步一点点，体验不一样的生活。我们下

人比山高

大家好，我是寒草，一只工作两年的程序猿。农历七月初五，阳历八月七日是我的生日，小时候总是期盼生日的到来，而且总有一种我过生日的那天我就是山大王的错觉，毕竟可以吃香的，喝辣的。但是我也早就度过了无忧无虑的年纪，而生日这一天的意义也早就有所不同。

长大后，每当生日临近，总是思绪万千，或是思考过去，或是展望未来，年少时的悠哉不再，而思绪确是一年比一年多，有一位著名工程师曾经说过：

思绪和发量是负相关的。

虽然上面这个定律在我身上还没有印证，但是我不妨借生日这个难得的机会整理一下，收拾行囊，以便整装待发。

脚比路长

写文的当下，我正在思考，去年写文章的时候是什么样的心理：

• 持续亢奋？
• 充满希望？
• 活力四射？

反正在我印象里，去年的我心中是充满希望和活力的，但是现在的我肯定和去年大不相同，可能是因为这一年出现了很多的变化：

• 停不下来的裁员潮
• 一座座楼（公司）塌了

听了很多悲伤的事，也经历了很多令人消沉的事，使得我并不会如去年那般纯粹的充满活力，也以更加理性和辩证的去看待问题，世界也不再非黑即白，这大概就是“成长”吧，在此推荐：《少有人走的路》

在夜晚一个人走在回家的小路，我会思考很多很多事，但多数像泡沫一样飞散了，但是有一件事是我不会放弃的，也算是我长久以来的梦。

见下文

白山旭日

前一段时间，我开了一个新坑：程序猿之梦！星辰大海的前端建站之路「第一周」，没错，现在的我有一个理想，想创造一个自己的产品，我对她寄托了很多很多情感：

• 我希望她可以承载更多的美好
• 我希望她可以创造一股清流在网络社会流淌
• 我希望她可以为社会提供向上的价值
• ...

但是这个事情已经停摆了一个月了，毕竟我上个月大概上了 250 个小时的班，工作饱和度也基本来到了 150% ，整个人特别特别疲惫，掘金技术圈的群也是会经常 cue 到我的加班。

不要说我卷，我是很期望刘慈欣摸鱼写《三体》的那种生活的，但是生活所迫。

即使工作比较辛苦让我疲惫至极，我也会想把我的产品搞下去，我总是做不切实际的梦，我总是有一堆幻想，我总希望我从事的事业可以让世界更加美好，我总是焦虑，我总是烦躁，我总是有一种奇奇怪怪的理想主义，还有那么一丝丝的浪漫情怀。

所以，无论如何，我欣赏我，我会是我。

黑水金光

前几天农历生日的时候，同事们陪我过了一个生日：

我作为一个东北人，也是第一次吃到铁锅炖大鹅（我怕不是个假东北人），还是很开心的，我从小到大还是第一次这么“正式”的过生日，近几天也陆陆续续的收到一些礼物：

• 一把工学椅：这样我在家就可以更舒适的创作了
• 一个木制密码箱：最关键还需要我自己拼（其实我没有什么特别值得放在密码箱里的东西）
• 特利迦奥特曼：这肯定是很了解我的人才会送的礼物～
• ...

羁绊越来越多了呢🌟还是要充满阳光的好好生活呀～

旅程

如果大家有耐心读到这里，一定有这样的一个疑问：“你这前四个标题是什么意思？”，其实只是我摘取了我母校校歌中的几句词，同时我也想到很多关于母校的指引我前进的故事：

• 黄大年教授：振兴中华，乃我辈之责

已故，纪念文：「振兴中华，乃我辈之责」于75周年校庆使用 canvas 纪念黄大年老师

• 张希校长：群居不倚,独立不惧
• ...

最后，祝我自己 25 岁生日快乐 🎂

✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨

江山如此多娇，引无数英雄竞折腰。
惜秦皇汉武，略输文采；唐宗宋祖，稍逊风骚。
一代天骄，成吉思汗，只识弯弓射大雕。
俱往矣，数风流人物，还看今朝。

— 《沁园春.雪》

✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨

各位，感谢阅读，一起加油！也欢迎各位加我微信：hancao97 和我交流。

-寒草写于2022.08.06 🔥 To Be Continued-

在Android开发中，数据与界面的分离一直是一项重要的挑战。为了解决这个问题，Google推出了Android Jetpack组件之一的ViewModel。ViewModel是一种用于管理UI相关数据的架构组件，它能够帮助开发者实现优雅的数据驱动和生命周期管理。本文将深入浅出地介绍ViewModel的使用和原理，带你一步步掌握这个强大的组件。

什么是ViewModel

ViewModel是Android Jetpack组件之一，它的主要目的是将UI控制器（如Activity和Fragment）与数据相关的业务逻辑分开，使得UI控制器能够专注于展示数据和响应用户交互，而数据的获取和处理则交由ViewModel来管理。这种分离能够使代码更加清晰、易于测试和维护。

ViewModel的原理

ViewModel的原理其实并不复杂。在设备配置发生变化（如屏幕旋转）导致Activity或Fragment重建时，ViewModel不会被销毁，而是保留在内存中。这样，UI控制器可以在重建后重新获取之前的ViewModel实例，并继续使用其中的数据，从而避免数据丢失和重复加载。

ViewModelStore和ViewModelStoreOwner

ViewModel的原理涉及两个核心概念：ViewModelStore和ViewModelStoreOwner。

ViewModelStore是一个存储ViewModel实例的容器，它的生命周期与UI控制器的生命周期关联。在UI控制器（Activity或Fragment）被销毁时，ViewModelStore会清理其中的ViewModel实例，避免内存泄漏。

ViewModelStoreOwner是拥有ViewModelStore的对象，通常是Activity或Fragment。ViewModelProvider通过ViewModelStoreOwner来获取ViewModelStore，并通过ViewModelStore来管理ViewModel的生命周期。

ViewModelProvider

ViewModelProvider是用于创建和获取ViewModel实例的工具类。它负责将ViewModel与ViewModelStoreOwner关联，并确保ViewModel在合适的时机被销毁。

在Activity中获取ViewModel实例：

viewModel = new ViewModelProvider(this).get(MyViewModel.class);

在Fragment中获取ViewModel实例：

viewModel = new ViewModelProvider(this).get(MyViewModel.class);

使用ViewModel

添加ViewModel依赖

首先，确保你的项目已经使用了AndroidX，并在build.gradle中添加ViewModel依赖：

dependencies {

    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.3.1"

}

创建ViewModel

创建ViewModel非常简单，只需继承ViewModel类并在其中定义数据和相关操作。

public class MyViewModel extends ViewModel {

    private MutableLiveData<String> data = new MutableLiveData<>();



    public LiveData<String> getData() {

        return data;

    }



    public void fetchData() {

        // 模拟异步数据获取

        new Handler().postDelayed(() -> {

            data.setValue("Hello, ViewModel!");

        }, 2000);

    }

}

在UI控制器中使用ViewModel

在Activity或Fragment中获取ViewModel的实例，并观察数据变化：

viewModel = new ViewModelProvider(this).get(MyViewModel.class);

viewModel.getData().observe(this, data -> {

    // 更新UI

    textView.setText(data);

});



viewModel.fetchData(); // 触发数据获取操作

ViewModel与跨组件通信

ViewModel不仅仅用于在单个UI控制器内部共享数据，它还可以用于在不同UI控制器之间共享数据，实现跨组件通信。例如，一个Fragment中的数据可以通过ViewModel传递给Activity。

在Activity中共享数据：

sharedViewModel = new ViewModelProvider(this).get(SharedViewModel.class);

sharedViewModel.getData().observe(this, data -> {

    // 更新UI

    textView.setText(data);

});

在Fragment中共享数据：

sharedViewModel = new ViewModelProvider(requireActivity()).get(SharedViewModel.class);

注意：在跨组件通信时，需要使用同一个ViewModelProvider获取相同类型的ViewModel实例。在Activity中，使用this作为ViewModelProvider的参数，在Fragment中，使用requireActivity()作为参数。

ViewModel与SavedState

有时，我们可能希望在ViewModel中保存一些与UI控制器生命周期无关的数据，以便在重建时恢复状态。ViewModel提供了SavedState功能，它可以让我们在ViewModel中持久化保存数据。

示例代码：

public class MyViewModel extends ViewModel {

    private SavedStateHandle savedStateHandle;



    public MyViewModel(SavedStateHandle savedStateHandle) {

        this.savedStateHandle = savedStateHandle;

    }



    public LiveData<String> getData() {

        return savedStateHandle.getLiveData("data");

    }



    public void setData(String data) {

        savedStateHandle.set("data", data);

    }

}

使用SavedStateViewModelFactory创建带有SavedState功能的ViewModel：

public class MyActivity extends AppCompatActivity {

    private MyViewModel viewModel;



    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);



        ViewModelProvider.Factory factory = new SavedStateViewModelFactory(getApplication(), this);

        viewModel = new ViewModelProvider(this, factory).get(MyViewModel.class);



        viewModel.getData().observe(this, data -> {

            // 更新UI

            textView.setText(data);

        });



        if (savedInstanceState == null) {

            // 第一次创建时，触发数据获取操作

            viewModel.fetchData();

        }

    }

}

ViewModel使用过程中的注意点

• 不要在ViewModel中持有Context的引用，避免引发内存泄漏。
• ViewModel应该只关注数据和业务逻辑，不应处理UI相关的操作。
• 不要在ViewModel中保存大量数据，避免占用过多内存。
• 当数据量较大或需要跨进程共享数据时，应该考虑使用其他解决方案，如Room数据库或SharedPreferences。

结论

通过本文的介绍，你已经了解了Android Jetpack ViewModel的使用与原理。ViewModel的出现极大地简化了Android开发中的数据管理和生命周期处理，使得应用更加健壮和高效。在实际开发中，合理使用ViewModel能够帮助你构建优雅、易维护的Android应用。

介绍

TextView 是 Android 开发中最常用的小部件之一。它用于在屏幕上显示文本。但是，TextView 有几个较少为人知的功能，对开发人员非常有用。在本博客文章中，我们将探讨其中的一些功能。

自定义字体

默认情况下，TextView 使用系统字体显示文本。但其实我们也可以导入我们自己的字体文件在 TextView 中使用自定义字体。这可以通过将字体文件添加到资源文件夹（res/font 或者 assets）并在 TextView 上以编程方式设置来实现。

要使用自定义字体，我们需要下载字体文件（或者自己生成）并将其添加到资源文件夹中。然后，我们可以使用setTypeface（）方法在TextView上以编程方式设置字体。我们还可以在XML中使用android：fontFamily属性设置字体。需要注意的是，fontFamily方式只能使用系统预设的字体并且仅对英文字符有效，如果TextView的文本内容是中文的话这个属性设置后将不会有任何效果。

以下是 Android TextView 自定义字体的代码示例：

1. 将字体文件添加到 assets 或 res/font 文件夹中。
2. 通过以下代码设置字体：

// 字体文件放到 assets 文件夹的情况

Typeface tf = Typeface.createFromAsset(getAssets(), "fonts/myfont.ttf");

TextView tv = findViewById(R.id.tv);

tv.setTypeface(tf);

// 字体文件放到 res/font 文件夹的情况, 需注意的是此方式在部分低于 Android 8.0 的设备上可能会存在兼容性问题

val tv = findViewById<TextView>(R.id.tv)

val typeface = ResourcesCompat.getFont(this, R.font.myfont)

tv.typeface = typeface

在上面的示例中，我们首先从 assets 文件夹中创建了一个新的 Typeface 对象。然后，我们使用 setTypeface() 方法将该对象设置为 TextView 的字体。

在上面的示例中，我们将字体文件命名为 “myfont.ttf”。我们可以将其替换为要使用的任何字体文件的名称。

自定义字体是 TextView 的强大功能之一，它可以帮助我们创建具有独特外观和感觉的应用程序。另外，我们也可以通过这种方法实现自定义图标的绘制。

AutoLink

AutoLink 可以自动检测文本中的模式并将其转换为可点击的链接。例如，如果 TextView 包含电子邮件地址或 URL，则 AutoLink 将识别它并使其可点击。此功能使开发人员无需手动创建文本中的可点击链接。

要在 TextView 上启用 AutoLink，您需要将autoLink属性设置为email，phone，web或all。您还可以使用Linkify类设置自定义链接模式。

以下是一个Android TextView AutoLink代码使用示例：

<TextView

    android:id="@+id/tv3"

    android:layout_width="match_parent"

    android:layout_height="wrap_content"

    android:autoLink="web"

    android:textColorLink="@android:color/holo_red_dark"

    android:text="这是我的个人博客地址: http://www.geektang.cn" />

在上面的示例中，我们将 autoLink 属性设置为 web ，这意味着 TextView 将自动检测文本中的 URL 并将其转换为可点击的链接。我们还将 text 属性将文本设置为 这是我的个人博客地址: http://www.geektang.cn 。当用户单击链接时，它们将被带到 http://www.geektang.cn 网站。另外，我们也可以通过 textColorLink 属性将 Link 颜色为我们喜欢的颜色。

AutoLink是一个非常有用的功能，它可以帮助您更轻松地创建可交互的文本。

对齐模式

对齐模式允许您通过在单词之间添加空格将文本对齐到左右边距，这使得文本更易读且视觉上更具吸引力。您可以将对齐模式属性设置为 inter_word 或 inter_character。

要使用对齐模式功能，您需要在 TextView 上设置 justificationMode 属性。但是，此功能仅适用于运行 Android 8.0（API 级别 26）或更高版本的设备。

以下是对齐模式功能的代码示例：

<TextView

    android:id="@+id/text_view"

    android:layout_width="match_parent"

    android:layout_height="wrap_content"

    android:text="This is some sample text that will be justified."

    android:justificationMode="inter_word"/>

在上面的示例中，我们将 justificationMode 属性设置为 inter_word 。这意味着 TextView 将在单词之间添加空格，以便将文本对齐到左右边距。

以下是对齐模式功能的显示效果示例：

同样一段文本，上面的设置 justificationMode 为 inter_word ，是不是看起来会比下面的好看一些呢？这个属性一般用于多行英文文本，如果只有一行文本或者文本内容是纯中文字符的话，不会有任何效果。

排序算法

数组任意两值交换

创建临时变量进行交换

private void swap(int[] nums, int idx1, int idx2) {

    int temp = nums[idx1];

    nums[idx1] = nums[idx2];

    nums[idx2] = temp;

}

冒泡排序

思路：每次对 [0, j] 进行排序，把该区间中最大的值放到这个区间的最右边；

时间复杂度：O(n2)

空间复杂度：O(1)

/**

 * 冒泡排序

 *

 * @param nums 数组

 */

public void bubbleSort(int[] nums) {

    for (int i = 0; i < nums.length - 1; i++) {

        for (int j = 0; j < nums.length - 1 - i; j++) {

            if (nums[j] > nums[j + 1]) {

                swap(nums, j, j + 1);

            }

        }

    }

}

选择排序

思路：对于区间 [j, nums.length] （i <= j <= nums.length），每次在这个区间中选择最小的值，插入到 nums[i] 中，即每次选择一个最小的值插入到 nums[i] 中；

时间复杂度：O(n2)

空间复杂度：O(1)

/**

 * 插入排序

 *

 * @param nums 数组

 */

public void insertSort(int[] nums) {

    for (int i = 0; i < nums.length; i++) {

        int idx = 0;

        int min = Integer.MAX_VALUE;

        for (int j = i; j < nums.length; j++) {

            if (nums[j] < min) {

                min = nums[j];

                idx = j;

            }

        }

        swap(nums, i, idx);

    }

}

插入排序

思路：对于区间 [0, j] ，在 [i, length-1] 的区间中每次使用下标的 i 的数（ j <= i ），插入到区间 [0, j] 中，保证 [0, j] 是有序的

时间复杂度：O(n2)

空间复杂度：O(1)

/**

 * 插入排序

 *

 * @param nums 数组

 */

public void insertSort(int[] nums) {

    for (int i = 1; i < nums.length; i++) {

        int temp = nums[i];

        int j = i;

        for (; j > 0; j--) {

            if (temp < nums[j - 1]) {

                nums[j] = nums[j - 1];

            } else {

                break;

            }

        }

        nums[j] = temp;

    }

}

快速排序

思路：

1. 对于单次的排序 partition() ，定义一个标志 part ，凡是小于该值的都放左边，大于该值的都放右边，最后把该值放到中间，并返回中间的下标 partition ，这里实现的关键是：存在一个指针 j 始终指向左边区间的最靠右的值，若 j + 1，则去到了右区间；
2. 将数组以 partition 为中点，将数组分成两份，每一份继续进行 partition()；

时间复杂度：O(nlogn)

空间复杂度：O(logn)

/**

 * 递归函数

 *

 * @param nums  数组

 * @param left  左

 * @param right 右

 */

public void quickSort(int[] nums, int left, int right) {



    if (left >= right) {

        return;

    }



    int partition = partition(nums, left, right);



    quickSort(nums, left, partition - 1);

    quickSort(nums, partition + 1, right);

}



/**

 * 将小于某个元素的值放到左边，大于某个元素的值放到右边

 *

 * @param nums  数组

 * @param left  左

 * @param right 右

 * @return 结果

 */

public int partition(int[] nums, int left, int right) {

    // 以数组的左边的值作为标记

    int part = nums[left];

    int i = left + 1;

    // j 始终指向左边区间小于或等于 part 的最靠右的值

    int j = left;



    for (; i < nums.length; i++) {

        if (nums[i] < part) {

            j++;

            swap(nums, i, j);

        }

    }



    swap(nums, j, left);

    return j;

}

三向切分快速排序

适用于有重复内容的排序

思路：

1. 分成三个区间，小于 pivot（左区间），等于 pivot（中区间），大于 pivot（右区间）；
2. 左区间的 lt 指针永远指向该区间的最右的位置，右区间的指针永远指向该区间的最左的位置；
3. 对于中区间，不断移动游标 i 的位置即可；

时间复杂度：O(nlogn)

空间复杂度：O(logn)

public void threeQuickSort(int[] nums, int left, int right) {

    if (left >= right) {

        return;

    }

    int pivot = nums[left];



    // [left + 1, lt] 小于 pivot

    // [lt + 1, i) 等于 pivot

    // [gt, right] 大于 pivot

    int lt = left;  // 左区间的指针

    int gt = right + 1;  // 右区间的指针

    int i = left + 1;



    while (i < gt) {

        if (nums[i] < pivot) {

            lt++;

            swap(nums, i, lt);

            i++;

        } else if (nums[i] == pivot) {

            i++;

        } else {

            gt++;

            swap(nums, gt, i);

        }

    }

    swap(nums, left, lt);

    threeQuickSort(nums, left, lt - 1);

    threeQuickSort(nums, gt, right);

}

归并排序

思路：

1. 分隔：先将数组不断分割，直到分割到区间 [left, right] 内只有一个值
2. 合并：将分隔后的数组不断向上合并，利用临时数组 temp[] 存储 原来 nums 数组 [left，right] 区间的值，然后分别从 temp 数组中 [left, mid] 和 [mid + 1, right] 区间分别取出最小的值，放入 nums 数组对应的位置即可；
3. 代码的主要难点是 nums 数组 和 temp 数组的下标对应关系

1. 1. i 对应 left，即 [left, mid] 的起点，i 在 temp 数组起始值为 0
   2. j 对应 mid + 1，即 [mid + 1, right] 的起点，j 在 temp 数组起始值为 mid - left + 1

时间复杂度：O(nlogn)

空间复杂度：O(n + logn) => O(n)：临时的数组和递归时压入栈的数据占用的空间

public void mergeSort(int[] nums, int left, int right) {



    if (left >= right) {

        return;

    }

    int mid = left + (right - left) / 2;



    mergeSort(nums, left, mid);

    mergeSort(nums, mid + 1, right);



    merge(nums, left, mid, right);

}



/**

 * 合并数组

 *

 * @param nums  数组

 * @param left  左端点

 * @param mid   中点

 * @param right 右端点

 */

private void merge(int[] nums, int left, int mid, int right) {

    int length = right - left + 1;

    int[] temp = new int[length];



    for (int i = 0; i < length; i++) {

        temp[i] = nums[left + i];

    }



    // i j 为 temp 数组的下标

    // 关键是找到 i j 与 原数组 nums 下标的对应关系

    int i = 0;

    int j = mid - left + 1;

    for (int k = 0; k < length; k++) {

        if (i == mid - left + 1) {

            nums[k + left] = temp[j];

            j++;

        } else if (j == right - left + 1) {

            nums[k + left] = temp[i];

            i++;

        } else if (temp[i] <= temp[j]) {

            nums[k + left] = temp[i];

            i++;

        } else {

            nums[k + left] = temp[j];

            j++;

        }

    }

}

堆排序

思路：

1. 读者首先搞懂什么是 堆 ，代码示例中介绍的 大顶堆，这里不作过多介绍；
2. 首先初始化一个大顶堆，每个大顶堆的根节点是最大值；
3. 不断把根节点的值与数组最后一个值交换，然后长度减 1 再次进行大顶堆的整理操作；

时间复杂度：O(nlogn)，每次整理的时间复杂度是 logn，要进行 n 次

空间复杂度：O(1)

/**

     * 堆排序

     *

     * @param nums 数组

     */

    public void heapSort(int[] nums) {

        initMaxHeap(nums);

        int len = nums.length - 1;

        while (len > 0) {

            swap(nums, 0, len);

            len--;

            siftDown(nums, 0, len);

        }

    }



    /**

     * 初始化为大顶堆

     *

     * @param nums 数组

     */

    public void initMaxHeap(int[] nums) {

        int len = nums.length;

        for (int i = (len - 1) / 2; i >= 0; i--) {

            siftDown(nums, i, len - 1);

        }

    }



    /**

     * 向下整理

     * @param nums 数组

     * @param k 某个节点

     * @param len 数组长度

     */

    public void siftDown(int[] nums, int k, int len) {



        while (k * 2 + 1 <= len) {

            int j = k * 2 + 1;

            if (j + 1 <= len && nums[j] < nums[j + 1]) {

                j++;

            }

            if (nums[k] > nums[j]) {

                break;

            }

            swap(nums, k, j);

            k = j;

        }

    }

过滤器

数据准备

• DAO 层 UserDao、AccountDao、BookDao、EquipmentDao

  public interface UserDao {
  
  	public void save();
  
  }

  @Component("userDao")
  
  public class UserDaoImpl implements UserDao {
  
      public void save() {
  
          System.out.println("user dao running...");
  
      }
  
  
  
  }
  
  

• Service 业务层

  public interface UserService {
  
      public void save();
  
  }

  @Service("userService")
  
  public class UserServiceImpl implements UserService {
  
      @Autowired
  
      private UserDao userDao;//...........BookDao等
  
  
  
      public void save() {
  
          System.out.println("user service running...");
  
          userDao.save();
  
      }
  
  }
  
  

过滤器

名称：TypeFilter

类型：接口

作用：自定义类型过滤器

示例：

• config / filter / MyTypeFilter

  public class MyTypeFilter implements TypeFilter {
  
      @Override
  
      /**
  
      * metadataReader:读取到的当前正在扫描的类的信息
  
      * metadataReaderFactory:可以获取到任何其他类的信息
  
      */
  
      //加载的类满足要求，匹配成功
  
      public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
  
          //获取当前类注解的信息
  
  		AnnotationMetadata am = metadataReader.getAnnotationMetadata();
  
  		//获取当前正在扫描的类的类信息
  
  		ClassMetadata classMetadata = metadataReader.getClassMetadata();
  
  		//获取当前类资源（类的路径）
  
  		Resource resource = metadataReader.getResource();
  
          
  
          
  
          //通过类的元数据获取类的名称
  
          String className = classMetadata.getClassName();
  
          //如果加载的类名满足过滤器要求，返回匹配成功
  
          if(className.equals("service.impl.UserServiceImpl")){
  
         	//返回true表示匹配成功，返回false表示匹配失败。此处仅确认匹配结果，不会确认是排除还是加入，排除/加入由配置项决定，与此处无关
  
              return true;
  
          }
  
          return false;
  
      }
  
  }
  
  

• SpringConfig

  @Configuration
  
  //设置排除bean，排除的规则是自定义规则（FilterType.CUSTOM），具体的规则定义为MyTypeFilter
  
  @ComponentScan(
  
          value = {"dao","service"},
  
          excludeFilters = @ComponentScan.Filter(
  
                  type= FilterType.CUSTOM,
  
                  classes = MyTypeFilter.class
  
          )
  
  )
  
  public class SpringConfig {
  
  }
  
  

导入器

bean 只有通过配置才可以进入 Spring 容器，被 Spring 加载并控制

• 配置 bean 的方式如下：

  • XML 文件中使用 标签配置
  • 使用 @Component 及衍生注解配置

导入器可以快速高效导入大量 bean，替代 @Import({a.class,b.class})，无需在每个类上添加 @Bean

名称： ImportSelector

类型：接口

作用：自定义bean导入器

• selector / MyImportSelector

  public class MyImportSelector implements ImportSelector{
  
      @Override
  
      public String[] selectImports(AnnotationMetadata importingClassMetadata) {
  
  //      1.编程形式加载一个类
  
  //      return new String[]{"dao.impl.BookDaoImpl"};
  
  
  
  //      2.加载import.properties文件中的单个类名
  
  //      ResourceBundle bundle = ResourceBundle.getBundle("import");
  
  //      String className = bundle.getString("className");
  
  
  
  //      3.加载import.properties文件中的多个类名
  
          ResourceBundle bundle = ResourceBundle.getBundle("import");
  
          String className = bundle.getString("className");
  
          return className.split(",");
  
      }
  
  }
  
  

• import.properties

  #2.加载import.properties文件中的单个类名
  
  #className=dao.impl.BookDaoImpl
  
  
  
  #3.加载import.properties文件中的多个类名
  
  #className=dao.impl.BookDaoImpl,dao.impl.AccountDaoImpl
  
  
  
  #4.导入包中的所有类
  
  path=dao.impl.*
  
  

• SpringConfig

  @Configuration
  
  @ComponentScan({"dao","service"})
  
  @Import(MyImportSelector.class)
  
  public class SpringConfig {
  
  }
  
  

注册器

可以取代 ComponentScan 扫描器

名称：ImportBeanDefinitionRegistrar

类型：接口

作用：自定义 bean 定义注册器

• registrar / MyImportBeanDefinitionRegistrar

  public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
  
  /**
  
   * AnnotationMetadata:当前类的注解信息
  
   * BeanDefinitionRegistry:BeanDefinition注册类，把所有需要添加到容器中的bean调用registerBeanDefinition手工注册进来
  
   */
  
      @Override
  
      public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
  
          //自定义注册器
  
          //1.开启类路径bean定义扫描器，需要参数bean定义注册器BeanDefinitionRegistry，需要制定是否使用默认类型过滤器
  
          ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(registry,false);
  
          //2.添加包含性加载类型过滤器（可选，也可以设置为排除性加载类型过滤器）
  
          scanner.addIncludeFilter(new TypeFilter() {
  
              @Override
  
              public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
  
                  //所有匹配全部成功，此处应该添加实际的业务判定条件
  
                  return true;
  
              }
  
          });
  
          //设置扫描路径
  
          scanner.addExcludeFilter(tf);//排除
  
          scanner.scan("dao","service");
  
      }
  
  }
  
  

• SpringConfig

  @Configuration
  
  @Import(MyImportBeanDefinitionRegistrar.class)
  
  public class SpringConfig {
  
  }
  
  

处理器

通过创建类继承相应的处理器的接口，重写后置处理的方法，来实现拦截 Bean 的生命周期来实现自己自定义的逻辑

BeanPostProcessor：bean 后置处理器，bean 创建对象初始化前后进行拦截工作的

BeanFactoryPostProcessor：beanFactory 的后置处理器

•  加载时机：在 BeanFactory 初始化之后调用，来定制和修改 BeanFactory 的内容；所有的 bean 定义已经保存加载到 beanFactory，但是 bean 的实例还未创建

•   执行流程：
  
  

  • ioc 容器创建对象

  • invokeBeanFactoryPostProcessors(beanFactory)：执行 BeanFactoryPostProcessor

    • 在 BeanFactory 中找到所有类型是 BeanFactoryPostProcessor 的组件，并执行它们的方法
    • 在初始化创建其他组件前面执行

BeanDefinitionRegistryPostProcessor：

• 加载时机：在所有 bean 定义信息将要被加载，但是 bean 实例还未创建，优先于 BeanFactoryPostProcessor 执行；利用 BeanDefinitionRegistryPostProcessor 给容器中再额外添加一些组件

• 执行流程：

  • ioc 容器创建对象

  • refresh() → invokeBeanFactoryPostProcessors(beanFactory)

  • 从容器中获取到所有的 BeanDefinitionRegistryPostProcessor 组件

    • 依次触发所有的 postProcessBeanDefinitionRegistry() 方法
    • 再来触发 postProcessBeanFactory() 方法

监听器

基本概述

ApplicationListener：监听容器中发布的事件，完成事件驱动模型开发

public interface ApplicationListener<E extends ApplicationEvent>

所以监听 ApplicationEvent 及其下面的子事件

应用监听器步骤：

• 写一个监听器（ApplicationListener实现类）来监听某个事件（ApplicationEvent及其子类）

• 把监听器加入到容器 @Component

• 只要容器中有相关事件的发布，就能监听到这个事件；

  •  ContextRefreshedEvent：容器刷新完成（所有 bean 都完全创建）会发布这个事件

  •  ContextClosedEvent：关闭容器会发布这个事件
    
    

• 发布一个事件：applicationContext.publishEvent()

@Component

public class MyApplicationListener implements ApplicationListener<ApplicationEvent> {

	//当容器中发布此事件以后，方法触发

	@Override

	public void onApplicationEvent(ApplicationEvent event) {

		System.out.println("收到事件：" + event);

	}

}

实现原理

ContextRefreshedEvent 事件：

• 容器初始化过程中执行 initApplicationEventMulticaster()：初始化事件多播器

  • 先去容器中查询 id = applicationEventMulticaster 的组件，有直接返回
  • 没有就执行 this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory) 并且加入到容器中
  • 以后在其他组件要派发事件，自动注入这个 applicationEventMulticaster

• 容器初始化过程执行 registerListeners() 注册监听器

  • 从容器中获取所有监听器：getBeanNamesForType(ApplicationListener.class, true, false)
  • 将 listener 注册到 ApplicationEventMulticaster

• 容器刷新完成：finishRefresh() → publishEvent(new ContextRefreshedEvent(this))

  发布 ContextRefreshedEvent 事件：

  • 获取事件的多播器（派发器）：getApplicationEventMulticaster()

  • multicastEvent 派发事件

    • 获取到所有的 ApplicationListener

    • 遍历 ApplicationListener

      • 如果有 Executor，可以使用 Executor 异步派发 Executor executor = getTaskExecutor()
      • 没有就同步执行 listener 方法 invokeListener(listener, event)，拿到 listener 回调 onApplicationEvent

容器关闭会发布 ContextClosedEvent

Frp是什么

简单地说，frp就是一个反向代理软件，它体积轻量但功能很强大，可以使处于内网或防火墙后的设备对外界提供服务，它支持HTTP、TCP、UDP等众多协议。

服务端配置

SSH连接到VPS之后运行如下命令查看处理器架构，根据架构下载不同版本的frp
运行如下命令，根据架构不同，选择相应版本并进行下载

wget https://github.com/fatedier/frp/releases/download/v0.22.0/frp_0.22.0_linux_amd64.tar.gz

然后解压缩

tar -zxvf frp_0.22.0_linux_amd64.tar.gz

服务端的配置我们只需要关注如下几个文件

• frps
• frps.ini

这两个文件（s结尾代表server）分别是服务端程序和服务端配置文件
然后修改frps.ini文件

[common]

bind_port = 49273

vhost_http_port = 9001

token = Er3@SGTwHtPl+jMRD0/f3QH/A

• “bind_port”表示用于客户端和服务端连接的端口，这个端口号我们之后在配置客户端的时候要用到。
• “vhost_http_port”和“vhost_https_port”用于反向代理HTTP主机时使用。
• “token”是用于客户端和服务端连接的口令，请自行设置并记录，稍后会用到。

编辑完成后保存（vim保存如果不会请自行搜索)

客户端配置

frp的客户端就是我们想要真正进行访问的那台设备。
同样地，根据客户端设备的情况选择相应的frp程序进行下载，将“frp_0.22.0_windows_amd64.zip”解压
客户端的配置我们只需要关注如下几个文件

• frpc

• frpc.ini

  这两个文件（c结尾代表client）分别是客户端程序和客户端配置文件。
  然后修改frpc.ini文件

[common]

server_addr = 52.80.184.170

server_port = 49273

token = Er3@SGTwHtPl+jMRD0/f3QH/A



[sentry]

type = http

local_ip = 10.10.75.137

local_port = 9001

custom_domains = 172.31.20.248

其中common字段下的三项即为服务端的设置。

• “server_addr”为服务端IP地址，填入即可。
• “server_port”为服务器端口，填入你设置的端口号即可。
• “token”是你在服务器上设置的连接口令，原样填入即可。

自定义规则

上面frpc.ini的sentry字段是自己定义的规则，自定义端口对应时格式如下。

• “[xxx]”表示一个规则名称，自己定义，便于查询即可。
• “type”表示转发的协议类型，有TCP和UDP等选项可以选择，如有需要请自行查询frp手册。
• “local_ip”是本地应用的IP地址，按照实际应用工作在本机的IP地址填写即可。
• “local_port”是本地应用的端口号，按照实际应用工作在本机的端口号填写即可。
• “custom_domains”服务端IP地址或域名，可以直接使用服务端ip或者生成一个内网ip。

后台运行脚本

运行服务端

./frpc -c frps.ini

运行客户端

./frpc -c frpc.ini

至此，我们的frp仅运行在前台，如果Ctrl+C停止或者关闭SSH窗口后，frp均会停止运行，因而我们使用 nohup命令将其运行在后台。
服务端创建start.sh脚本文件以及frps.log日志文件 编辑start.sh

nohup ./frps -c frps.ini &> frps.log &

客户端创建start.sh脚本文件以及frpc.log日志文件 编辑start.sh

nohup ./frpc -c frpc.ini &> frpc.log &

客户端和服务端执行start.sh脚本

./stash

查看log日志

tail -f frps.log

tail -f frpc.log

一篇文章学会正则表达式(Kotlin举例)

正则表达式是一种用来匹配字符串的工具，它可以在文本中查找特定的模式，从而实现对文本的处理和分析。在很多编程语言中，正则表达式都是非常重要的一部分。

了解正则表达式

在学习正则表达式之前，我们需要先了解一些基本概念。正则表达式由一系列字符和特殊字符组成，用来匹配字符串中的模式。例如，我们可以使用正则表达式来匹配一个电话号码、一个电子邮件地址或者一个网址。正则表达式中的一些常用特殊字符包括：

• .：匹配任意一个字符。
• *：匹配前面的字符零次或多次。
• +：匹配前面的字符一次或多次。
• ?：匹配前面的字符零次或一次。
• |：表示或的关系，匹配两边任意一边的内容。
• ()：表示分组，可以将多个字符组合成一个整体。
• ^：匹配字符串的开头。
• $：匹配字符串的结尾。
• {n}：匹配前面的字符恰好出现 n 次。
• {n,}：匹配前面的字符

正则表达式的基本语法

正则表达式的基本语法包括两个部分：模式和修饰符。模式是用来匹配字符串的规则，而修饰符则用来控制匹配的方式。

在 Kotlin 中，我们可以使用 Regex 类来表示一个正则表达式。例如，下面的代码定义了一个简单的正则表达式，用来匹配一个由数字组成的字符串：

val pattern = Regex("\\d+")

在这个正则表达式中，\d 表示匹配一个数字，+ 表示匹配前面的字符一次或多次。注意，在 Kotlin 中，我们需要使用 \\ 来表示 \ 字符，因为 \ 在字符串中有特殊的含义。

接下来，我们可以使用 matchEntire 函数来检查一个字符串是否符合这个正则表达式：

val input = "12345"

if (pattern.matchEntire(input) != null) {

    println("Match!")

} else {

    println("No match.")

}

这个代码会输出 Match!，因为输入的字符串符合正则表达式的规则。

常见的正则表达式的高级用法

除了基本的语法之外，正则表达式还有很多高级用法，可以实现更加复杂的匹配和替换操作。下面是一些常用的高级用法：

1. 捕获组

捕获组是指用 () 包围起来的一部分正则表达式，可以将匹配到的内容单独提取出来。例如，下面的代码定义了一个正则表达式，用来匹配一个由姓和名组成的字符串：

val pattern = Regex("(\\w+)\\s+(\\w+)")

val input = "John Smith"

val matchResult = pattern.matchEntire(input)

if (matchResult != null) {

    val firstName = matchResult.groupValues[1]

    val lastName = matchResult.groupValues[2]

    println("First name: $firstName")

    println("Last name: $lastName")

}

在这个代码中，\\w+ 表示匹配一个或多个字母、数字或下划线，\\s+ 表示匹配一个或多个空格。groupValues属性可以返回一个列表，其中包含了所有捕获组的内容。在这个例子中，groupValues[1] 表示第一个捕获组的内容，即姓，groupValues[2] 表示第二个捕获组的内容，即名。

2. 非捕获组

非捕获组是指用 (?:) 包围起来的一部分正则表达式，它和普通的捕获组的区别在于，非捕获组匹配到的内容不会单独提取出来。例如，下面的代码定义了一个正则表达式，用来匹配一个由单词和空格组成的字符串：

val pattern = Regex("(?:\\w+\\s+)+\\w+")

val input = "one two three four"

val matchResult = pattern.matchEntire(input)

if (matchResult != null) {

    println("Match!")

} else {

    println("No match.")

}

在这个代码中，(?:\\w+\\s+)+ 表示匹配一个或多个单词和空格组成的片段，\\w+ 表示匹配一个或多个字母、数字或下划线，\\s+ 表示匹配一个或多个空格。注意，这个正则表达式并没有使用捕获组，因此 matchResult.groupValues 的结果是一个空列表。

3. 零宽断言

零宽断言是指用 (?=) 或 (?!) 包围起来的一部分正则表达式，它可以在匹配的时候不消耗任何字符。例如，下面的代码定义了一个正则表达式，用来匹配一个以 http 或 https 开头的 URL：

val pattern = Regex("(?=http|https)\\w+")

val input = "https://www.google.com"

val matchResult = pattern.find(input)

if (matchResult != null) {

    println("Match: ${matchResult.value}")

} else {

    println("No match.")

}

在这个代码中，(?=http|https) 表示匹配一个以 http 或 https 开头的字符串，但是不消耗任何字符。find 函数可以在输入字符串中查找第一个匹配的子串，返回一个 MatchResult? 类型的结果。

总结

本文介绍了正则表达式的基本概念和语法，以及一些常用的高级用法。在实际的编程中，正则表达式是一种非常有用的工具，可以帮助我们快速地处理和分析文本数据。在 Kotlin 中，我们可以使用 Regex 类来表示和操作正则表达式，同时还可以使用一些高级用法来实现更加复杂的匹配和替换操作。

前言

本文将讲述ThreadLocal的实现原理，还有## ThreadLocal为什么使用弱引用。

ThreadLocal

ThreadLocal 是 Java 中的一个类，用于在多线程环境下为每个线程提供独立的变量副本。它通常用于解决多线程并发访问共享变量时的线程安全性问题。

ThreadLocal 的工作原理是每个线程内部维护一个 ThreadLocalMap 对象，该对象用于存储每个线程的变量副本。当通过 ThreadLocal 对象获取变量时，它会首先检查当前线程是否已经创建了该变量的副本，如果有，则直接返回副本；如果没有，则通过初始化方法创建一个新的副本，并将其保存在当前线程的 ThreadLocalMap 中。

使用 ThreadLocal 时，每个线程都可以独立地访问和修改自己的变量副本，而不会影响其他线程的副本。这使得在多线程环境中共享变量变得更加安全和可靠。

需要注意的是，使用 ThreadLocal 时要注意及时清理不再使用的变量副本，以避免内存泄漏问题。可以通过调用 remove() 方法来清除当前线程的变量副本。

源码解释

set方法源码

// ThreadLocal的set方法，value是要保存的值

public void set(T value) {

    // 得到当前线程对象

    Thread t = Thread.currentThread();

    // 得到当前线程对象关联的ThreadLocalMap对象

    ThreadLocalMap map = getMap(t);

    // 得到map对象就保存值，键为当前ThreadLocal对象

    // 如果没有map对象就创建一个map对象，保存值

    if (map != null)

        map.set(this, value);

    else

        createMap(t, value);

}

// 得到当前线程关联的ThreadLocalMap对象

ThreadLocalMap getMap(Thread t) {

       return t.threadLocals;

}

// 创建一个ThreadLocalMap对象，赋给当前线程的threadLocals属性，并且存入值

void createMap(Thread t, T firstValue) {

       t.threadLocals = new ThreadLocalMap(this, firstValue);

}

private void set(ThreadLocal<?> key, Object value) {

    Entry[] tab = table;

    int len = tab.length;

    // 通过key计算在tab数组中的槽位i

    int i = key.threadLocalHashCode & (len-1);

    // 拿到槽位上的Entry对象，如果不为null，则进入循环，如果为null则表示可以直接加入该槽位

    // e = tab[i = nextIndex(i, len)])取出下一个槽位的Entry实体，如果为null，则表示可以直接添加进该槽位

    for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) {

        // 拿到与当前Entry有关联的ThreadLocal对象

        ThreadLocal<?> k = e.get();

        // 如果k与当前要保存值的key相等，则替换掉value，相当于修改key的值

        if (k == key) {

            e.value = value;

            return;

        }

        // 检查当前节点的ThreadLocal如果为null，表示ThreadLocal已经被gc回收，则调用 replaceStaleEntry() 方法来替换陈旧的 Entry，将新的 ThreadLocal 和值插入到数组中的索引位置 i 处，并返回。

        if (k == null) {

            replaceStaleEntry(key, value, i);

            return;

        }

    }

    // 创建一个Entry对象，加入i槽位

    tab[i] = new Entry(key, value);

    // 记录Entry对象个数

    int sz = ++size;

    // cleanSomeSlots清理陈旧的Entry，清理完后如果大于阈值，则调用rehash扩容数组

    if (!cleanSomeSlots(i, sz) && sz >= threshold)

        rehash();

}

get方法源码

public T get() {

    // 获取当前线程对象

    Thread t = Thread.currentThread();

    // 得到当前线程关联的ThreadLocalMap对象

    ThreadLocalMap map = getMap(t);

    if (map != null) {

        // 通过key获取到Entry对象

        ThreadLocalMap.Entry e = map.getEntry(this);

        // Entry不为空，则直接获取值返回结果

        if (e != null) {

            @SuppressWarnings("unchecked")

            T result = (T)e.value;

            return result;

        }

    }

    // 如果map为null，或者Entry为null，则返回一个初始化值

    return setInitialValue();

}

private T setInitialValue() {

        // 如果是在调用构造器初始化的ThreadLocal对象，该方法直接返回null

        // 如果是调用的静态方法withInitial，则返回你指定的一个初始化则

        // 并且还会把该初始化的值保存进ThreadLocalMap

        T value = initialValue();

        Thread t = Thread.currentThread();

        ThreadLocalMap map = getMap(t);

        if (map != null)

            map.set(this, value);

        else

            createMap(t, value);

        return value;

}

public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {

        // SuppliedThreadLocal是ThreadLocal的子类，重写了initialValue方法，通过传入一个Supplier，指定初始化值

        return new SuppliedThreadLocal<>(supplier);

}

private Entry getEntry(ThreadLocal<?> key) {

    // 计算当前key的落脚点

    int i = key.threadLocalHashCode & (table.length - 1);

    // 取出落脚点的Entry对象

    Entry e = table[i];

    // 如果e不为空，并且跟e关联的ThreadLocal对象等于当前的key，则返回当前e对象

    if (e != null && e.get() == key)

        return e;

    // 否则进入getEntryAfterMiss

    else

        return getEntryAfterMiss(key, i, e);

}

private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {

    Entry[] tab = table;

    int len = tab.length;

    // 如果e为null，则直接返回null，表示当前key并没有数据

    while (e != null) {

        // 取出与e关联的ThreadLocal对象

        ThreadLocal<?> k = e.get();

        // 判断k是否等于当前的ThreadLocal对象

        if (k == key)

            return e;

        // 当前k是否等于null，为null表示被gc垃圾回收，就清理旧的Entry对象

        if (k == null)

            expungeStaleEntry(i);

        else

            // 否则k不为null，取出下一个槽位，接着循环

            i = nextIndex(i, len);

        e = tab[i];

    }

    return null;

}

总结

可以看出实际保存线程局部变量的是ThreadLocalMap对象，每个线程都有一个这样的对象，保存的是键值对，键为当前的ThreadLocal对象，ThreadLocal对象一般设置为静态，非静态只会造成对象的冗余，因为ThreadLocalMap的键只能是当前ThreadLocal对象，所以只能保存一个键值对，如果要保存多个键值对，可以定义多个ThreadLocal对象作为不同的键，这样获取到的还是与线程有关联的ThreadLocalMap对象，而ThreadLocalMap的键是当前的ThreadLocal对象，多少个该对象，那就可以保存多少个值。

强软弱虚四大引用

在Java中，引用是用于引用对象的一个机制，它允许我们通过引用变量来操作和访问对象。在Java中，主要有以下几种引用类型：

0. 强引用（Strong Reference）：这是最常见的引用类型。当我们使用 new 关键字创建对象时，默认就是使用强引用。如果一个对象具有强引用，即存在一个强引用变量引用它，那么垃圾回收器就不会回收该对象。只有当对象没有任何强引用时，才会被认为是不再需要的，可以被垃圾回收。
1. 软引用（Soft Reference）：软引用用于描述还有用但非必需的对象。在内存不足时，垃圾回收器可能会选择回收软引用对象。使用软引用可以实现一些缓存功能，在内存不足时释放缓存中的对象，从而避免 OutOfMemoryError。可以使用 SoftReference 类来创建软引用。
2. 弱引用（Weak Reference）：弱引用的生命周期更短暂，只要垃圾回收器发现一个对象只有弱引用与之关联，就会立即回收该对象。弱引用通常用于实现一些特定的缓存或关联数据结构，当对象的强引用被释放后，关联的弱引用对象也会被自动清除。可以使用 WeakReference 类来创建弱引用。
3. 虚引用（Phantom Reference）：虚引用是最弱的引用类型，几乎没有实际的使用场景。虚引用的主要作用是跟踪对象被垃圾回收的状态。当垃圾回收器决定回收一个对象时，如果该对象有虚引用，将会在对象被回收之前，将虚引用加入到与之关联的引用队列中，供应用程序获取对象回收的状态信息。

在内存管理方面，软引用和弱引用都可以用于解决一些特定的内存问题，例如缓存管理或对象关联。它们对于临时性或可替代性对象的管理非常有用，可以在内存紧张时进行垃圾回收，从而提高系统的性能和可用性。然而，需要注意的是，对于软引用和弱引用对象，程序应该在使用时进行必要的判空和恢复处理，以避免 NullPointerException 和其他相关问题。

ThreadLocal为什么使用弱引用

ThreadLocal 使用弱引用的主要原因是为了避免内存泄漏问题。

当使用强引用持有 ThreadLocal 对象时，只有线程销毁或显式地调用 remove() 方法时，Entry 才会被释放。这可能导致在多线程环境下使用线程池时，即使线程已经使用结束处于空闲状态，对应的 Entry 仍然会存在于 ThreadLocalMap 中，导致无法回收相关资源，从而造成内存泄漏。

使用弱引用作为 ThreadLocal 的键（key），可以解决这个问题。弱引用在垃圾回收时只要发现只有弱引用指向，则会被直接回收。因此，当线程结束且对应的 ThreadLocal 对象只有弱引用存在时，垃圾回收器会自动清理该弱引用，进而清理 ThreadLocalMap 中对应的 Entry。这样可以避免内存泄漏问题。

需要注意的是，尽管 ThreadLocalMap 使用了弱引用来避免内存泄漏问题，但仍然需要在使用 ThreadLocal 后调用 remove() 方法，以确保及时清理 ThreadLocal 对象和对应的值。这是因为弱引用的回收时机不确定，不能完全依赖垃圾回收器的工作。

当我们应该请求进来分配一个线程处理请求，此时ThreadLocal对象就会被创建，并且是一个强引用，当第一次把值存入时ThreadLocal时，就会通过Thread拿到或者创建一个ThreadLocalMap对象，并且存入我们的数据，此时ThreadLocal作为键就会被放入弱引用中，此时就算发送垃圾回收也不会回收ThreadLocal因为有一个强引用指向，但是一旦我们的请求执行完毕返回，线程处于空闲状态时，这个强引用就没了，此时就剩下一个弱引用，这个时候发生垃圾回收就ThreadLocal就会被收回。

在 Kotlin 中，reduce() 和 fold() 是函数式编程中常用的高阶函数。它们都是对集合中的元素进行聚合操作的函数，将一个集合中的元素缩减成一个单独的值。它们的使用方式非常相似，但是返回值略有不同。下面是它们的区别：

• reduce() 函数是对集合中的所有元素进行聚合处理，并返回最后一个合并处理值。
• fold() 函数除了合并所有元素之外，还可以接受一个初始值，并将其与聚合结果一起返回。注：如果集合为空的话，只会返回初始值。

reduce示例

1、使用 reduce() 函数计算列表中所有数字的总和：

fun reduceAdd() {

        val list = listOf(1, 2, 3, 4, 5)

        val sum = list.reduce { acc, i ->

            println("acc:$acc, i:$i")

            acc + i

        }

        println("sum is $sum")  // 15

    }

执行结果：

acc:1, i:2

acc:3, i:3

acc:6, i:4

acc:10, i:5

sum is 15

2、使用 reduce() 函数计算字符串列表中所有字符串的拼接结果：

val strings = listOf("apple", "banana", "orange", "pear")

val result = strings.reduce { acc, s -> "$acc, $s" }

println(result) // apple, banana, orange, pear

执行结果：

apple, banana, orange, pear

fold示例

1、使用 fold() 函数计算列表中所有数字的总和，并在其基础上加上一个初始值：

val numbers = listOf(1, 2, 3, 4, 5)

val sum = numbers.fold(10) { acc, i -> acc + i }

println(sum) // 25

执行结果为：

acc:10, i:1

acc:11, i:2

acc:13, i:3

acc:16, i:4

acc:20, i:5

sum is 25

2、使用 fold() 函数将列表中的所有字符串连接起来，并在其基础上加上一个初始值：

val strings = listOf("apple", "banana", "orange", "pear")

val result = strings.fold("Fruits:") { acc, s -> "$acc $s" }

println(result) // Fruits: apple banana orange pear

执行结果：

Fruits: apple banana orange pear

源码解析

• reduce() 在Kotlin标准库的实现如下：

public inline fun <S, T : S> Iterable<T>.reduce(operation: (acc: S, T) -> S): S {

    val iterator = this.iterator()

    if (!iterator.hasNext()) throw UnsupportedOperationException("Empty collection can't be reduced.")

    var accumulator: S = iterator.next()

    while (iterator.hasNext()) {

        accumulator = operation(accumulator, iterator.next())

    }

    return accumulator

}

从代码中可以看出，reduce函数接收一个operation参数，它是一个lambda表达式，用于聚合计算。reduce函数首先获取集合的迭代器，并判断集合是否为空，若为空则抛出异常。然后通过迭代器对集合中的每个元素进行遍历操作，对元素进行聚合计算，将计算结果作为累加器，传递给下一个元素，直至聚合所有元素。最后返回聚合计算的结果。

• fold() 在Kotlin标准库的实现如下：

public inline fun <T, R> Iterable<T>.fold(

    initial: R,

    operation: (acc: R, T) -> R

): R {

    var accumulator: R = initial

    for (element in this) {

        accumulator = operation(accumulator, element)

    }

    return accumulator

}

从代码中可以看出，fold函数接收两个参数，initial参数是累加器的初始值，operation参数是一个lambda表达式，用于聚合计算。

fold函数首先将初始值赋值给累加器，然后对集合中的每个元素进行遍历操作，对元素进行聚合计算，将计算结果作为累加器，传递给下一个元素，直至聚合所有元素。最后返回聚合计算的结果。

总结

• reduce()适用于不需要初始值的聚合操作，fold()适用于需要初始值的聚合操作。
• reduce()操作可以直接返回聚合后的结果，而fold()操作需要通过lambda表达式的返回值来更新累加器的值。

在使用时，需要根据具体场景来选择使用哪个函数。

字符串常用的操作符

commonPrefixWith

返回两个字符串中最长的相同前缀，如果它们没有共同的前缀，则返回空字符串，可以定义 ignoreCase 为 true忽略大小写

val action = "蔡徐坤唱跳rap"

val time = "蔡徐坤两年半"

val introduce = "个人练习生蔡徐坤喜欢唱跳rap"

println(action.commonPrefixWith(time)) // 蔡徐坤

println(action.commonPrefixWith(introduce)) // ""

源码实现

// 通过while获取两个字符串同个索引下的字符是否相等

// 最后通过subSequence切割字符串

public fun CharSequence.commonPrefixWith(other: CharSequence, ignoreCase: Boolean = false): String {

    val shortestLength = minOf(this.length, other.length)



    var i = 0

    while (i < shortestLength && this[i].equals(other[i], ignoreCase = ignoreCase)) {

        i++

    }

    if (this.hasSurrogatePairAt(i - 1) || other.hasSurrogatePairAt(i - 1)) {

        i--

    }

    return subSequence(0, i).toString()

}

commonSuffixWith

返回两个字符串中最长的相同后缀，如果它们没有共同的后缀，则返回空字符串，可以定义 ignoreCase 为 true忽略大小写

val action = "蔡徐坤唱跳rap"

val time = "蔡徐坤两年半"

val introduce = "个人练习生蔡徐坤喜欢唱跳rap"

println(action.commonSuffixWith(time))

println(action.commonSuffixWith(introduce))

源码实现

// 与commonPrefixWith的实现差不多，只是commonSuffixWith是倒序循环

public fun CharSequence.commonSuffixWith(other: CharSequence, ignoreCase: Boolean = false): String {

    val thisLength = this.length

    val otherLength = other.length

    val shortestLength = minOf(thisLength, otherLength)



    var i = 0

    while (i < shortestLength && this[thisLength - i - 1].equals(other[otherLength - i - 1], ignoreCase = ignoreCase)) {

        i++

    }

    if (this.hasSurrogatePairAt(thisLength - i - 1) || other.hasSurrogatePairAt(otherLength - i - 1)) {

        i--

    }

    return subSequence(thisLength - i, thisLength).toString()

}

contains

判断字符串是否包含某字符或某字符串，可以定义 ignoreCase 为 true 忽略大小写

val introduce = "个人练习生蔡徐坤喜欢唱跳rap"

println(introduce.contains('唱')) // true

println(introduce.contains("蔡徐坤")) // true

println("蔡徐坤" in introduce) // // 同上，contains是重载操作符，可以使用该表达式

println(introduce.contains("Rap", ignoreCase = true)) // true

println("Rap" !in introduce) // !in表示不包含的意思，与!introduce.contains("Rap")是同个意思

源码实现

// 通过indexOf判断字符是否存在

public operator fun CharSequence.contains(char: Char, ignoreCase: Boolean = false): Boolean =

    indexOf(char, ignoreCase = ignoreCase) >= 0



// 通过indexOf判断字符串是否存在

public operator fun CharSequence.contains(other: CharSequence, ignoreCase: Boolean = false): Boolean =

    if (other is String)

        indexOf(other, ignoreCase = ignoreCase) >= 0

    else

        indexOf(other, 0, length, ignoreCase) >= 0

endsWith

判断字符串是否以某字符或某字符串作为后缀，可以定义 ignoreCase 为 true 忽略大小写

val introduce = "个人练习生蔡徐坤喜欢唱跳rap"

println(introduce.endsWith("蔡徐坤")) // false

println(introduce.endsWith("唱跳rap")) // true

源码实现

// 字符直接判断最末尾的字符

public fun CharSequence.endsWith(char: Char, ignoreCase: Boolean = false): Boolean =

    this.length > 0 && this[lastIndex].equals(char, ignoreCase)

// 如果都是String，返回String.endsWith，否则返回regionMatchesImpl    

public fun CharSequence.endsWith(suffix: CharSequence, ignoreCase: Boolean = false): Boolean {

    if (!ignoreCase && this is String && suffix is String)

        return this.endsWith(suffix)

    else

        return regionMatchesImpl(length - suffix.length, suffix, 0, suffix.length, ignoreCase)

}



// 不忽略大小写，返回java.lang.String.endsWith

public actual fun String.endsWith(suffix: String, ignoreCase: Boolean = false): Boolean {

    if (!ignoreCase)

        return (this as java.lang.String).endsWith(suffix)

    else

        return regionMatches(length - suffix.length, suffix, 0, suffix.length, ignoreCase = true)

}

equals

判断两个字符串的值是否相等，可以定义 ignoreCase 为 true 忽略大小写

val introduce = "蔡徐坤rap"

println(introduce.equals("蔡徐坤Rap")) // false

println(introduce == "蔡徐坤Rap") // 同上，因为equals是重载操作符，通常使用 == 表示即可

println(introduce.equals("蔡徐坤Rap", false)) // true

源码实现

// 通过java.lang.String的equals和equalsIgnoreCase判断

public actual fun String?.equals(other: String?, ignoreCase: Boolean = false): Boolean {

    if (this === null)

        return other === null

    return if (!ignoreCase)

        (this as java.lang.String).equals(other)

    else

        (this as java.lang.String).equalsIgnoreCase(other)

}

ifBlank

如果字符串都是空格，将字符串转成默认值。这个操作符非常有用

val whitespace = "    ".ifBlank { "default" }

val introduce = "蔡徐坤rap".ifBlank { "default" }

println(whitespace) // default

println(introduce) // 蔡徐坤rap

源码实现

public inline fun <C, R> C.ifBlank(defaultValue: () -> R): R where C : CharSequence, C : R =

    if (isBlank()) defaultValue() else this

ifEmpty

如果字符串都是空字符串，将字符串转成默认值。这个操作符非常有用，省去了你去判断空字符串然后再次赋值的操作

val whitespace = "    ".ifEmpty { "default" }

val empty = "".ifEmpty { "default" }

val introduce = "蔡徐坤rap".ifEmpty { "default" }

println(whitespace) // "    "

println(empty) // default

println(introduce) // 蔡徐坤rap

判断空字符串、null 和空格字符串

• isEmpty 判断空字符串
• isBlank 判断字符串都是空格
• isNotBlank 与 isBlank 相反，判断字符串不是空格
• isNotEmpty 与 isEmpty 相反，判断字符串不是空格
• isNullOrBlank 判断字符串不是 null 和 空格
• isNullOrEmpty 判断字符串不是 null 和 空字符串

lines

将字符串以换行符或者回车符进行分割，返回每一个分割的子字符串 List<String>

val article = "大家好我是练习时长两年半的个人练习生\n蔡徐坤\r喜欢唱跳rop"

println(article.lines()) // [大家好我是练习时长两年半的个人练习生, 蔡徐坤, 喜欢唱跳rop]

源码实现

// 大概就是通过Sequence去切割字符串

public fun CharSequence.lines(): List<String> = lineSequence().toList()

public fun CharSequence.lineSequence(): Sequence<String> = splitToSequence("\r\n", "\n", "\r")



public fun <T> Sequence<T>.toList(): List<T> {

    return this.toMutableList().optimizeReadOnlyList()

}

lowercase

将字符串都转换成小写

val introduce = "蔡徐坤RaP"

println(introduce.lowercase()) // 蔡徐坤rap

源码实现

// 通过java.lang.String的toLowerCase方法实现，其实很多kotlin的方法都是调用java的啦

public actual inline fun String.lowercase(): String = (this as java.lang.String).toLowerCase(Locale.ROOT)

replace

将字符串内的某一部分替换为新的值，可以定义 ignoreCase 为 true 忽略大小写

val introduce = "蔡徐坤rap"

println(introduce.replace("rap", "RAP"))

println(introduce.replace("raP", "RAP", ignoreCase = true))

源码实现

// 首先通过indexOf判断是否存在要被替换的子字符串

// do while循环添加被替换之后的字符串，因为字符串有可能是有多个地方需要替换，所有通过occurrenceIndex判断是否还有需要被替换的部分

public actual fun String.replace(oldValue: String, newValue: String, ignoreCase: Boolean = false): String {

    run {

        var occurrenceIndex: Int = indexOf(oldValue, 0, ignoreCase)

        // FAST PATH: no match

        if (occurrenceIndex < 0) return this



        val oldValueLength = oldValue.length

        val searchStep = oldValueLength.coerceAtLeast(1)

        val newLengthHint = length - oldValueLength + newValue.length

        if (newLengthHint < 0) throw OutOfMemoryError()

        val stringBuilder = StringBuilder(newLengthHint)



        var i = 0

        do {

            stringBuilder.append(this, i, occurrenceIndex).append(newValue)

            i = occurrenceIndex + oldValueLength

            if (occurrenceIndex >= length) break

            occurrenceIndex = indexOf(oldValue, occurrenceIndex + searchStep, ignoreCase)

        } while (occurrenceIndex > 0)

        return stringBuilder.append(this, i, length).toString()

    }

}

startsWith

判断字符串是否以某字符或某字符串作为前缀，可以定义 ignoreCase 为 true 忽略大小写

val introduce = "rap"

println(introduce.startsWith("Rap"))

println(introduce.startsWith("Rap", ignoreCase = true))

源码实现

// 还是调用的java.lang.String的startsWith

public actual fun String.startsWith(prefix: String, ignoreCase: Boolean = false): Boolean {

    if (!ignoreCase)

        return (this as java.lang.String).startsWith(prefix)

    else

        return regionMatches(0, prefix, 0, prefix.length, ignoreCase)

}

substringAfter

获取分割符之后的子字符串，如果不存在该分隔符默认返回原字符串，当然你可以自定义返回

例如在截取 ip:port 格式的时候，分隔符就是 :

val ipAddress = "192.168.1.1:8080"

println(ipAddress.substringAfter(":")) // 8080

println(ipAddress.substringAfter("?")) // 192.168.1.1:8080

println(ipAddress.substringAfter("?", missingDelimiterValue = "没有?这个子字符串")) // 没有?这个子字符串

源码实现

// 还是通过substring来截取字符串的

public fun String.substringAfter(delimiter: String, missingDelimiterValue: String = this): String {

    val index = indexOf(delimiter)

    return if (index == -1) missingDelimiterValue else substring(index + delimiter.length, length)

}

substringAfterLast

与 substringAfter 是同一个意思，不同的是如果一个字符串中有多个分隔符，substringAfter 是从第一个开始截取字符串，substringAfterLast 是从最后一个分隔符开始截取字符串

val network = "255.255.255.0:192.168.1.1:8080"

println(network.substringAfter(":"))  // 192.168.1.1:8080

println(network.substringAfterLast(":")) // 8080

源码实现

// 源码和substringAfter差不多，只是substringAfterLast获取的是最后一个分割符的索引

public fun String.substringAfterLast(delimiter: String, missingDelimiterValue: String = this): String {

    val index = lastIndexOf(delimiter)

    return if (index == -1) missingDelimiterValue else substring(index + delimiter.length, length)

}

substringBefore

获取分割符之前的子字符串，如果不存在该分隔符默认返回原字符串，当然你可以自定义返回，与 substringAfter 刚好相反

val ipAddress = "192.168.1.1:8080"

println(ipAddress.substringBefore(":")) // 192.168.1.1

println(ipAddress.substringBefore("?")) // 192.168.1.1:8080

println(ipAddress.substringBefore("?", missingDelimiterValue = "没有?这个子字符串")) // 没有?这个子字符串

源码实现

// 还是通过substring来截取字符串的，只是是从索引0开始截取子字符串

public fun String.substringBefore(delimiter: String, missingDelimiterValue: String = this): String {

    val index = indexOf(delimiter)

    return if (index == -1) missingDelimiterValue else substring(0, index)

}

substringBeforeLast

与 substringBefore 是同一个意思，不同的是如果一个字符串中有多个分隔符，substringBefore 是从第一个开始截取字符串，substringBeforeLast 是从最后一个分隔符开始截取字符串

val network = "255.255.255.0:192.168.1.1:8080"

println(network.substringBefore(":"))  // 255.255.255.0

println(network.substringBeforeLast(":"))  // 255.255.255.0:192.168.1.1

源码实现

// 源码和substringBefore差不多，只是substringBeforeLast获取的是最后一个分割符的索引

public fun String.substringBeforeLast(delimiter: String, missingDelimiterValue: String = this): String {

    val index = lastIndexOf(delimiter)

    return if (index == -1) missingDelimiterValue else substring(0, index)

}

trim

去掉字符串首尾的空格符，如果要去掉字符串中间的空格符请用 replace

val introduce = "  个人练习生蔡徐坤  喜欢唱跳rap  "

println(introduce.trim()) // 个人练习生蔡徐坤  喜欢唱跳rap

uppercase

将字符串都转换成大写

源码实现

// java.lang.String.toUpperCase

public actual inline fun String.uppercase(): String = (this as java.lang.String).toUpperCase(Locale.ROOT)

前言

最近想不出什么比较好的内容，但是碰到一个没毕业的小老弟问的问题，那就借机说说这个事。Intent如何传大数据？为什么是简单的说，因为这背后深入的话，有很多底层的细节包括设计思想，我也不敢说完全懂，但我知道当你用Intent传大数据报错的时候应该怎么解决，并且简单聊聊这背后所涉及到的东西。

Intent传大数据

平时可能不会发生这种问题，但比如我之前是做终端设备的，我的设备每秒都会生成一些数据，而长时间的话数据量自然大，这时当我跳到另外一个页面使用intent把数据传过去的时候，就会报错

我们调用

intent.putExtra("key", value) // value超过1M

会报错

android.os.TransactionTooLargeException: data parcel size xxx bytes

这里的xxx就是1M左右，告诉你传输的数据大小不能超过1M，有些话咱也不敢乱说，有点怕误人子弟。我这里是凭印象说的，如果有大佬看到我说错，请狠狠的纠正我。

这个错误描述是这么描述，但真的是限死1M吗，说到这个，就不得不提一样东西，Binder机制，先不要跑，这里不会详细讲Binder，只是提一嘴。

说到Binder那就会联系到mmap内存映射，你可以先简单理解成内存映射是分配一块空间给内核空间和用户空间共用，如果还是不好理解，就简单想成分配一块空间通信用，那在android中mmap分配的空间是多少呢？1M-4K。

那是不是说Intent传输的数据超过1M-4K就会报错，理论上是这样，但实际没到这个值，比如0.8M也可能会报错。所以你不能去走极限操作，比如你的数据到了1M，你觉得只要减少点数据，减到8K，应该就能过了，也许你自己测试是正常的，但是这很危险。

所以能不传大数据就不要传大数据，它的设计初衷也不是为了传大数据用的。如果真要传大数据，也不要走极限操作。

那怎么办，切莫着急，请听我慢慢讲。就这个Binder它是什么玩意，它是Android中独特的进程通信的方式，而Linux中进程通信的方式，在Android中同样也适用。进程间通信有很多方式，Binder、管道、共享内存等。为什么会有这么多种通信方式，因为每种通信方式都有自己的特点，要在不同的场合使用不同的通信方式。

为什么要提这个？因为要看懂这个问题，你需要知道Binder这种通信方式它有什么特点，它适合大量的数据传输吗？那你Binder又与我Intent何干，你抓周树人找我鲁迅干嘛～～所以这时候你就要知道Android四大组件之间是用什么方式通信的。

有点扯远了，现在可以来说说结论了，Binder没办法传大数据，我就1M不到你想怎样？当然它不止1M，只是Android在使用时限制了它只能最多用1M，内核的最大限制是4M。又有点扯远了，你不要想着怎么把限制扩大到4M，不要往这方面想。前面说了，不同的进程通信方式，有自己的特点，适用于某些特定的场景。那Binder不适用于传输大数据，我共享内存行不行？

所以就有了解决办法

bundle.putBinder()

有人可能一看觉得，这有什么不同，这在表面上看差别不大，实则内部大大的不同，bundle.putBinder()用了共享内存，所以能传大数据，那为什么这里会用共享内存，而putExtra不是呢？想搞清楚这个问题，就要看源码了。 这里就不深入去分析了，我怕劝退，不是劝退你们，是劝退我自己。有些东西是这样的，你要自己去看懂，看个大概就差不多，但是你要讲出来，那就要看得细致，而有些细节确实会劝退人。所以想了解为什么的，可以自己去看源码，不想看的，就知道这是怎么一回事就行。

那还有没有其它方式呢？当然有，你不懂共享内存，你写到本地缓存中，再从本地缓存中读取行不行？

办法有很多，如果你不知道这个问题怎么解决，你找不到你觉得可行的解决方案，甚至可以通过逻辑通过流程的方式去绕开这个问题。但是你要知道为什么会出现这样的问题，如果你没接触过进程通信，没接触过Binder，让你看一篇文章就能看懂我觉得不切实际，但是至少得知道是怎么一回事。

比如我只说bundle.putBinder()能解决这个问题，你一试，确实能解决，但是不知道为什么，你又怕会不会有其它问题。虽然这篇文章我一直在打擦边球，没有提任何的原理，但我觉得还是能大概让人知道为什么bundle.putBinder()能解决Intent传大数据，你也就能放心去用了。

反编译部分的介绍在文章末尾

排查原因

根据现象来看，这程序要嘛崩溃了，要嘛该App不适配此款盒子（比如ABI不支持、Target SDK Version等问题）

minSdkVersion系统版本不支持？

但是同事告诉我这款盒子是Android9，在其他的Android9和Android 4.4盒子上都跑过，没问题，排除了minSdkVersion的问题

ABI不支持？

不太可能，先不想这个

ADB才是王道

但凡遇到问题，只要设备能够adb，起码问题就解决了一半，但一问，说这盒子似乎不能Adb，，鹅鹅鹅饿~~ 后来借助adbhelper发现，此款盒子还是能adb，只是常规情况下adb的端口是60001，连上之后执行adb root的话，又会换回默认端口，这个情况我也是活久见。。

说正题，连上adb之后，通过抓日志，发现了如下问题：Permission denial: writing to settings requires:android.permission.WRITE_SECURE_SETTINGS,根据错误堆栈信息，大致是app调用了wifimanager.setWifiEnabled(true)这个方法引起的

解决

权限思路

因为自己对android.permission.WRITE_SECURE_SETTINGS这个权限并不太了解，所以从异常的字面意思理解，我以为是权限不够，所以我尝试让app拥有权限来确保其正常运行。

方法1：adb shell pm grant {包名} {权限内容}

执行命令，赋予该程序权限adb shell pm grant {packagename} android.permission.WRITE_SECURE_SETTINGS，执行命令之后，提示java.lang.SecurityException: Package xxxx has not requested permission android.permission.WRITE_SECURE_SETTINGS意思说该程序不需要这个权限，这个问题的原因是因为app并没有在清单文件中申明这个权限，这就有意思了，这个app操作需要这个权限却没有申请权限，可能主要原因是因为以前的低版本不需要，Android9需要吧，所以我们得先给他增加这个申明，然后再赋予这个权限。

通过apktool反编译，然后修改清单文件添加这个权限，再重新打包（后面再说具体得反编译重打包的步骤），一切妥当之后再次执行上面命令，果然老天是不会让我舒坦的，执行后出现异常：java.lang.SecurityException: Package android does not belong to 10034,触发问题的调用堆栈还是之前那个方法引起的。(⊙﹏⊙)，思考半天，看了下它的清单文件，并没有申明targetSdkVersion，这有点怪哦，也是活久见，难道游戏apk就可以这么无视规则？那我要不给他增加上，，，嗯可以一试，还是相同的配方，给清单文件增加如下代码：

<uses-sdk

    android:minSdkVersion="17"

    android:targetSdkVersion="22" />

然后重新打包，再来，没错，还是同样的味道，同样的问题，我以为修改来低于23，权限能够就自动允许了，现在想起来真是too young to simple。。

东搜搜西搜搜，想尝试下是不是因为这个程序不是系统app，后来将程序放在system/app下作为系统程序，还是同样问题，所以很显然，权限这条路行不通。

所以这个问题的解决办法应该参考如下内容：

这个错误是因为你的应用试图调用setWifiEnabled方法，这个方法在Android 9（API级别28）及以上版本已经被弃用。在这些版本中，只有系统应用才能调用setWifiEnabled方法。  

即使你的应用已经被安装为系统应用，并且已经获得了WRITE_SECURE_SETTINGS权限，它仍然不能调用setWifiEnabled方法。这是因为这个方法现在只能被系统UI调用，其他应用，包括系统应用，都不能调用这个方法。  

你可以考虑使用WifiNetworkSuggestion API来提示用户连接到特定的Wi-Fi网络，或者使用Settings.Panel.ACTION_WIFI来引导用户到Wi-Fi设置页面。  

以下是如何使用Settings.Panel.ACTION_WIFI的示例：

val intent = Intent(Settings.Panel.ACTION_WIFI)

startActivity(intent) 

这段代码会打开Wi-Fi设置页面，让用户自己开启或关闭Wi-Fi。

修改程序源代码

权限的路行不通，那我们只能想办法修复app这段逻辑代码了，但是别人的apk，显然不是那么容易让人想改就改撒，提出是这里的问题，别人也不一定信啊，所以我打算自己改这个apk的编译后的源代码，让他不要触发引起异常的那个逻辑，绕过看程序能不能正常跑起来，这一步就需要懂得起smali，还好这个问题比较简单，定位到代码改了之后，重新打包，这下消停了，程序很好正常的运行。

反编译

反编译这一块涉及很多概念，以前大概接触过，都只是看，没有实际操作，有些时候操作也只是简单的反编译看下源码，但总体工具和涉及的概念主要有ApkTool、dex2jar-2.1、jarsigner、jd-gui，还有些文章提到SignApk.jar、jax-gui等；

说下自己的理解，假如我们需要重新打包一个apk，那么我们肯定要从这个apk得到我们可以编辑的文件进行修改，修改后再重新打包，这是我们需要的核心流程；

反编译APK

ApkTool，具体的作用自己查，大致意思是如果我们想看清单文件内容，资源文件之类的，我们就可以通过这个工具进行反编译，由于前面我需要给源程序在清单文件中新增权限申明，所以我们就需要先得到反编译的工程，然后直接修改清单文件即可（把AndroidManifest拖动到Android Studio或者其他文本编辑工具中直接修改然后保存即可）

• 反编译apk ：先在终端将当前位置定位到ApkTool的目录，然后执行命令apktool d {xxx.apk:你的apk名称}，该命令会将apk反编译后保存在apktool所在目录下。也可以使用如下命令指定反编译后工程的存储路径apktool d -o {反编译后的存储目录} {xxx.apk}，其实只需要知道反编译apk是使用的apktool d即可，查一下文档了解更详细的用法。

• 重新编译：修改之后我们需要重新打包成apk，使用命令apk b {反编译后的存储目录}，编译成功之后，会保存在指定目录下的dist文件夹中。也可以用-o 指定存储的目录。

重签名

apk反编译修改了，也重新编译成了新的apk，但此时这个apk是没有签名的，直接拿到设备上安装是不行的，所以我们需要签名。 这里就需要用到jarsign,这个应该是jdk内自带的jarsigner -verbose -keystore {签名文件路径：也就是keystore、jks文件} -signedjar {签名后的apk路径} {没有签名的apk路径} {使用的签名文件别名,也就是keyalias}如果没出错，则我们就拥有了已经签名的被修改过的apk了，可以去运行验证了。但是由于我们是用的自己签名文件签名的，是不能覆盖安装原来的apk的，两者签名不一致。

使用系统签名

这块我没尝试过，需要的自行查看搜索查看，附带个链接Android应用程序签名系统的签名(SignApk.jar)_新根的博客-CSDN博客

修改源码

跟直接修改清单文件的原理差不多，都是直接修改，但是由于是smali，就需要做一定的语法了解才能改了。也有工具可以将smali转换成java的，比如使用skylot/jadx: Dex to Java decompiler (github.com)工具,不过这个方法只是将smali转换成java来查阅，如果我们想重新打包，那还是必须修改smali文件才行的。

关于这一节建议参考：Android App 逆向入門之二：修改 smali 程式碼 (cymetrics.io)

额外说的：其实上面整个过程我们没用到dex2jar-2.1、jd-gui之类的，其实作用不同，dex2jar的作用是将apk的后缀改成zip解压出来会得到很多dex文件，我们通过dex2jar可以让这些dex转换成jar文件，jar文件就是常规生成的java class文件了，但是jar文件没法直接打开查看，就需要借助jd-gui之类的工具。。所以的目的是说我们想看看别人程序的代码的时候用的吧。

就到这吧，做个记录。。

Kafka 和 RabbitMQ 都是流行的开源消息系统，它们可以在分布式系统中实现数据的可靠传输和处理。Kafka 和 RabbitMQ 有各自的优势和特点，它们适用于不同的场景和需求。本文将比较 Kafka 和 RabbitMQ 的主要区别，并分析何时使用 Kafka 而不是 RabbitMQ。

推荐博主开源的H5商城项目waynboot-mall，这是一套全部开源的微商城项目，包含一个运营后台、h5商城和后台接口。 实现了一个商城所需的首页展示、商品分类、商品详情、sku详情、商品搜索、加入购物车、结算下单、订单状态流转、商品评论等一系列功能。 技术上基于最新得Springboot3.0、jdk17，整合了Redis、RabbitMQ、ElasticSearch等常用中间件， 贴近生产环境实际经验开发而来不断完善、优化、改进中。

github地址：github.com/wayn111/way…

影响因素

1. 可扩展性：Kafka 旨在处理大容量、高吞吐量和实时数据流。它每秒能够处理数百万个事件，并且可以处理大量数据。另一方面，RabbitMQ 的设计更加灵活，可以处理广泛的用例，但可能不太适合大容量、实时数据流。
2. 耐用性：Kafka 通过将所有数据写入磁盘来提供高度的耐用性，这对于任务关键型应用程序非常重要。 RabbitMQ 还提供基于磁盘的持久性，但这可能不如 Kafka 提供的那么强大。
3. 延迟：RabbitMQ 设计为低延迟，这对于实时数据处理和分析非常重要。Kafka 延迟相比 RabbitMQ 会高一点。
4. 数据流：Kafka 使用无界的数据流，即数据持续地流入到指定的主题（topic）中，不会被删除或过期，除非达到了预设的保留期限或容量限制。RabbitMQ 使用有界的数据流，即数据被生产者（producer）创建并发送到消费者（consumer），一旦被消费或者达到了过期时间，就会从队列（queue）中删除。
5. 数据使用：Kafka 支持多个消费者同时订阅同一个主题，并且可以根据自己的进度来消费数据，不会影响其他消费者。这意味着 Kafka 可以支持多种用途和场景，比如实时分析、日志聚合、事件驱动等。RabbitMQ 的消费者从一个队列中消费数据，一旦被消费，就不会再被该队列其他消费者看到。这意味着 RabbitMQ 更适合一对一的通信或任务分发。
6. 数据顺序：Kafka 保证了同一个分区（partition）内的数据是有序的，即按照生产者发送的顺序来存储和消费。但是不同分区之间的数据是无序的，即不能保证跨分区的数据按照全局顺序来处理。 RabbitMQ 保证了同一个队列内的数据是有序的，即按照先进先出（FIFO）的原则来存储和消费。但是不同队列之间的数据是无序的，即不能保证跨队列的数据按照全局顺序来处理。
7. 数据可靠性：Kafka 通过副本（replica）机制来保证数据的可靠性，即每个主题可以有多个副本分布在不同的节点（broker）上，如果某个节点发生故障，可以自动切换到其他节点继续提供服务。 RabbitMQ 通过镜像（mirror）机制来保证数据的可靠性，即每个队列可以有多个镜像分布在不同的节点上，如果某个节点发生故障，可以自动切换到其他节点继续提供服务。
8. 数据持久性：Kafka 将数据持久化到磁盘中，并且支持数据压缩和批量传输，以提高性能和节省空间。Kafka 可以支持TB级别甚至PB级别的数据存储，并且可以快速地重放历史数据。RabbitMQ 将数据缓存在内存中，并且支持消息确认和事务机制，以提高可靠性和一致性。RabbitMQ 也可以将数据持久化到磁盘中，但是会降低性能和吞吐量。RabbitMQ 更适合处理小规模且实时性较高的数据。
9. 数据扩展性：Kafka 通过分区机制来实现水平扩展，即每个主题可以划分为多个分区，并且可以动态地增加或减少分区数量
10. 复杂性：与 RabbitMQ 相比，Apache Kafka 具有更复杂的架构，并且可能需要更多的设置和配置，因此它的复杂性也允许更高级的功能和定制。另一方面，RabbitMQ 更容易设置和使用。

应用场景

Kafka 适用场景和需求

• 跟踪高吞吐量的活动，如网站点击、应用日志、传感器数据等。
• 事件溯源，Kafka 保存着所有历史消息，可以用于事件回溯和审计。
• 流式处理，如实时分析、实时推荐、实时报警等。
• 日志聚合，如收集不同来源的日志并统一存储和分析。

RabbitMQ 适用场景和需求

• 中小项目，项目消息量小、吞吐量不高、对延时敏感。
• 遗留应用，如需要与旧系统或第三方系统进行集成或通信。
• 复杂路由，如需要根据不同的规则或条件来分发或过滤消息。
• 任务分发，如需要将任务均匀地分配给多个工作进程或消费者。

总结

在公司项目中，一般消息量都不大的情况下，博主推荐大家可以使用 RabbitMQ。消息量起来了可以考虑切换到 Kafka，但是也要根据公司内部对两种 MQ 的熟悉程度来进行选择，避免 MQ 出现问题时无法及时处理。

大家好，我是 方圆。最近在接口联调时发生了数据并发修改问题，我想把这个问题讲解一下，并把当时提出的解决方案进行实现，希望它能在大家以后在遇到同样的问题时提供一些借鉴和思考的方向。原文还是收录在我的 Github: enthusiasm 中，欢迎Star和获取原文。

1. 问题背景

问题发生在快递分拣的流程中，我尽可能将业务背景简化，让大家只关注并发问题本身。

分拣业务针对每个快递包裹都会生成一个任务，我们称它为 task。task 中有两个字段需要关注，一个是分拣中发生的 异常（exp_type），另一个是分拣任务的 状态（status）。另外，需要关注 分拣状态上报接口，通过它来记录分拣过程中的异常和状态变更。

一般情况下，分拣机在分拣异常发生时会及时调用接口上报，在分拣完成时调用接口来标记为完成状态，两次接口调用的时间间隔较长，不会发生并发问题。

但是有一种特殊的分拣机，它不会在异常发生时及时上报，而是在分拣完成时将分拣过程中发生的异常和分拣结果一起上报，那么此时分拣状态上报接口在同一时间内就会有两次调用，这时便发生了预期外的并发问题。

我们先看下分拣状态上报接口的执行流程：

1. 先查询到该分拣任务 task，默认情况下 exp_type 和 status 均为默认值0

2. 分拣异常修改 task 中的 exp_type，分拣完成修改 status 字段信息

3. 修改完成将 task 写入

数据库初始值为 1, 0, 0，分拣异常和分拣完成几乎同时上报，它们都读取到该值。分拣异常动作将 exp_type 修改为9，写入数据库，此时数据库值为 1, 9, 0；分拣完成动作将 status 修改为1，写入数据库，使得数据库最终值为 1, 0, 1，它将异常字段的值覆盖掉了。正常情况下，最终值应该为 1, 9, 1，分拣完成动作应该读取到分拣异常完成后的值 1, 9, 0 后再进行修改才对。

2. 解决方案

发生这个问题的原因很容易就能发现：两个事务同时执行 读取-修改-写入 序列，其中一个写操作在没有合并另一个写操作变更的情况下，直接覆盖了另一个写操作的结果，所以导致了数据的丢失。

这种问题是比较典型的 丢失更新 问题，可以通过对数据库读操作加锁或者改变数据库的隔离级别为可串行化使事务串行执行的方式进行避免。下面我会将大家在讨论避免丢失更新问题时提出的方案进行介绍，并尽可能的用代码来表现它们。

2.1 数据库读操作加锁和可串行化隔离级别

我们可以考虑：如果对每条Task数据修改的事务都是在当前事务完成之后才允许后续事务进行修改，使事务串行执行，那么我们就能够避免这种情况。比较直接的实现是通过显式加锁来实现，如下

select exp_type, status

from task

where id = 1

for update;

先查询该行数据的事务会获取到该行数据的 排他锁，后续针对该数据的所有读写请求都会被阻塞，直到先前事务执行完将锁释放。

这样通过加锁的方式实现了事务的串行执行。但是，在为SQL添加加锁语句时，需要确定是不是为该行数据加锁而不是锁住了整个表，如果是后者，那么可能会造成系统性能严重下降，而且还需要关注有哪些业务场景使用到了该SQL，是否存在长时间执行的只读事务使用，如果存在的话可能会出现因加锁导致延迟和系统性能下降，所以需要谨慎的评估。

此外，可串行化的数据库隔离级别也能保证事务的串行执行，不过它针对的是所有事务。一般情况下为了保证性能，我们不会采用这种方案（默认使用MySQL可重复读隔离级别）。

MySQL的InnoDB引擎实现可串行化隔离级别采用的是2PL机制：在第一阶段事务执行时获取锁，第二阶段事务执行完成释放锁。

2.2 针对业务只修改必要字段

如果异常状态请求仅修改 exp_type 字段，分拣完成仅修改 status 字段的话，那么我们可以梳理一下业务逻辑，仅将必要修改的字段写入数据库，这样就不会发生丢失更新的异常，如下代码所示：

// 处理异常状态请求，封装修改数据的对象

Task task = new Task();

tast.setId(id);

task.setExpType(expType);



// 更改数据

taskService.updateById(task);

在执行修改数据前，创建一个新的修改对象，并只为其必要修改字段赋值。但是还需要考虑的是：如果这个业务流程处理已经很复杂了，很可能不清楚该为哪些字段赋值而导致再发生新的异常，所以采用这种方法需要对业务足够熟悉，并且在修改完后进行充分的测试。

2.3 分布式锁

分布式锁的方法与方法一类似，都是通过加锁的方式来保证同时只有一个事务执行，区别是方法一的锁加在了数据库层，而分布式锁是借助Redis来实现。

这种实现方式的好处是锁的粒度小，发生锁争抢仅限于单个包裹，无需像数据库加锁一样去考虑锁的粒度和对相关业务的影响。伪代码如下所示：

// 分布式锁KEY

String distributedKey = String.format(DISTRIBUTED_KEY_PREFIX, packageNo);

try {

    // 分布式锁阻塞同一包裹号的修改

    lock(distributedKey);

    // 处理业务逻辑

    handler();

} finally {

    // 执行完解锁

    redissonDistributedLocker.unlock(distributedKey);

}

需要注意，lock() 加锁方法要保证加锁失败或发生其他异常情况不影响业务逻辑的执行，并设定好锁持有时间和等待锁的阻塞时间，此外解锁方法务必添加到 finally 代码块中保证锁的释放。

2.4 CAS

CAS是乐观的解决方案，它一般通过在数据库中增加时间戳列来记录上次数据更改的时间，当新的事务执行时，需要比对读取时该行数据的时间戳和数据库中保存的时间戳是否一致，以此来判断事务执行期间是否有其他事务修改过该行数据，只有在没有发生改变的情况下才允许更新，否则需要重试这个事务。样例SQL如下所示：

update task 

set exp_type = #{expType}, status = #{status}, ts = #{currentTs}

where id = #{id} and ts = #{readTs}

它的原理不难理解，但是实现起来可能会存在困难，因为需要考虑在执行失败后该如何重试，重试的方式和重试的次数需要根据业务去判断。

今天来跟大家讨论一下技术主管需要什么样段位的技术？

首先我要说明的一点，技术主管前提一定是技术出身。对于那些完全不懂技术，但是又身兼技术主管或者总监的同学，我这里就不再赘述，毕竟这个已经超出我目前理解力的范围。比如阿里云的王坚博士，基本上不懂技术细节，但是依然是阿里云的CTO，一手缔造了阿里云。

那我们这里再详细讨论一下，作为一名技术主管，到底应该有什么样的一个技术的段位？或者换句话来说，你的主管的技术水平需要到达什么样的一个水位？

先说结论，作为一名技术主管，一定是整个团队的技术架构师。像其他的一些大家所讨论的条件我觉得都是次要的，比如说写代码的多少，对于技术深度的钻研多少，带的团队人数多少等等，最核心的是技术主管一定要把控整个团队整个业务技术发展的骨架。

为什么说掌控团队技术架构是最重要的？因为对于一个团队来说无非就两点，第一点就是业务价值，第二点就是技术价值。

对于业务价值来说，有各种各样的同学都可以去负责业务上面的一些导向和推进，比如说产品经理，比如说运营同学。技术主管可以在一定程度上去帮助业务成功，甚至是助力业务成功，但是一定要明白技术同学一定要有自己的主轴，就是你对于整个技术的把握。因为业务上的决策说到底技术主管是只能去影响而非去决策，否则就是你们整体业务同学太过拉胯，无法形成战术合力的目的。

对于一线开发同学来说，你只要完成一个接一个的技术项目即可。但是对于技术主管来说，你就要把握整体的技术发展脉络。要清晰的明白什么样的技术架构是和当前的业务匹配的，同时又具备未来业务发展的可扩展性。

那为什么不能把整个技术架构的设计交给某一个核心的骨干研发同学呢？

所以这里就要明白，对于名技术主管来说，未必一定要深刻的钻研技术本身，一定要把技术在业务上的价值发挥到最大。所以在一定程度上来说，可以让适当的同学参与或者主导整个技术架构的设计，但是作为主管必须要了解到所谓的技术投入的产出比是什么。但是如果不对技术架构有一个彻底的理解，如何能决定ROI？

也就是在技术方案的选型里面一定要有一个平衡，能够用最小的技术投入获取到最大的技术利益，而非深究于技术本身的实习方式。如果一名技术主管不了解技术的框架或者某一些主干流程，那么就根本谈不上怎么样去评估这投入的技术产出比。一旦一名技术主管无法衡量整个技术团队的投入产出比，那就意味着整个团队的管理都是在抓虾和浑水摸鱼的状态，这时候就看你团队同学是否自觉了。

出现了这种情况下的团队，可能换一头猪在主管的位置上，业务依然运行良好。如果在业务发展好的时候，可能一直能够顺利推动，你只要坐享其成就可以了，但是一旦到了要突破困难的时期，或者在业务走下行的时候，这个时候你技术上面的优势就一点就没有了。而且在这种情况下，如果你跳槽到其他公司，作为一名技术主管，对方的公司对你的要求也是非常高的，所以这个时候你如果都说不出来你的技术价值对于业务上面的贡献是什么那想当然，你可能大概率就凉凉了。

那问题又回到了什么样的水平才能到达架构师这个话题，可以出来另一篇文章来描述，但是整体上来说，架构的本质首先一定要明白，为的就是业务的增长。

其次，架构的设计其实就是建造一个软件体系的结构，使得具备清晰度，可维护性和可扩展性。另外要想做好架构，基本的基础知识也必不可少，比如说数据库选型、分布式缓存、分库分表、幂等、分布式锁、消息架构、异步架构等等。所以本身来说做好架构师本身难度就非常大，需要长期的积累，实现厚积而薄发。如何成为一名优秀的架构师可以看我的公众号的其他文章，这里就不再详细的介绍了。

第二点是技术主管需要对于技术细节有敏感度。很多人在问一名主管到底应该具备什么样的综合能力，能不能用一种更加形象的方式来概括，我认为就有一句话就可以概括了。技术主管应该是向战略轰炸机在平常的时候一直遨游在大气的最上层能够掌控整个全局，当到了必须要战斗的时候，可以快速的补充下去，定点打击。

我参加过一次TL培训课程，讲师是阿里云智能交付技术部总经理张瑞，他说他最喜欢的一句管理概括，就是“心有猛虎，细嗅蔷薇”，也就是技术主管在平常的时候会关注于更大的宏观战略或策略，也就是注重思考全局，但是在关键的时候一定要关注和落地实际的细节。

换句更加通俗的话来说，就是管理要像战略轰炸机，平常的时候飞在万丈高空巡视，当发生了战斗的时候，立即能够实现定点轰炸。

所以如果说架构上面的设计就是对于整个团队业务和技术骨架的把握，那么对于细节的敏感度就是对于解决问题的落地能力。

那怎么样能够保证你自己有一个技术细节的敏感度？

我认为必要的代码量是需要的，也就是说对于一个主管来说，不必要写太多低代码，但一定要保证一定的代码量，让自己能够最好的，最快的，最贴近实际的理解实际的业务项目。自己写一些代码，其实好处非常多，一方面能够去巩固和加深自己对技术的理解，另外一方面也能够通过代码去更加理解业务。

当然贴近技术的方式有很多种，不一定要全部靠写代码来完成，比如说做code review的方式来完成，做技术方案的评审来完成，这都是可以的。对我来说，我就会强迫自己在每一个迭代会写上一个需求，需求会涉及到各方各面的业务点。有前端的，有后端的，也有数据库设计的。

自己亲自参与写代码或者code review，会让自己更加贴近同学，能够感知到同学的痛点，而不至于只是在空谈说教。

总结

所以对于一个技术主管来说，我认为首要的就是具备架构设计的能力，其次就是要有代码细节的敏感度，对全局和对细节都要有很强大的把控能力。

当然再总结一下，这一套理论只是适用于基础的管理者，而非高层的CTO等，毕竟不同的层级要求的能力和影响力都是不一样的。

引言

2023年，前端开发作为IT行业中备受关注的领域之一，正在经历着巨大的挑战和变革。然而，在当前行业不景气、失业率居高不下以及裁员潮席卷而来的情况下，许多人开始质疑前端开发的未来前景以及学习它是否依然有意义。本文将探讨这个问题并试图给出一些启示。

第一部分：前端的价值

前端开发作为网页和移动应用程序开发的重要组成部分，扮演着连接用户与产品的桥梁。前端技术的发展不仅推动了用户体验的提升，也对整个互联网行业产生了深远的影响。随着移动互联网的普及和技术的进步，前端在用户与产品之间的交互变得越来越重要。

对于企业而言，拥有优秀的前端开发团队意味着能够提供更好的用户体验、增强品牌形象、吸引更多用户和扩大市场份额。因此，前端开发的技能依然是企业争相追求的核心能力之一。

第二部分：行业不景气的背后

然而，正如每个行业都经历高低起伏一样，前端开发也面临着行业不景气带来的挑战。2023年，全球经济增长乏力、市场竞争激烈以及萧条的就业市场等因素，使得许多公司紧缩预算、停止招聘，并导致了失业率的上升和裁员的潮水。

在这种情况下，前端开发者需要重新审视自己的技能和市场需求。他们需要具备综合能力，包括对最新前端技术的深入了解、与其他团队成员的良好沟通合作能力以及持续学习和适应变化的能力。

第三部分：自我调整与进阶

面对市场变化和就业压力，前端开发者需要主动调整自己的发展路径。以下是一些建议：

1. 多元化技能：学习并精通多种前端框架和库，如React、Vue.js和Angular等。同时，了解后端开发和数据库知识，拥有全栈开发的能力，将会让你在就业市场上更具竞争力。
2. 学习与实践并重：不仅仅是学习新知识，还要将所学应用于实际项目中。积累项目经验，并在GitHub等平台分享你的作品，以展示自己的能力和潜力。同时，参加行业内的比赛、活动和社区，与他人交流并学习他们的经验。
3. 持续学习：前端技术发展日新月异，不断学习是必需的。关注行业的最新趋势和技术，参加培训、研讨会或在线课程，保持对新知识的敏感度和学习能力。

第四部分：面对就业市场的挑战

在面对行业不景气和裁员的情况下，重新进入就业市场变得更加具有挑战性。以下是一些建议：

1. 提升个人竞争力：通过获得认证、实习或自主开发项目等方式，提升自己在简历中的竞争力。扩展自己的专业网络，与其他开发者和雇主建立联系。
2. 寻找新兴领域：探索新兴的技术领域，如大数据、人工智能和物联网等，这些领域对前端开发者的需求逐渐增加，可能为你提供新的机会。
3. 转型或深耕细分领域：如果市场需求不断减少，可以考虑转型到与前端相关的领域，如UI设计、交互设计或用户体验设计等。或者在前端领域深耕细分领域，在特定行业或特定技术方向上寻找就业机会。

结论

 虽然当前的行业环境确实严峻，但前端开发作为连接用户与产品的重要纽带，在未来依然有着广阔的发展空间。关键在于前端开发者要不断自我调整与进阶，持续学习并适应市场需求。通过多元化技能、学习实践、提升个人竞争力以及面对市场挑战，前端开发者依然可以在这个变革时代中谋得一席之地。

前言

1、人情世故

如果做得好就会说是情商高，做不好会说是世故，这是冯仑老师一段话，然后怎么做不世故呢，也很难评判。

借着这个聊聊人情世故，在我看来它也是做事规则的一部分，我们发展很长一段历史，从不同的立场、不同的利益分出了派别，又从血缘关系分出了宗族，这些都是为了利益最大化的一个产物。

反观博主本人，典型理工男，执着技术研究，所以这块一直是弱项，不太会讲话，但是我人缘一直比较好的。当然有利也有弊，弊端的话比较明显的，当一个人说话很厉害的时候，会给人自信，给人觉得靠谱，当一个人说话不咋样的时候，其实也有好处，就是藏锋，你不说出来个人想法大家是不知道你心里的小九九的，所以保全了你自身。（当一个人份量足的时候，说话会引发很大的影响，所以你可以发现如果一个人在公开场合大发演讲，要么是初出茅庐要么就是有靠山）

2、人生的发展需要平台

王立群老师：人生发展往往需要平台，秦国李斯这么一个故事，他发现仓鼠跟厕鼠待遇很不一样，同样是一个物种，但是一个光明正大的吃着粮食，一个过街老鼠人人喊打，所以他悟到了一个道理，人生好的发展需要借助平台的。

我们今天讲的人物：曹操，我们还是从几个学习角度去看，一个是做事的方法，另一个我们从他的事迹里面看出成事的借力的这么一回事。

曹操

出身

他祖父是一个大太监，伺候皇后还有皇上，古代有三股力量，两股都是因为比较亲近产生的，一个是外戚，另一个太监，还有一股力量是文官，这个是人数最多的。那么他祖父权利很大的，然后收了一个义子也就是曹操的父亲，然后他本身属于夏侯家族，所以他带的资源是曹家还有夏侯家非常有实力。

他并没有说直接躺平，而是想着有所作为，接下来我们再看看他的做事方面

做事手段

1、许劭风评

古代有个一个规则，靠着这些有能力、有品德的人来进行推荐人才，曹操想出来做事，他找到许劭，一开始是不肯的，因为前面讲过三股力量，文官是很鄙视太监的，后面曹操使了点手段最终让许劭给他做了风评，然后他听完大笑而去。

idea：从这件事看做什么事都是有个窍门，这个方式是别人建议曹操这么干，所以做事要恰到好处。另外里面提到曹操使了点手段，哈哈透出了一个狠，有点东西。

2、傍大腿

曹操曾经在袁绍下面干活，然后好几次都把自己的精锐干没了，袁绍作为盟主，慷慨的给予兵马才得以恢复元气。

idea：我们看曹操的出身，这么牛逼的背景，他也需要大腿的支持，更何况普普通通的我们。

3、挟天子以令诸侯

这个是非常著名的历史典故，也是因为这个跟袁绍闹掰了，当汉献帝去了洛阳的时候，他马上去迎接，然后用这个发号施令讨伐别人。

idea：曹操的眼光十分毒辣，他看出潜在的价值，不愧是曹老板。

4、善用人才

像官渡之战，像迎接汉献帝，都是底下这批谋士给的主意，曹操手下文官是人才济济的，另外这个老板是善于听从这些好的计谋，这是非常重要的。

官渡之战，袁绍没有听从谋士的重兵把守粮草，导致给了曹操抓住了机会，乌巢一把火烧光了粮草。

个人看法

a、平台是重要的，借力也是需要的

从曹操的发迹来看，他站在一个大平台上面，不像刘备四处投奔。人并不是说能力很强就能表现出来，需要有平台，有这么伯乐去发现你，然后有这么一股力量在你困难的时候拉你一把，这是重要的。

b、曹操做事狠

这里的狠，不是残暴，而是毒辣，眼光毒辣、做事方式到位，我们从善用人才，许劭风评，挟天子以令诸侯，这些做的都很到位。举个例子，比如说我们要煮开一壶水，需要火柴、木头、可能需要鼓风工具，这都是关键那些点。

这个我们前面也提到了，做事一定要有所研究，事情的关键点是什么，当然有这么一群得力助手也很重要，发现关键突破点。所以古代对英雄标准是：腹有良策，有大气概。

c、驾驭人

司马家起来是在曹操去世后几代的事情，可以说在曹操在的时候，这些有心机的人没有动作的，侧面看出曹操的厉害之处，懂人心。在资治通鉴里面也有一个例子，就是桓温，他也是古代一个权臣，后面几代就不行了压不住这批人。

学历史，学读懂人心

历史里面基本都是那个朝代的精英，他们的事迹，做事方法，当然我们看到很多东西，包括抱负、无奈、遗憾；我们学的不仅仅是做事方法，避开权谋的陷阱，还有就是学习读懂人心、人性。当我们谈到这个，大家第一印象就是坏的人性，其实它是一种自然的表现，就像饿了就要吃饭。

《百家讲坛》里面讲了这么一个故事，曹操的下邳之战生擒了吕布，原本曹操很爱惜人才的，后面刘备的一句话：吕布对以往老板不好，而曹操生性多疑，最终嘎了吕布。王立群老师：人们往往看重结果，以结果说话，而不是问你这么做的原因。

是啊，我们在故事背后，看到整件事情人心的博弈，刘备被人称为仁义之君，但是他在那会落进下石了，因为他之前跟吕布有些矛盾的，吕布把他从原来的根据地赶走了，当然他说的也是事实。所以我们除了学习历史，还需要去洞察人心，往往这些能决定事情的走向。

我从4月开始离职开始全职做独立开发，算是真正踏进入了这条河流。在过去半年多了我也观察了很多独立开发者。自己目前算是过了新手村（有正常的开发节奏，有3万用户）。看到很多刚起步的独立开发者还是有很多疑问，所以分享一下我在独立开发最初期的一些经验。因为我也不是很成功（没有走的很远），所以只能分享独立开发前100天的经验。

先说一下我认为独立开发起步阶段面临的主要困难：

第一：没有公司的孤独感。如果是一个人全职开发就更寂寞了。即使有一两个合作伙伴，但是大概率也是异地，因此也算是网友性质的社交。人说到底是群居的，所以需要找到一种社交平衡。我想可能这也是很多独立开发白天要在外面地方待着的原因，也许一个人一直在家待着有点闷。

第二：无法建立产品的健康开发节奏。以前在公司的时候自己是流程里的一环，只关心自己分工的完成情况。做了独立开发以后，所有事情都需要自己决策。太多自由的结果就是没了方向。什么都想做，好像什么都可以做，又感觉什么都不好做。

第三：没有收入。产品从开始建造到有足够健康收入中间有一段过程。这还有一个前提要是一个真正有用户价值的产品。如果你起步的时候自己没有一个优势产品方向，又没有个人社区号召力，就算你的产品是好的，也需要一段时间（可长可短）才能获得有效收入。一上线就火的概率太小了。高强度投入一件事情，如果长期没有收入，家人会有很多质疑，可能最后自己也很怀疑自己。

我把这三点结合起来，编一个故事大家可能比较有画面了：

一个人做独立开发已经半年多了，产品设计都是自己做，也没有什么人可以讨论，不知道下一步该做什么。目前每天只有零星的新增。做了这么久，总共只有两三千的收入。看来做产品还得会营销**，打算最近开始学习一下运营**。最近也打算做一下AI产品，感觉这个赛道很火。老婆说如果不行就早点回去上班好了，总不能一直这样。家人们，你们说我应该坚持吗。

家人们会说你的产品很棒，会说你做的比他们强，会说下次一定，会说你未来会成功。但是家人们不会为你掏一分钱。

也许我们不知道如何成功，但是我们可以知道什么是失败。你知道的失败方式越多，你成功的概率就越大。总的来说，产品的成功就两个要点：有用户价值，能赚钱。注意，这两点是或的关系，不是且的关系。一个产品可以能赚钱，但是没有用。一个产品也可以有用，但是不赚钱。失败就是你做的产品：既没用，又不赚钱。

基于前面提到的三个困难，我得出的前100天最重要的事是：找到一个可行的产品迭代方向。和团队经过磨合，互相能有有效、信任的协作。找到一百个种子用户。你越早解决这三个困难，你越快走上轨道。

确认产品方向

如果你真的做过产品，你就知道最终正确的产品路径不是通过脑中的某刻灵光乍现得到的。所以不是那种大脑飞速运算解题的方式。这里有两件事情需要确认：大的产品方向，产品的路径。

比如阿里巴巴，马云不是一开始就做的淘宝网。他只是觉得互联网普及以后，电子商务会有需求。最开始做的是黄页，并不是淘宝网。但是他没有在第一个项目失败以后，去做门户网站。产品路径的例子是特斯拉。特斯拉很早就确定了先出高性能的跑车，高性能轿车（model s），有了前面的技术积累以后，最后通过推出平价的轿车赢得市场（model 3）。特斯拉在 model 3 大规模量产前都是亏损的。

所以最重要的是确认产品方向。这个方向要结合自身的情况进行设定，就是我在前面帖子里提到的要是你想做的，能做的。也许想达到的产品方向有很多工作量，这个时候就要有同步的产品路径。比如小米手机的创业，他们一开始就想造手机。但是直接启动手机的制造市场、技术都有很大的困难。于是他们先通过做 MIUI 入局。

这里面首先要有个大的方向判断，对于独立开发来说，我觉得张宁在《创作者》里提到的两个维度的方向挺有意思：大众、小众；高频、低频。这里面两两结合各有什么特点我这里就不展开了，大家可以自行体会。

但是可以明确的是，独立开发者做不了又大众又高频的应用。大众又高频，就不可能小而美。大众又高频，最后赢家除了产品能力，要有运营优势，要有资源优势。独立开发者通常没有运营优势和资源优势。另外一点，如果是小众低频，就一定要高忠诚，高付费转化。可以往大众低频或者小众高频的方向多想想。

产品方向选择还有一个建议就是要有秘密。成功的业务后面一定有秘密。秘密也回答了一个问题：如果这个需求真的存在，为什么用户选择了你的产品。

最初级的秘密就是信息差，你知道别人不知道，所以你可以，更早做，可以更低的成本，更高效，有更高的获客率。

更高级的秘密就是大家都能看到，但是大家知道了，但是大家不信（脑中想到了拼多多的砍一刀）。

最高级的秘密就是所有人都知道，但是他们做不到。

总结起来，你应该找到一个你有优势的细分方向。信息优势，洞察优势也是优势。

没有一发即中的银弹，最平凡的方式想很多方向，用最低成本进行最快速的验证。在反馈中渐渐明晰产品路径。如果你三个月不管反馈闷头做，只做出了一个产品方向。你失败的概率是很大的。所以我看到很多产品1.0 的时候就做会员，做社区，做跨平台我是很不理解的。其实这些功能在早期性价比很低。

我的方式是脑海中有10个想法，挑出3个想法做初步设计，选出一个或者两个想法做产品验证。可能是原型，数据是模拟的，没有设计，如果产品真的解决了痛点的话，用户会愿意用，然后他会给你反馈他想要更好的体验，他愿意付钱得到这些改进。这里的效率优势是，你能在更短的时间验证产品方向是不是对的。总比走了3个月才发现是一条死胡同要好。

开发者很容易因为想到一个想法很兴奋，觉得这个很有用，就闷头做了一个月。有可能的问题是，这个想法虽然是个痛点，但是这个痛点频次很低，场景很少，所以虽然有用，但是没人会愿意买单。所以尽量跳出自己的思维，从用户的角度来进行验证是很必要的。

团队协作

独立开发的开发方式和传统公司不同。需要建立一个全新的工作流程。在初期大家都是空白，所以需要通过产品迭代中，形成高效的开发默契。大家松散做东西，工作习惯，工作职责都需要有共识才行。

比如我合作的设计师早期喜欢一次做一大板块的整体设计，大概一周的工作量。初期我觉得我们对产品有激情，大家都应该有自由的发挥空间。但是做了一周的设计图和产品脑海中的产品行进方向不一致怎么办。在工作时间上，我合作的设计师因为目前还是兼职，他只能在下班后设计。然而我全职只在6点前工作。这又是一个要协调的地方。

如果你是一个产品，需要协调研发和设计，三个人协调就又更复杂了。要找到一个大家都舒服，高效的协作方式。

100个种子用户

独立开发最核心的一环就是找到一个健康的商业模式。产品方向和团队协作的目标都是为了未来可以达成一个健康的商业模式。我觉得太多独立开发者上来就把目标（野心）定的太高。一口吃不成胖子。独立开发早期的商业目标只有一个：尽快达成团队最低维持标准。一鸟在手胜过二鸟在林。不要在团队只有几个人的时候用几十个人的方式管理。

初期就要估算出产品（团队）能够持续运转的最低收入。这个成本越低，团队就越容易跑起来。当收入足够覆盖团队的成本后，你的心态就会得到极大的自由，可以尝试很多奇奇怪怪有趣的想法。所以早期不要想有多高的天花板，如何建立壁垒，就关心如何达成产品的及格生命线。谁会想做一个注定失败的产品呢。

早期在没有运营优势的情况下，最重要的指标就是用户满意度了。用户满意度，就暗示了这个产品有没有解决切实的用户问题，用户愿不愿意为你宣传。其实很多人都搞错了重点，在产品没有让100个种子用户满意前，新增的流量是没有意义的。因为再多的用户都会流失。竹篮打水一场空。如果你把产品的用户目标定在100个种子用户，你也就没了运营压力，可以关注在如何打造正确的产品上。在产品基本盘没有问题后，再思考后面的才有意义。

总结

总结起来三点就是：做什么（产品方向），怎么做（团队协作），为谁做（验证用户）。以上就是我全职独立开发3个多月以来肤浅的经验分享，希望对你有帮助。

你是否曾经有过类似的疑惑？

• 我尝试过好几次健身，但都坚持不下来，我是不是一个没有耐心，没有毅力的人？
• 领导反馈说我需要提升沟通能力(开发效率、主动性)，可是我要怎么提升呢？
• 我知道该怎么做，但就是做不到呀。

在我们的个人成长中，出现这些疑惑是很正常的，它们可以归纳为以下两个原因：

• 不知道方法
• 知道方法但不知道该怎样坚持

如果你经常被这两个问题困扰，长此以往，就会陷入自我怀疑的状态。这时，MORS 法则可以帮到你。

MORS 法则，又叫做具体性原则。MORS 法则认为，我们的行为只有符合Measured（可测评）、Observable（可观察）、Reliable（可信赖）、Specific（明确化） 这 4 个要素，才是一个具体的、可执行的行为。

针对上面说到的问题，我们不要光喊口号，而需要给出具体的、可执行的方案，然后行动起来！

也就是说，当你碰到一个很复杂的目标时，要尽量拆解目标，制定一系列符合 MORS 法则的行动计划，然后开始行动，这样就能达成目标。

让我用一个栗子来解释 MORS 法则，假想一下，你今年给自己立了一个 flag：“今年要跑半马(21公里)”。要是只有这样一个目标，你能做到吗？大概率是不能的，即使你知道要每天坚持跑步，也很难坚持下来。你有可能会被临时的一些事情耽搁了几天就放弃了；你有可能在坚持了一段时间之后发现自己“根本做不到”就放弃了。

想要达成这个大目标，你可以尝试先拆解目标。假设第一次开始跑步，你可以跑 1 公里，希望 10 个月后能跑 21 公里，那就是每个月要多跑 2 公里；然后再拆到每周要多跑 0.5 公里；然后再拆解到每 2 天多跑 0.07 公里左右。这样分拆之后，就可以罗列出每天的跑步行动计划，比如：xx月xx日，跑 1.14 公里；xx月xx+1日，跑 1.21 公里... 这些行动是符合 MORS 法则的：

• Measured：这些行动是可以被测量和评估的，你可以明确知道今天计划跑多少公里，最终有没有完成这个行动也可以很清楚地衡量和评估。
• Observable：这些行动是可见的，你要跑起来，可能需要一些跑步装备和资源（比如准备水），这些都是实实在在的行动，不是 YY。
• Reliable：这些行动是可以完成的，它不会太难，每天多跑 0.07 公里远远比多跑 20 公里要简单太多了，肯定能做到吧？
• Specific：这些行动是非常明确的，就是跑步，不会有什么歧义。

当然，肯定有更好的、更加符合运动理论的跑步计划，比如是不是每天跑，还是一周休息 2 天、是应该每天突破，还是隔一天突破等等。这里只是举例，就简单一点了。不过不管是什么跑步计划，原理是不变的。

当你制定了符合 MORS 法则的行动计划之后，就能够更加容易地达成目标，也更加容易坚持下来了。因为：

• 行动计划是具体的，明确的，可行的。相比原来的假大空的目标，它更容易做到！而且，按照这个行动计划来行动，就能达成目标。
• 能够不断地感受到成果，这会帮助你更容易坚持下来。在这个栗子中，就是每天都多跑了一些，感受到自己每天都在进步，这是强大的正反馈，会给予你力量。

注意不要跟 SMART 原则搞混了哈。SMART 原则是制定目标时使用的，MORS 法则是制定行动计划的时候使用的。它们有一些相同的点，比如 Measured 和 Specific，那是因为每一个行动本身也是带有目的性的，所以 MORS 法则和 SMART 原则会有重叠的地方。

好了，MORS 法则的介绍就到这里了，它的内容非常简单，但是 MORS 法则对于我们的个人成长来说，作用是非常大的，希望你们可以多加实践啦。

除了在个人成长上面有帮助之外，MORS 法则对于管理者指导下属也非常有用，后面有机会我再介绍吧。

加油，让我们从行动开始！

1. passive event listeners

passive event listeners 是一种新兴的web标准，Chrome 51中提供的新功能为滚动性能提供了巨大的潜在提升。Chrome Release Notes.

背景：所有的现代浏览器都有一个滚动功能的线程，可以保证即使在运行耗时的js代码时滚动也能够平滑进行，但这种优化部分因需要等待任何touchstart 和 touchmove处理程序的结果而失败，因为这些交互可能会通过调用preventDefault() 事件来完全阻止滚动。

于是有了 {passive: true}

通过将touch或wheel事件监听标记为 passive，开发人员承诺处理程序不会调用 preventDefault来禁用滚动。这使浏览器可以立即响应滚动，而无需等待js的执行，从而确保为用户提供可靠流畅的滚动体验。

2. 关于系统设计

   • 关于分层

分层一般是基于模块功能来分层，有时候分层不清晰可能是有哪些模块，各模块间的功能，整个功能流程不是很清楚。

有时候两个模块间的交互复杂度增加，可以考虑构建一个中间层。 这样可以保持两个模块不会杂糅相关度不是很高的处理逻辑，功能逻辑更纯粹，保持边界清晰，降低模块本身的复杂度。

3. 关于编程思维

仔细想来，虽然从事开发工作很久了，但是编程上还是很没有章法，架构设计能力较弱，多年来都是凭借以前热血和几分小聪明存活。

今日份反思：

拿到一个需求，分析该需求需要支持那些场景，为了支持这些场景它需要具备哪些功能，思考怎样实现这些功能，根据功能做模块划分，对这些模块进行分析，做逻辑抽象（也就是分层），然后整个需求实现的大致框架就心中有数了，开始产出技术方案。 技术方案产出后，按照技术方案的设想去实施，实施过程中可能会遇到没考虑到的场景，或者发现之前的设计不能很好的cover，调整设计，增加分层或者调整已有的分层，然后修改技术方案。 不断的经历上述过程，会慢慢的沉淀出一些业务通用的设计思路，这样下次再做技术方案的时候就不会很迷茫。脑子理清楚，而后出设计，实践后总结。

4. ShadowRealm API

一个进入 statge3 的新的 JavaScript 提案,用于创建一个独立的JavaScript运行环境，里面有独立的变量作用域。

数据结构：

declare class ShadowRealm {

  constructor();

  // 同步执行字符串，类似eval()

  evaluate(sourceText: string): PrimitiveValueOrCallable;

  // 返回一个Promise对象，异步执行代码字符串

  importValue(specifier: string, bindingName: string): Promise<PrimitiveValueOrCallable>;

}

使用场景：

• 在Web IDE 或 Web绘图应用程序中运行插件等第三方代码； 这种方式比iframe的实现更简单、灵活度更高，占用内存更少、代码的安全性更高。
• 用 ShadowRealms 中创建编程环境，运行用户代码，如codepen，codesandbox；
• 服务器可以在 ShadowRealms 运行第三方代码，防止第三方代码出错打挂主环境；
• 网页抓取和网页应用测试可以在ShadowRealms中运行；

补充：Node.js的vm模块与ShadowRealm API类似，但具有更多功能，缓存Javascript 引擎，拦截import() 等等。

5. 关于状态管理

做状态管理的核心就是监听数据的变化，监听数据的变化有两种方式：

• 提供api来修改，内部做联动处理（React的setState）
• 对对象做一层代理，set的时候做联动处理，同时get时收集所有依赖。（vue，mobx的响应式数据）

6. 需求/调研

关于需求调研，我还是很急躁，急急忙忙开始技术方案评审、开发、排期的话，就会导致整个开发过程很被动。

比较好的方式，前期对于自己做的需求，以及需求的各个功能依赖有比较充分的了解（不过这在很多功能依赖方都没有文档的情况下很难做到），然后写一个符合需求的简版的demo，对可能出现的阻塞点和解决方案心里有一个预期，把图纸画好，照着图纸开发，从而更好的掌控整个开发进度。

7. 功能/需求拆解

对功能需求的有效拆解，功能模块详细具体，粒度合适，不会太过细化，也不会忽略一些关键点，才能够更好的把控整个开发进度，评估可能出现的风险点。

8. 工具方法收敛思路

收敛-内部集中分发给各个具体的util处理，保证对外暴露的接口的统一，降低该方法使用的心智负担。

9. 关于「自顶向下」和「自底向上」

自顶向下：

程序设计时，先考虑整体，后考虑细节。先考虑全局目标，后考虑局部目标。不要一开始就过多追求总多的细节，先从最上层总目标开始设计，逐步使问题具体化。

模块化设计：一个复杂的问题，肯定是有若干稍简单的问题构成。模块化是把程序要解决的总目标拆解为子目标，再进一步细化分解为具体的小目标，把每一个小目标称为一个模块。

自底向上：

自底向上的设计简单来说就是先完成细节功能，每个细节功能抽象成一个运算符，然后将这些完成的细节功能组装到整体的架构中。

自动化的设计是不是就应该采用自底向上的设计思路，把每个需要的细节功能做抽象，使得配置规则的人可以任意组装，对于不支持的功能制造新的抽象？

10. eval 和 new Function的区别

eval 和 new Function都可以解析执行一段传入的字符串。但有以下不同的地方：

• eval中的代码是当前作用域，它可以访问当前函数中的局部变量和全局变量。new Function中的代码执行的作用域是全局作用域，不论它在哪个地方被调用，可访问的都是全局变量；
• eval接收函数作为字符串时需要“（”和“）”作为前缀和后缀，new Function不需要，new Function可以接收N个参数，最后一个参数作为函数体；
• eval不容易调试，用chromeDev等调试工具无法打断点调试；
• 性能问题，eval通常比其他替代方法更慢，因为他必须调用js解释器，而其他结构则可被现代js引擎优化；
• eval存在安全问题，因为可访问局部作用域的变量，其内部逻辑不可预测性很强，可能导致XSS攻击；

11. 乐观更新与保守更新

• 乐观更新（Optimistic Update）： 乐观更新：如果有编辑等改动，先更新前端页面，再像服务端发送请求，如果请求成功则结束操作，无需额外处理，若请求失败，则页面回滚到先前状态； 这样更新方式的优点是响应及时，缺点就是低概率的请求失败回滚的体验不太好。
• 保守更新（Perssimistic Update）： 保守更新：如果有编辑等改动，向服务端发送请求，等收到回复请求后再响应用户操作，在此之前用户都需要处于等待状态。 这样做的缺点是会使页面有比较大的延时感，优点是最终呈现的结果是可信赖、稳定可靠的。

12. 正交的概念

编程上的正交，从数学上引进这个词，用于表示相互独立，相互间不可替代，并且可以组合起来实现其他功能。比如if和for语言是正交的，但for和while与句的功能是有重叠的。逻辑运算not、and也是正交的，其他复杂的逻辑运算都可以用这三种基本运算叠加起来。 编程语言经常定义一组正交语法特性，相互间不可替代，组合起来可以实现其他功能。为了更方便使用，在基础特性之上，再添加一些额外特性。这些非基本的额外特性，成为语法糖。语法糖对语言的功能没有太大影响，只是有了，代码写起来更方便些。

13. 引入外部字体，因等待字体文件的加载而产生文字不可见问题的一些解决方案

• 临时显示系统字体：添加font-display: swap;到自定义字体的style中，在自定义字体加载好之前显示系统字体；
• 预加载网页字体：用<link rel="preload" as="font" >更早的获取字体文件。

14. 总结写技术文章的几个步骤，引导自己学习并践行：

• 学习优秀的人写的东西，看看他们的理解；
• 带着自己的疑问，和目前接收到的理解去读源码；
• 读完之后，按照自己最终的理解绘制相关逻辑的流程图；
• 针对关键功能模块做拆解和源码解读；
• 总结相关功能的实现机制，以及给我带来的启发和思考；

15. 关于团队中被高频讨论的去底座；

去底座不是完全失去对底座（数据）的访问能力，而是设计一个标准化的API来支持按需访问底座（数据）的能力。

前言

本文仅简单描述一下kotlin中常用到的scope function，如apply,let,run,with,also等函数的常用方法和选取。即使很多情况下选择不同函数，也同样都能达到最终效果，具体选择哪个函数我们不会严格约束，但如果你是对代码规范要求比较高的，最好建立良好的代码习惯。

一般对比

1. apply 函数接收一个 lambda 表达式作为参数，并返回被调用对象本身。通过 apply，可以在对象创建后立即对其进行链式操作，设置属性值、调用方法等。适合用于链式初始化或配置一些属性。

val person = Person().apply { 

        name = "John" 

        age = 30 

    }

2. also 函数接收一个 lambda 表达式作为参数，lambda 表达式中的 it 引用指向调用 also 的对象。通过 also，可以对对象进行额外的操作，而原对象仍然是函数调用的结果。适合用于在对象操作过程中执行额外的副作用操作。

val modifiedObject = myObject.also {

    // 额外操作 it

}

3. let 函数接收一个 lambda 表达式作为参数，lambda 表达式中的 it 引用指向调用 let 的对象。如果对象不为空，则执行 lambda 表达式内的操作，并返回 lambda 表达式的结果。适合用于安全地操作对象，避免空指针异常。

val result = nullableValue?.let {

    // 操作非空对象 it

}

4. run 函数接收一个 lambda 表达式作为参数，lambda 表达式中的 this 引用指向调用 run 的对象。通过 run，可以便捷地对对象进行多次操作，并返回最后一个表达式的结果。适合用于执行一系列操作并返回最终结果。

val result = myObject.run {

    // 对象操作1

    // 对象操作2

    // ...

    // 返回结果

}

5. with 函数接收一个对象和一个 lambda 表达式作为参数，lambda 表达式中的 this 引用指向传入的对象。通过 with，可以在没有对象接收者的情况下操作对象，并返回最后一个表达式的结果。适合用于对对象进行一系列操作，而无需在乎返回值。

val result = with(myObject) {

    // 对象操作1

    // 对象操作2

    // ...

    // 返回结果

}

小明的故事

故事是这样的

1. 小明今年上一年级
2. 但是家长跟学校说，小明是个天才，现在可以直接跳级到二年级
3. 学校给二年级分配的老师是王老师，是个女教师
4. 半学期后，王老师怀孕了需要休息，于是学校给王老师放假
5. 学校给二年级分配了新的李老师,小明有了新老师

下面是故事的代码：

data class Student(var name: String = "", var grade: String = "", var teacher: Teacher? = null) {

    //插班跳级

    fun needSkippingGrade(insertGrade: String) {

        this.grade = insertGrade

    }

}



data class Teacher(var name: String = "") {

    fun relax() {

        println("$name 休假了！")

    }

}



fun main() {



    //1. **小明**今年上一年级

    val xiaoming = Student()

        .apply {

            name = "小明"

            grade = "一年级"

            println("小明开始前: $this")

        }

        .also {

            //2.现在可以直接跳级到二年级

            it.needSkippingGrade("二年级")

            println("小明插班后: $it")

        }



    //3. 学校给二年级分配的老师是**王老师**，是个女教师

    val ownTeacher = xiaoming.teacher?.let {

        println("小明当前的老师不为NULL,是${it}")

    } ?: Teacher("王老师").also {

        xiaoming.teacher = it

        println("小明有了老师: $xiaoming")

    }

    

    fun changeStudentCurrentTeacher(student: Student): Teacher? {

        return student.run {

            teacher?.relax()

            Teacher("李老师")

        }

    }



    //4. 半学期后，王老师怀孕了需要休息，于是学校给王老师放假

    //5. 学校给二年级分配了新的**李老师**,小明有了新老师

    with(xiaoming) {

        println("开学了！")

        println("半学期后，王老师怀孕了！...")

        val newTeacher = changeStudentCurrentTeacher(this)

        println("新老师是$newTeacher")

        teacher = newTeacher

        println("小明有了新老师$this")

    }



}

输出结果：

小明开始前: Student(name=小明, grade=一年级, teacher=null)

小明插班后: Student(name=小明, grade=二年级, teacher=null)

小明有了老师: Student(name=小明, grade=二年级, teacher=Teacher(name=王老师))

开学了！

半学期后，王老师怀孕了！...

王老师 休假了！

新老师是Teacher(name=李老师)

小明有了新老师Student(name=小明, grade=二年级, teacher=Teacher(name=李老师))

最后

实际过程中，需要根据具体的场景和需求来选择适合的函数。前面这些函数在 Kotlin 中提供了更简洁、可读性更高的方式来处理对象，根据不同的使用场景，你可以选择最适合和更易读的函数来操作对象

什么是广播，简单点广播就是安卓系统本身发出的声音，我们可以通过安卓提供给我们的一系列内容来接收和发出广播，以此来简单快捷地实现一些功能。

在实际开发中也常常用到，而是否熟悉使用，这成为面试官最常问的问题。

当面试官问你：

1.请问BroadcastReciver的静态注册与动态注册的区别？，你在开发中用过吗？

答：

其实广播分为两种基本类型：

在一个程序中，可以发送广播供当前程序的广播接收器收到。首先我们来看下两种方式的发送广播。 在Android系统中，主要有两种基本的广播类型： - 标准广播（Normal Broadcasts） - 有序广播（Ordered Broadcasts）

标准广播：

是一种完全异步执行的广播，在广播发出之后，所有的广播接收器会在同一时刻接收到这条广播，广播无法被中断。

发送广播的方式十分容易的，只需要实例化一个Intent对象，然后调用context的** sendBroadcast() **方法。这样就完成了广播的发送。

        //intent中的参数为action

        Intent intent=new Intent("com.example.dimple.BROADCAST_TEST");

        sendBroadcast(intent);

有序广播：

是一种同步执行的广播，在广播发出之后，优先级高的广播接收器会先接收到这条广播，并可以在优先级较低的广播接收器之前终止发送这条广播。

        //intent中的参数为action

        Intent intent=new Intent("com.example.dimple.BROADCAST_TEST");

        sendOrderBroadcast(intent，null);//第二个参数是与权限相关的字符串。

到此时，如果你的程序中只有一个广播接收器的话，是体现不出有序广播的特点的， 右击包名——New——Other——BroadcastReceiver多创建几个广播接收器。

此时你还是会发现，所有的广播接收器是同时接收到广播消息的。注意上面介绍的时候说到优先级，这个时候我们需要设置优先级，在AndroidManifest文件中的Receiver标签中设置广播接收器的优先级。

        <receiver

            android:name=".MyReceiver"

            android:enabled="true"

            android:exported="true">

            <!--注意此时有一个Priority属性-->

            <intent-filter android:priority="100">

                <action android:name="android.intent.action.BROADCAST_TEST"></action>

            </intent-filter>

        </receiver>

优先级越高的广播接收器优先收到广播，也可以在收到广播的时候调用abortBroadcast() 方法截断广播。优先级低的广播接收器就无法接收到广播了。

面试官，假设我有一个接收者如下：

在Android的广播接收机制中，如果接收到广播，就需要创建广播接收器。而创建广播接收器的方法就是新建一个类（可以是单独新建类，也可以是内部类（public）） 继承自BroadcastReceiver

   class myBroadcastReceiver extends BroadcastReceiver{



        @Override

        public void onReceive(Context context, Intent intent) {

            //接收到广播的处理，注意不能有耗时操作，当此方法长时间未结束，会报错。

            //同时，广播接收器中不能开线程。

        }

    } 

面试官，接下来就是面临注册的问题了，有两种注册方式，一种是动态注册，一种是静态注册。

所谓动态注册是指在代码中注册。步骤如下 ：

• 实例化自定义的广播接收器。
• 创建IntentFilter实例。
• 调用IntentFilter实例的addAction()方法添加监听的广播类型。
• 最后调用Context的registerReceiver(BroadcastReceiver,IntentFilter)动态的注册广播。

这个时候，已经为我们自定义的广播接收器关联了广播，当收到和绑定的广播一直的广播的时候，就会调用广播接收器中的onReceiver方法。

        MyBroadcastReceiver myBroadcastReceiver=new MyBroadcastReceiver();

        IntentFilter intentFilter=new IntentFilter();

        intentFilter.addAction("com.example.dimple.MY_BROADCAST");

        registerReceiver(myBroadcastReceiver,intentFilter);

这里需要注意的是，如果需要接收系统的广播（比如电量变化，网络变化等等），别忘记在AndroidManifest配置文件中加上权限。另外，动态注册的广播在活动结束的时候需要取消注册：

    @Override

    protected void onDestroy() {

        super.onDestroy();

        unregisterReceiver(myBroadcastReceiver);

    }  

静态注册：

在创建好的广播接收器中添加一个Toast提示。代码如下：

public class MyReceiver extends BroadcastReceiver {

    @Override

    public void onReceive(Context context, Intent intent) {

        Toast.makeText(context,"开机启动！",Toast.LENGTH_LONG).show();

    }  

} 

然后在AndroidManifest文件中添加：

• 权限 <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"></uses-permission>

• Intent-filter

          <receiver
  
              android:name=".MyReceiver"
  
              android:enabled="true"
  
              android:exported="true">
  
              <!--添加以下3行-->
  
              <intent-filter>
  
                  <action android:name="android.intent.action.BOOT_COMPLETED"></action>
  
              </intent-filter>
  
          </receiver>
  
  

  此时重启Android系统就可以收到开机提示了。

总结：

动态注册和静态注册的不同：

动态注册的广播接收器可以自由的实现注册和取消，有很大的灵活性。但是只有在程序启动之后才能收到广播，此外，不知道你注意到了没，广播接收器的注销是在onDestroy()方法中的。所以广播接收器的生命周期是和当前Activity的生命周期一样。

静态注册的广播不受程序是否启动的约束，当应用程序关闭之后，还是可以接收到广播。

标准广播和有序广播的接收和发送都是全局性的，这样会使得其他程序有几率接收到广播，会造成一定的安全问题。为了解决这个问题，Android系统中有一套本地广播的机制。这个机制是让所有的广播事件（接收与发送）都在程序内部完成。主要是采用的一个localBroadcastReceiver对广播进行管理。

背景

今天突然听到隔壁在讨论同步屏障，听到这个名字，我依稀记得 Handler 里面是有同步屏障机制的，但是具体的原理怎么有点模糊不清呢？就像一个明星，你明明看着面熟，就是想不起来他叫啥，让我这样的强迫症患者无比难受，所以抽时间来扒一扒同步屏障。

同步屏障机制

1. 直奔主题，同步屏障机制这几个字听起来很牛逼，能浅显的解释一下，先让大家明白它的作用是啥不？

同步屏障实际上就是字面意思，可以理解为建立一道屏障，隔离同步消息，优先处理消息队列中的异步消息进行处理，所以才叫同步屏障。

2. 第二个问题，同步消息又是啥呢？异步消息和同步消息有啥不一样呢？

要回答这个问题，我们就得了解一下 Message，Message 的消息种类分为三种：

• 普通消息（同步消息）
• 异步消息
• 同步屏障消息

我们平时使用 Handler 发送的消息基本都是普通消息，中规中矩的排到消息队列中，轮到它了再乖乖地出来执行。

考虑一个场景，我现在往 UI 线程发送了一个消息，想要绘制一个关键的 View，但是现在 UI 线程的消息队列里面消息已经爆满了，我的这条消息迟迟都没有办法得到处理，导致这个关键 View 绘制不出来，用户使用的时候很恼怒，一气之下给出差评这是什么垃圾 app，卡的要死。

此时，同步屏障就派上用场了。如果消息队列里面存在了同步屏障消息，那么它就会优先寻找我们想要先处理的消息，把它从队列里面取出来，可以理解为加急处理。那同步屏障机制怎么知道我们想优先处理的是哪条消息呢？如果一条消息如果是异步消息，那同步屏障机制就会优先对它处理。

3.那要如何设置异步消息呢？怎样的消息才算一条异步消息呢？

Message 已经提供了现成的标记位 isAsynchronous 用来标志这条消息是不是异步消息。

4.能看看源码了解下官方到底怎么实现的吗？

看看怎么往消息队列 MessageQueue 中插入同步屏障消息吧。

private int postSyncBarrier(long when) {

    synchronized (this) {

        final int token = mNextBarrierToken++;

        final Message msg = Message.obtain();

        msg.markInUse();

        msg.when = when;

        msg.arg1 = token;



        Message prev = null;

        // 当前消息队列

        Message p = mMessages;

        if (when != 0) {

            // 根据when找到同步屏障消息插入的位置

            while (p != null && p.when <= when) {

                prev = p;

                p = p.next;

            }

        }

        // 插入同步屏障消息

        if (prev != null) {

            msg.next = p;

            prev.next = msg;

        } else {

            msg.next = p;

            // 前面没有消息的话，同步屏障消息变成队首了

            mMessages = msg;

        }

        return token;

    }

}

在代码关键位置我都做了注释，简单来说呢，其实就像是遍历一个链表，根据 when 来找到同步屏障消息应该插入的位置。

5.同步屏障消息好像只设置了when，没有target呢？

这个问题发现了华点，熟悉 Handler 的朋友都知道，插入消息到消息队列的时候，系统会判断当前的消息有没有 target，target 的作用就是标记了这个消息最终要由哪个 Handler 进行处理，没有 target 会抛异常。

boolean enqueueMessage(Message msg, long when) {

  // target不能为空

  if (msg.target == null) {

      throw new IllegalArgumentException("Message must have a target.");

  }

  ...

}

问题 4 的源码分析中，同步屏障消息没有设置过 target，所以它肯定不是通过 enqueueMessage() 添加到消息队列里面的啦。很明显就是通过 postSyncBarrier() 方法，把一个没有 target 的消息插入到消息队列里面的。

6.上面我都明白了，下面该说说同步屏障到底是怎么优先处理异步消息的吧？

OK，插入了同步屏障消息之后，消息队列也还是正常出队的，显然在队列获取下一个消息的时候，可能对同步屏障消息有什么特殊的判断逻辑。看看 MessageQueue 的 next 方法：

Message next() {

    ...

            // msg.target == null，很明显是一个同步屏障消息

            if (msg != null && msg.target == null) {

                // Stalled by a barrier.  Find the next asynchronous message in the queue.

                do {

                    prevMsg = msg;

                    msg = msg.next;

                } while (msg != null && !msg.isAsynchronous());

            }

    ...

}

方法代码很长，看源码最主要还是看关键逻辑，也没必要一行一行的啃源码。这个方法中相信你一眼就发现了msg.target == null，前面刚说过同步屏障消息的 target 就是空的，很显然这里就是对同步屏障消息的特殊处理逻辑。用了一个 do...while 循环，消息如果不是异步的，就遍历下一个消息，直到找到异步消息，也就是 msg.isAsynchronous() == true

7.原来如此，那如果消息队列中没有异步消息咋办？

如果队列中没有异步消息，就会休眠等待被唤醒。所以 postSyncBarrier() 和 removeSyncBarrier() 必须成对出现，否则会导致消息队列中的同步消息不会被执行，出现假死情况。

8.系统的 postSyncBarrier() 貌似也没提供给外部访问啊？这我们要怎么使用？

确实我们没办法直接访问 postSyncBarrier() 方法创建同步屏障消息。你可能会想到不让访问我就反射调用呗，也不是不可以。

但我们也可以另辟蹊径，虽然没办法创建同步屏障消息，但是我们可以创建异步消息啊！只要系统创建了同步屏障消息，不就能找到我们自己创建的异步消息啦。

系统提供了两个方法创建异步 Handler：

public static Handler createAsync(@NonNull Looper looper) {

    if (looper == null) throw new NullPointerException("looper must not be null");

    // 这个true就是代表是异步的

    return new Handler(looper, null, true);

}



public static Handler createAsync(@NonNull Looper looper, @NonNull Callback callback) {

    if (looper == null) throw new NullPointerException("looper must not be null");

    if (callback == null) throw new NullPointerException("callback must not be null");

    return new Handler(looper, callback, true);

}

异步 Handler 发送的就是异步消息。

9.那系统什么时候会去添加同步屏障呢？

有对 View 的工作流程比较了解的朋友想必已经知道了，在 ViewRootImpl 的 requestLayout 方法中，系统就会添加一个同步屏障。

不了解也没关系，这里我简单说一下。

（1）创建 DecorView

当我们启动了 Activity 后，系统最终会执行到 ActivityThread 的 handleLaunchActivity 方法中：

final Activity a = performLaunchActivity(r, customIntent);

这里我们只截取了重要的一行代码，在 performLaunchActivity 中执行的就是 Activity 的创建逻辑，因此也会进行 DecorView 的创建，此时的 DecorView 只是进行了初始化，添加了布局文件，对用户来说，依然是不可见的。

（2）加载 DecorView 到 Window

onCreate 结束后，我们来看下 onResume 对应的 handleResumeActivity 方法：

@Override

public void handleResumeActivity(ActivityClientRecord r, boolean finalStateRequest,

        boolean isForward, String reason) {

    ...

    // 1.performResumeActivity 回调用 Activity 的 onResume

    if (!performResumeActivity(r, finalStateRequest, reason)) {

        return;

    }

    ...

    final Activity a = r.activity;

    ...

    if (r.window == null && !a.mFinished && willBeVisible) {

        r.window = r.activity.getWindow();

        // 2.获取 decorview

        View decor = r.window.getDecorView();

        // 3.decor 现在还不可见

        decor.setVisibility(View.INVISIBLE);

        ViewManager wm = a.getWindowManager();

        WindowManager.LayoutParams l = r.window.getAttributes();

        a.mDecor = decor;

        l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;

        l.softInputMode |= forwardBit;

        ...

        if (a.mVisibleFromClient) {

            if (!a.mWindowAdded) {

                a.mWindowAdded = true;

                // 4.decor 添加到 WindowManger中

                wm.addView(decor, l);

            } else {

                a.onWindowAttributesChanged(l);

            }

        }

    }

    ...

}

注释 4 处，DecorView 会通过 WindowManager 执行了 addView() 方法后加载到 Window 中，而该方法实际上是会最终调用到 WindowManagerGlobal 的 addView() 中。

（3）创建 ViewRootImpl 对象，调用 setView() 方法

// WindowManagerGlobal.ddView()

root = new ViewRootImpl(view.getContext(), display);

root.setView(view, wparams, panelParentView);

WindowManagerGlobal 的 addView() 会先创建一个 ViewRootImpl 实例，然后将 DecorView 作为参数传给 ViewRootImpl，通过 setView() 方法进行 View 的处理。setView() 的内部主要就是通过 requestLayout 方法来请求开始测量、布局和绘制流程。

（4）requestLayout() 和 scheduleTraversals()

@Override

public void requestLayout() {

    if (!mHandlingLayoutInLayoutRequest) {

        checkThread();

        mLayoutRequested = true;

        // 主要方法

        scheduleTraversals();

    }

}



void scheduleTraversals() {

    if (!mTraversalScheduled) {

        // 1.将mTraversalScheduled标记为true，表示View的测量、布局和绘制过程已经被请求。

        mTraversalScheduled = true;

        // 2.往主线程发送一个同步屏障消息

        mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();

        // 3.注册回调，当监听到VSYNC信号到达时，执行该异步消息

        mChoreographer.postCallback(

                Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);

        notifyRendererOfFramePending();

        pokeDrawLockIfNeeded();

    }

}

看到了吧，注释 2 的代码熟悉的很，系统调用了 postSyncBarrier() 来创建同步屏障了。那注释 3 是啥意思呢？mChoreographer 是一个 Choreographer 对象。

要理解 Choreographer 的话，还要明白 VSYNC。

我们的手机屏幕刷新频率是 1s 内屏幕刷新的次数，比如 60Hz、120Hz 等。60Hz表示屏幕在一秒内刷新 60 次，也就是每隔 16.6ms 刷新一次。屏幕会在每次刷新的时候发出一个 VSYNC 信号，通知CPU进行绘制计算，每收到 VSYNC，CPU 就开始处理各帧数据。这时 Choreographer 就上场啦，当有 VSYNC 信号到来时，会唤醒 Choreographer，触发指定的工作。它提供了一个回调功能，让业务知道 VSYNC 信号来了，可以进行下一帧的绘制了，也就是注释 3 使用的 postCallback 方法。

当监听到 VSYNC 信号后，会回调来执行 mTraversalRunnable 这个 Runnable 对象。

final class TraversalRunnable implements Runnable {

    @Override

    public void run() {

        doTraversal();

    }

}



void doTraversal() {

    if (mTraversalScheduled) {

        mTraversalScheduled = false;

        // 移除同步屏障

        mHandler.getLooper().getQueue().removeSyncBarrier(mTraversalBarrier);



        if (mProfile) {

            Debug.startMethodTracing("ViewAncestor");

        }

        // View的绘制入口方法

        performTraversals();



        if (mProfile) {

            Debug.stopMethodTracing();

            mProfile = false;

        }

    }

}

在这个 Runnable 里面，会移除同步屏障。然后调用 performTraversals 这个View 的工作流程的入口方法完成对 View 的绘制。

这回明白了吧，系统会在调用 requestLayout() 的时候创建同步屏障，等到下一个 VSYNC 信号到来时才会执行相应的绘制任务并移除同步屏障。所以在等待 VSYNC 信号到来的期间，就可以执行我们自己的异步消息了。

各位，两个月没写文章了，这两个月发生了很多事，也让我产生了很多不一样的感悟。从上次发完《阅阿里大裁员有感》，我的手机里就推了越来越多的“裁员”、“经济下行”、“焦虑”等信息。我这边现在这家公司，虽然不裁员，但是执行了“SABC”绩效分布考核，什么内容大家应该也都清楚，最后给我打了个 B-。呵呵，扣工资 20%，变成所谓的绩效工资，下次考核看情况发放。

很多兄弟看到这可能会替我打抱不平，狗资本家，快去发起劳动仲裁。可是他们马上又下上另一剂猛药，那就是不停的 PUA 你，告诉你现在有家庭，要多努力，要一心扑在工作上，放心，下次一定给你打回来。

我承认，他们这些话术我都看过，基本相当于明牌。可依然我还是被影响到了，情绪十分低落，也没心思去劳动局跟他们 PK。对未来的预期瞬间变得很悲观，人要是一悲观了，真的干什么也提不起兴趣。我一门心思都扑在以后能干什么上，其它的啥也不想管，疯狂的在国内外门户上刷信息，希望能找到一条“赚钱之路”。我研究了 Web3、AI 绘画、搞自媒体、网赚攻略（什么视频搬运、抄书、小说转漫画等等），基本上信息流推给我的，我都研究了一遍。这些玩意越研究越让人焦虑，因为那些标题都起的特别的有煽动性，动不动就日入几万，而我发的那些，浏览量都破不了百。于是我就想研究更多的路子去赚钱，老实说，东南亚那边的情况，我也了解过一些。

后面我对家人的态度也越来越坏，经常不耐烦，看着我小孩我经常叹气，我想这他妈可能就是中年危机提前爆发了，总之那段时间人会越来越焦虑。

后来还是我一兄弟，邀请我一家人去平潭自驾游，我们其实也没玩几天，属于特种兵式旅游，两天两晚（晚上熬夜开车去）。回来之后心情就好多了，也没那么焦虑了。其实本来也没什么，君子不立于危墙之下，这里不行那就走。找不到就先干自己的项目（我有开源项目）。我其实对干这行还是蛮有兴趣的，应该持续坚持的干下去，半途而废干别的是下策。

回想下我那时候焦虑的经历，我以前根本看都不看那种赚钱文章的，因为我知道这些大部分是在卖课，可为什么那时候我着了魔一样呢？其实很大部分与网络有关系，你着急干什么，你就愿意看点什么，你看点什么，网络就给你推什么。这种消极循环人一旦深陷其中，光凭自己是很难走出来的。其实这种时候应该主动去接收一些积极乐观的情绪，有助于自己调整心态，网络给不了你，只有身边人能给你。

更深一步的想，所谓内卷是不是也是通过网络在传播着，深刻的影响到每一个人。所谓的“智能推荐算法”，真的智能吗？大家想看的一定就是适合每个人的吗？你不停的点击去看的信息，真的能帮助到你吗？网络是我们的工具，还是我们是网络的工具？

我想我们真的应该停下来，想想我们到底在多大程度上需要抖音、需要 BiliBili、需要知乎，也许它们真的没这么重要。

人生在世，我们到底应该追逐什么？或者说，追逐什么其实不重要，重要的是我们去追逐的过程。在这个过程中，没有内卷，没有与别人的竞争，只有对自我的审视和成长。

换句话说，我有多久没有好好了解自己了，那些独属于自己的东西，永远不会背叛的资源。我们常说的：能力、人脉、技术、视野。其实除此之外还有很多很多，我刷视频看到的有趣视频点的赞，我 Chrome 里收藏的网页，我百度网盘里躺着的分享资料等等等等，还有最重要的一项，就是我的身体和组成我身体的每一个部分：大脑、心脏、肺...... 有多久没有关注和了解它们了？在这个内卷的时代，每个人都在比拼都在竞争，都怕落于人后，都想快点挣更多的钱，这些，时常让我们忽视了对我们最重要的东西。

有趣的是，每个平台都在疯狂的更新自己的算法，期望能更精准的描述一个人，给人打上各种各样的标签。但在这场竞赛中，没有平台能竞争的过你自己，在这个世界上，只有自己更了解自己。所以我真的感觉它们在做无用功，浪费资源，最好的平台，不是给打各种标签，而是引导每个人发现自己的标签是什么。

这里我想分享给各位几个我思考的点，以供探讨。

原则一：相比与到处去找信息差，更重要的是建立自己的“资源池”

我那时候不停的刷信息，不停的找信息，本质上，我是在幻想着找到一个信息差，从而获利。这也是网上铺天盖地的文章所推崇的，所谓在风口上猪都能飞。但它们总是在掩盖一个逻辑错误，那就是找到信息差和获利之间的因果关系。实际上，找到信息差只是获利的条件之一，你有多大的能力利用这个信息差，这个信息差的时效性，方方面面的因素都会互相交织和影响。

更进一步的想，信息差就像风一样，它存在于冷热空气的交换之时，它存在于各行各业、每时每刻。让我们去追逐风，这现实吗？

我们更应该静下来，好好数数自己手头的东西，整理自己的大脑。找到自己“资源池”有哪些资源，哪些可以为我们所用，哪些可以继续扩充。思路可以打开一点，任何在当前时刻属于你的东西，都是你“资源池”的一部分。

原则二：出卖自己时间和体力的不做

这个不做，不是指不去做，而是指不长期的做。一般入门一个行业或者技术，肯定要付出时间和体力的。但你要说十年如一日的付出相同的东西，那所谓“35 岁”危机就只能找到你了。这点其实各行各业都一样，只是互联网行业处在发声的前沿罢了。

包括所谓网赚、搬运都是一个道理，毫无技术含量的事做几年就好。要时常审视自己现在在干什么，手头有哪些资源，未来的目标是什么。这跟程序运行是一个道理，运行了一段时间，停下来让自己 GC 一下。不然很容易 StackOverflow。

原则三：自己抓住的资源，千万不要轻易放手

如果不经常审视自己的“资源池”，给所有资源估估价值，就很容易被人带坑里。

原先我就做过一个项目，这是个跨部门项目，我那个领导一直告诉我说这个项目没前途、没卵用，绩效也给我打的不好，问我还要不要继续做。我说那就算了吧，做的我都不想做了。

我一放弃，马上就有新人接手，连交接也不用做，代码直接拿走，吃相可见一斑。

也就是从这里我才理解到，我其实没有了解自己，没了解过我手里的项目，被人潜移默化的影响了。影响一个人的思想真的不难，不停的重复就好了。所以还是那句话，多把自己手里的“资源池”拿出来晒一晒，整理一下。

其实 996 也是一样，拿出了你最重要的资源---身体，到底换来了什么，值得好好评估一下。

原则四：做自己喜欢的赛道，更要积累自己的资源

这几个月的经历给我的最大感觉是，这世界上真的有太多太多的行业，也有很多人赚到了钱（至少网络上宣传他们赚了钱）。网络能让这些信息病毒式的传播，导致很多人错觉的以为自己照着做也能挣到钱。但他们忽视的是，网络能把世界各地的人汇聚起来，让信息流通。其实也提供了一个更大的平台，在这个平台里，只有更卷的人才能挣到钱。

有时候真的应该抛开网络。比如，你会写代码，这是你“资源池”里的一项技能，你把这个技能公开到网络售卖。只有两种情况，要么你非常的卷，打拼出一番事业；要么你根本竞争不过别人，这是普遍情况，这世界那么大，比你优秀的人有太多太多了。

但是抛开网络，回到你身边的小小社交圈子，你的技能可能就没那么普遍了。可能你会说，那我做程序员，我身边朋友认识的大部分也是做程序员啊。那么可以这么想，假如你会做菜，你身边的程序员朋友都会做菜吗？假如你会画画，你身边的程序员朋友都会画画吗？人和人总有差异点，你觉得找不到优势，那是因为你尚未建立自己的“资源库”。

先认识自己，再让身边的人认识自己，当他们会给你打标签时，他们就成了你“资源库”中的一员，这就是人脉。这才是是独属于你自己的标签，而不是抖音、B 站为你打的冷冰冷的标签。

总结

以上我感悟的四个原则，我称之为“资源池思维”，一个比较程序员化的名词。

这篇文章发完后，我后续可能就继续更新一下具体的技术文章了，继续深耕技术。

最后，推荐看到最后的各位看一部冷门电影：《神迹》，讲述的是医生维维安托马斯的故事。看完可以来一起交流交流感悟。