前言

很久不见，甚是想念。

解释下没更新的原因，一是秋招找工作，从深圳回来后就准备秋招然后也变懒了；二是因为没有 Offer，也便没有了更新的心情。

总结

工作

如果掐点算的话，在 2019-12-31 24:00:00 之前我只有京东的 Offer，有道的 Offer 在 2020-1-3 才给我。

大体来讲，几乎一整年在准备未来，找实习、复习、准备挑战杯等等……

春招惨淡无光，面试简直是傻白甜，问啥啥不会，双非渣本没有项目经验，谁都不要……最后感谢随手科技选择了我，让我学到了许多东西。之后八月底告别了一起实习小伙伴，独自踏上了秋招的路。

整个秋招不是很顺利，九月底面试了很多，有名的诸如京东、58 安居客、顺丰科技，没名的顺网科技、贝贝、连连支付等等……有些给了 Offer，也有些没给，拒掉的多半是薪资劝退，名气太小，接受的也只有京东。

灰暗的第三季和第四季，也终于在 2020 年初迎来了曙光。

生活

似乎除了求职，其他并没有什么可以说的。

哦对了，年初定投的指数基金，已经投进去 700 多，收益 100+，我也不知道是赚了亏了，来年且看吧。

攒下来的钱倒有不少，实习打拼的，父母给的，项目报销的余款，勤工俭学赚的等。不过也就塞一下牙缝……
计划再贴些钱三月份买个 Mac2020 吧

学习

大三下学期差点挂科，感谢云计算老师在关键时刻拉了我一把 61 分飘过。

差点挂科原因就很简单了，天天准备面试，既没 Offer，成绩又不好，同时还要准备挑战杯省，心力憔悴。

说到挑战杯省赛，真的是坑。看的是创意，还有证明报道。那些证明报道从来哪呢，你们应该可以猜到。但是我就是一个打工的，我有什么办法呢，也只好照做。所以至今贴进去的 1800 元还没报销下来……如果再给我一次机会，我的头一定会摇的跟拨浪鼓一样。

展望

去年的年终总结说输出博客每周两到三篇，手动滑稽……

不立什么 flag 了

• 未来不出意外会开一个微信公众号
• 博客每周一到两篇吧哈哈哈哈

前言

这是个困扰我一年多的问题，今天终于解决了……

起因

一年前将主系统换成 Arch Linux 后，其他一切正常就是 IDEA 的打开设置的快捷键 ctrl+alt+s 失效，让我很是头疼。虽然不是很重要，但是对于我这种强迫症来说别提多难受了……

我曾多次在设置里的快捷键查找 Ctrl+Alt+S，每次无功而返。

解决

今天在群里闲聊到 Linux 下 IDEA 的快捷键问题，一位大佬就发了一张解决方案的截图给了我新的思路。

Linux 万物皆是文件

倾向于系统文件快捷键的占用，所以我下载了 dconf-editor 去更改快捷键的文件。不幸的是看上去并没有什么问题，文件显示层叠窗口的快捷键并没有被设置。打开搜狗输入法以及 Konsole 也都没有发现 Ctrl+Alt+S 的痕迹，那为什么会被占用呢？百思不得其解……

想起了之前加入 TG 上的 Arch Linux 官方群组，就去上面将问题描述了一遍。一分钟后，大佬告诉我是因为 fcitx 的全局快捷键，Ctrl+Alt+S 被设置成保存所有设置和历史。

收到回复后，我一想那简单啊，修改配置文件不就完了……
天真的把 S 改成 Q，重新登录发现并没有什么卵用。定睛一看前面还有 # 号（吐血.jpg）……改成下面这样重启登录就解决了。

总结

1. gnome 可以下载 dconf-editor 去查找快捷键有没有被默认系统设置占用，kde 只需在设置里查找是否有重复的快捷键即可
2. 看看是不是因为输入法的框架是 fctix，是的话修改 fctix 的配置文件，将保存所有设置的快捷键改成其他键位
3. 直接改 IDEA 的快键键不好么？？？

这个快捷键终于解决了，让我心情很舒畅！！！希望今后能帮助到其他人。

前言

捂脸.jpg

起因

这篇博文说到的用了 Mybatis 做拦截器来记录产品以及运营变更后台内容的操作信息。本来直接在后台管理的模块操作就可以了，但是有个要求是记录操作前后的信息……因为公司大都是微服务采用的单数据源，操作人信息是在 A 服务，变更前后的信息是在 B 服务。

一开始接到任务的时候就感觉不好搞，这不是坑爹嘛直接拦截 Controller 的日志多好（小声）

经过与大佬的深入探讨，有两个技术方案。这里为了长话短说，就只讲最终实现的技术方案。

我需要在 RPC API 中加个字段来传递操作人的真实信息以及客户端 IP，B 服务接收到后通过 ThreadLocal 传递到 DAO 层，最后拦截器先去数据库查询出旧值，然后执行原来的方法，最后拼接旧值以及新值，日志入库。

这个方案很完美有没有，嗯如果没有 Bug 就很完美。

开发

经过几天的开发、提测、测试通过、上线了。

上线半小时，导师通过 kibana 观察线上的日志发现并没有什么问题。看一眼线上的数据库，卧槽记录了几张不用记录的表，操作人信息怎么都是一样的，功能倒是写的没问题，就是似乎将所有业务的增删改特定的方法都记录了……

排错

下面是段很有意思的对话

我：为什么能获取到操作人的信息，如果 A 系统没带过来的话，B 中心服务所有的操作为什么会带有脏信息……
导师：你这写的有问题啊？
我：是啊，OS：代码不都给你 review 过了么（逃）
导师：你是不是用了 ThreadLocal
我小鸡啄米似的点头
导师：讲道理线程调用结束了 ThreadLocal 不就被回收了么？
我：是啊是啊

随后导师看着逐渐增加的日志记录表陷入了沉思，我也陷入了思考……

突然灵光乍现，因为没有在拦截器的拦截方法里 remove 掉 ThreadLocal，肯定有个线程池调用了，那为什么有线程池呢？哦艹，Dubbo 默认有线程池……我没有 remove 掉，管理操作后台如果有操作可能会污染到所有线程。

复现

因为只是增加了记录日志数量，所以大佬们似乎并不急于修复数据让我先自己在本地复现一下确定原因。
我把 Dubbo 线程池的数目调成 1， DeBug 模拟登录复现了场景。Dubbo 通过线程池来处理提供 provider 的服务，如果我没有 remove 掉的话会导致相关信息一直在，GC 回收时会产生内存泄漏

修复

ThreadLocal remove 掉需要用 finally 代码块，侵入性太强，经过短暂的讨论决定新版本用注解add 以及 remove 掉 ThreadLocal，暂时的解决方案是注释掉拦截器。

总结

那天加班到了九点，第一次遇到线上的 bug 有点猝不及防。

虽然我知道 ThreadLocal 需要 remove，但是想当然以为没有线程池调用就不会有问题。
是啊没有线程池调用是没啥问题，但最骚的是忽略了 Dubbo 内部有个默认的线程池去提供服务。有了理论基础还是要有实践经验，不然容易出问题。

庆幸我是实习生，不然绩效就是 C 了（手动狗头）

前言

此篇是本博客引入 Google 广告的过程
算是教程吧
开通完之后记得把广告插件关了看下效果

准备

• 一个稳定的 VPN
  不稳定也行，注册卡顿你不介意就行……
• 一个博客
  要原创几篇文章，我猜是人工审核吧
• 一个 Google 账号

申请开通

1. 传送门
2. 将谷歌提供的代码扔在 head 里，因为我的博客是 hexo v6.0，所以将验证代码扔在了 themes/next/layout/_custom/head.swig 里面，这样之后主题升级会更加平滑
3. 验证完后，等两三天，审核通过就可以了

友情提醒：新站不容易过审

配置

自动广告

没玩过，据说是 Google 爸爸根据网站长宽比投放的，投放率很低。

广告单元

这是今天要讲的关键部分，点击想要投放的广告样式后会获得相应的代码。

展示广告

将代码插入到 themes/next/layout/_macro/sidebar.swig 文件中 <div class=”sidebar-inner”> </div> 标签包裹着的最下部。

信息流广告

类似知乎推荐、QQ 空间信息流式中的广告，扔太多地方不好就没研究了。

文章内嵌广告

可以放在文章尾部，代码往 themes/next/layout/_macro/post.swig 一扔就行

PS：不过得注意位置我扔在这里，大佬们可根据自己博客在浏览器 F12 选位置嵌代码。

后来发现内嵌广告太大，就改成了展示广告的横幅版了……

最后

一般 Chrome 或者 FireFox 都会装广告屏蔽插件，手机浏览器应该不会被屏蔽，所以一般也不会有人点。（那为啥要装？人总要有梦想，万一有人问了呢）

游客点一下根据广告质量来算钱，有点一下 0.14 刀的也有 0.07 刀的，广告点满一百刀才能提现。不过别想着薅羊毛，容易被封号。据大佬们说广告点满十刀后还会又自检，还是希望不要舍本逐末吧。

最后，大佬们，关掉广告插件帮我点个广告可好～

前言

一个月前的实习生面试，面试过程很愉快，面试官很和蔼。但一个月后复盘，发现并没有回答到点子上，如果我是面试官，我也不会要这么一个人。

红黑树与 AVL 树的区别

红黑树的定义

• 两个节点颜色只有红黑两种
• 根和叶子节点都为黑色
• 两个红节点不相连
• 路径上的黑节点数一致

AVL 强制左右子树高度相差为 1，平衡代价比红黑树大

LinkedList 与 ArrayList 的区别

（也就是数组与链表的区别）

• 数组需要连续的地址空间
• 数组支持随机访问下标
• 还问了插入的话哪个快

Spring 代理

如何实现 JDK 代理

Spring 五种隔离级别

这一块答上来了，但是都是错的，春天的面试太失败了

• 数据库的四种级别
• 后端数据库默认的事务
  Mysql 默认采用的 REPEATABLE_READ 隔离级别 Oracle 默认采用的 READ_COMMITTED 隔离级别.

不可重复读

这一块面试官应该想问，可重复读隔离级别如何消除不可重复读，但被我糊弄过去了。另外，RR 级别可以消除当前读的幻读。当然这些都是之后才学习到。

如何实现事务

底层采用的还是 JDBC 的事务，只不过用动态代理以及注解的方式代理，抽出来往下看的话就是 TransactionManager 提供的 commit、rollback、close 的方法。

单点登录的流程

AQS

底层的结构是 FIFO 队列。线程进来先去竞争锁，竞争不到将线程扔到队尾自旋。一旦锁释放，若非公平锁，头结点后面的节点会通过自旋获得锁。

软链接与硬链接的区别

• 软链接
  快捷方式
• 硬链接
  复制一份相同的 inode 号以及权限，并且计数器 +1，另外硬链接的文件必须存在无法对目录硬链接。硬链接不能在不同文件系统中使用。

Maven 依赖命令行查看

我应该答，可以通过 mvn -h 的方式看看

前言

需求驱动学习，最近一周组长让我在业务模块里加日志，经过与导师以及组长讨论决定用拦截器记录日志。周五下班前已经发了提测邮件。

虽然我知道 MyBatis 有这东西，但是没在实际情况中用过，心里有点虚2333……所以才有了此文的理解。

前世今生

它的本质就是 JDK 的动态代理。首先先来复习一下动态代理我贴了一段最常见的 JDK 动态代理的代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

//服务员的接口
public interface Waiter {
    void serve();
}
//服务员的实现
public class WaiterImpl implements Waiter {
    @Override
    public void serve() {
        System.out.println("服务中...");
    }
}
//需要代理的对象处理器
class WaitInvocationHandler implements InvocationHandler {
    private Waiter waiter;

    public WaitInvocationHandler(Waiter waiter1) {
        waiter = waiter1;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("你好");
        Object invoke = method.invoke(waiter, args);
        System.out.println("再见");
        return invoke;
    }
}
public class App {
    //普通的实现
    @Test
    public void fun() {
        Waiter waiter = new WaiterImpl();
        waiter.serve();
    }

    @Test
    public void fun1() {
        Waiter a = new WaiterImpl();
        ClassLoader classLoader = getClass().getClassLoader();
        Class[] classes = {Waiter.class};
        //生成代理对象
        Waiter waiterproxy = (Waiter) Proxy.newProxyInstance(classLoader, classes, new WaitInvocationHandler(a));
        waiterproxy.serve();
    }
}

拦截器

V1

我现在要在函数执行前后记录日志操作，考虑需要在代理方法那里定义个拦截器的接口，如下代码所示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

//拦截器 V1 版本
public interface MyInterceptorV1 {
    void interceptor();
}
//代理对象变成这个
public class TargetProxyV1 implements InvocationHandler {

    private Target target;

    private MyInterceptorV1 myInterceptor;

    public TargetProxyV1(Target target, MyInterceptorV1 myInterceptor) {
        this.target = target;
        this.myInterceptor = myInterceptor;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        myInterceptor.interceptor();
        return method.invoke(target, args);
    }
}

这是最简单的版本，但是我们很多时候需要拦截参数等根据参数判断拦不拦截等，代码更新如下

1
2
3
4
5
6
7
8
9

public interface MyInterceptorV1 {
    void interceptor(Method method, Object[] args);
}

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    myInterceptor.interceptor(method, args);
    return method.invoke(target, args);
}

V2

似乎上面的方案很完美 废话肯定不完美，不然怎么会有这段

没错，第二段代码并不是很优雅，有方法参数重复，可以考虑将三者抽出来，直接在拦截器的实现里写上method.invoke(target, args);，如下代码所示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

@Getter
@Setter
@AllArgsConstructor
public class MyInvocation {
    private Object target;
    private Method method;
    private Object[] args;

    public Object proceed() throws InvocationTargetException, IllegalAccessException {
        return method.invoke(target, args);
    }
}
//没错这就是 V2 版本
public interface MyInterceptorV2 {
    Object interceptor(MyInvocation invocation) throws Throwable;
}

总结

Mybatis 的拦截器就是像我上面这么写的，名字也跟我取得一样，只是它更加复杂，能够通过注解区分拦截 update 操作和 query 等操作。

既完成了任务又巩固了原来的知识，这种感觉很棒，最关键的是还有钱拿……

本文代码

前言

异常有名的背包问题，终于有勇气面对它了。
三年前学数据结构算法的时候，那时候也不懂，参考的很多博客文章没有例子，都是数学公式生硬地出来，而且写法各种各样，导致一直没有勇气去接触这些。

题目描述

在 n 个物品中挑选若干物品装入背包，最多能装多满？假设背包的大小为 w，每个物品的大小为 A[i]

样例

1
2
3
4
5
6
7

样例 1:
输入:  [3,4,8,5], backpack size=10
输出:  9

样例 2:
输入:  [2,3,5,7], backpack size=12
输出:  12

动态规划

最简单的动态规划做法是将过程分为 n 个阶段，每个阶段决策是否将物品放入背包中。记住，动态规划的本质就是通过数组存储状态。

请看下面的例子，这是现在我拥有的东西以及条件

1
2

int[] weight = {2,2,4,6,3};// 物品重量
int w = 9; // 背包承受的最大重量

我们需要通过这些来构建出一个二维数组 states[n][w+1] 记录状态。states[i][j] 表示第 i 个做完决策后，背包容量 j 能放多少价值。这道题目物品的价值与物品的重量相等。

• 为什么数组是 w+1？
  数组边界可以取到 w 意味着 states[][w] 可以表示装满背包时的总价值是多大。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public int backPack2D(int m, int[] A) {
    //求出物品个数
    int n = A.length;
    int[][] states = new int[n][m + 1];
    //初始化 states[0][]
    for (int i = A[0]; i <= m; i++) {
        states[0][i] = A[0];
    }
    for (int i = 1; i < n; i++) {
        for (int j = m; j >= 0; j--) {
            //当不把物品放入背包，将上一层的数值拷贝过来
            if (states[i - 1][j] > 0) {
                states[i][j] = states[i - 1][j];
            }
        }
        //决策将物品放入背包，取最大值
        //注意这里 j 的范围
        for (int j = 0; j >= 0; j--) {
            states[i][j + A[i]] = Math.max(states[i][j + A[i]], states[i][j] + A[i]);
        }
    }
    return states[n - 1][m];
}

1. 重量数组{2,2,4,6,3}，代码更新数组如下
   new 数组时的状态

   

2. 初始化数组，第 0 个物品决策
   

3. 第（i=1）个物品决策完后数组状态
   
4. 第（i=2）个物品决策完后数组状态
   
5. 第（i=3）个物品决策完后数组状态
   
6. 第（i=4）个物品决策完后数组状态
   

states[i][j] 表示第 i 个物品决策完后，容量为 j 的背包里最多能放多少价值的物品，所以最后返回 states[n-1][m] 即可

优化

上述解法用到了一个二维数组，其实我们还能进一步地优化空间

1
2
3
4
5
6
7
8
9
10
11

public int backPack(int m, int[] A) {
    int n = A.length;
    int[] states = new int[m + 1];
    for (int i = 0; i < n; i++) {
        //注意这里倒着遍历
        for (int j = m - A[i]; j >= 0; j--) {
            states[A[i] + j] = Math.max(states[A[i] + j], states[j] + A[i]);
        }
    }
    return states[m];
}

解释一下倒着遍历的那里以及 j 的范围

• 如果正序遍历，后面的值有可能直接被前面的覆盖了，当遍历到覆盖的值的时候，此时当前数组元素的值并不是从上面一行数组 copy 下来的，而是通过 max 计算出来的
• j 的范围有两种，第一种是 m 到 A[i]，可以理解为要更新的数组状态；第二种是 m-A[i] 到 0，可以理解为遍历前序数组，更新尾部的数组。虽然两种理解代码不一样，但是结果一致。
  

01 背包升级版

加上了 value 数组，我将链接以及 AC 代码贴在这里，希望对你有所帮助

• 题目链接
• 代码

  1 2 3 4 5 6 7 8 9 10

  public int backPackII2(int m, int[] A, int[] V) { int n = A.length; int[] states = new int[m + 1]; for (int i = 0; i < n; i++) { for (int j = m - A[i]; j >= 0; j--) { states[j + A[i]] = Math.max(states[j] + V[i], states[j + A[i]]); } } return states[m]; }

小技巧

• 恰好装满与尽量装满
  • 恰好装满需要将数组初始化为 0,-1,-1,-1,-1……
  • 尽量装满只需要 0,0,0,0……

原因的话偷个懒，上一个背包九讲的图

总结

01 背包是动态规划的入门，需要静下心来仔细想一步步 DeBug，收获会很大。很多题目都是基于 01 背包的变种。
江湖艰险，希望此文会对你有所帮助！

前言

现在正在大学城的图书馆敲着文字，周围是北大清华哈工大的研究生，让我这个双非本科的瑟瑟发抖……

体验

城市

首先说说深圳这座城市给我带来的最大感受吧

• 热
  刚下火车扑面而来的是一阵热风，让我这个南方人体验到了真正的潮热
• 多
  在这个 2000 平方公里的城市，居住人口超过 2000 万，报道的那天就让我感受到了拥挤，几乎是一站一辆公交车都满足不了出行，加上上下班地铁限流，简直是要人命
• 新
  建筑大都很现代化，像是杭州滨江

公司

随手科技在著名的南山区金蝶软件园 B 幢，大概有 4、5、6、7、8 楼吧（萌新入职才一周，不是很清楚，见谅）

新人入职两周不让碰源码，要看两周文档，下周培训。不过文档内容和规范真的丰富，同事沟通、请假以及项目管理都有内部的软件。

周二、周四有下午茶，晚上加班到十点能打车，每个月有生(qiang)日(dan)会(gao)，福利比杭州某公司多了一点……，除了钱给的稍微不够了点。

导师待我还不错，带我逛周围的饭店介绍周边的环境给我开文档的权限什么的，还会撺掇我去拿吃的2333。

随手算是暑期镀金的好地方了，不用像很多实习生那样担心租房问题，大城市租房是真的贵啊。加上在异地，看房也是问题。公司分配宿舍，溜的时候退租就好了。

这里要吐槽下 HR，emmmm 工牌在上班后两天才拿到，结果发现还要去开门禁权限……我至今仍然不能自由出入……

闲聊

随手算比较大的了，对新人很友好，文档很丰富，我们组有活干，起码之后不会带薪摸鱼。

来深圳其实父母不是很支持，担心我的安全，因为这件事我向他们哭诉了很多次了，也影响了春招后来的状态。再后来父母也拿我没办法，只能妥协。互联网的信息差对我们这代以及我们的父母影响还是很大的。当然也有观念的问题，父母想一直把我限制在浙江，甚至最好在村里找份工作，这样会安生许多。可是……

我真的不想一直在父母的庇护下成长，父母是农村人加上家境又不是很殷实，下半年加油吧！

前言

我胡汉三又回来了

考完最后一门马克思主义原理，就意味着三月份自己制定的春招计划画上了逗号。

金三银四

这里我只想提醒一句，每个人的一生中不出意外的话只有一次金三银四，也就是大三下的这一段时间。虽然可能你的未来不取决于这段时间，但如果这段时间状态良好无疑会给你未来的职业生涯中添加上浓墨重彩的一笔。

很遗憾，我并没有把握住这些机会，复盘原因：

• 简历准备不充分
  在期间，我听取他人的建议更换了一次简历，这里感谢亚信科技老哥提供的建议。他的建议是，既然找 Java 后台实习，你的简历上要单独开发的模块，要让人家清楚招你进来你是能干活的，而不是吹吹牛皮。
• 挑战杯事宜
  这是个无比巨大的坑，虽然我是负责人，但是真的很累。你每礼拜需要花费一小时地铁上的时间区评委家中更改文档，不止一次！！！临近比赛，还要去准备答辩事宜……拿的钱却跟同等级别比赛的钱是一样的，这也太坑了！
  为什么还要参加？去翻我前面的文章吧
• 基础不牢，地动山摇
  基本上我的三四月份是在投简历-笔试-投简历中度过，根本没有电话，注意一个都没有！意思是我笔试没通过呗，加上上一条原因，金三银四就过去了……

五月重新起航

其实四月底已经开始着急了，开始在 Boss 直聘上找小公司练面试。有幸的是，经过三四月份魔鬼训练，小公司的面试题都比较简单，收到了几家不错的 Offer，但由于不是很甘心（想去稍微大一点的公司），所以一直吊着，至今还没拒绝……

这里重点提醒一下，在春招前最好要先找小公司沉淀一下（大牛当我没说），问问面试题项目啊都是极好的，而且过了有个保底 Offer，心里也不慌了。
实话说，我当初看到这条前人的经验了，但当时头铁啊，实习面试我这种水平应该还行吧，哪知道水这么深……

总结

虽然收到了还算满意的 Offer，但这家公司在深圳（不是你们想的某讯）……离杭州太远了，属实不方便。

经验

所谓经验，给秋天的我和未来的你们看吧

• 看到招聘信息请立刻投简历
  别像我这样攒着攒着，人招满了，连面试机会都没有
• 打好基础，想进大厂实习需要计算机深厚的功底
  菜鸡能做的是刷题，搞懂知识点
• 找小公司试水（大牛绕道）
• 寒假就需要准备了
  甚至在期末考试结束后就要准备了，金三银四想要上岸，真的一点都不夸张，像我三月份才开始准备真的太晚了。

最后，期待秋收。

前言

很早就想仔细学了，终于有机会记一下笔记……

Lambda 表达式

函数式接口

只定义了一个抽象方法的的接口，值得注意的是，Java 8 引入了 stream 等方法，但是原先的 Collection 里没有。为了提高效率，接口的设计者就引入了 default 关键字来扩充接口。可用 @FunctionalInterface 标记为函数式接口，类似 @Override。

常用的接口

• Predicate
  返回 boolean
• Consumer
  void，适用于 sout
• Function
  可以将 T 转化为 R

感觉

其实 Java 中就是一个接口实现，如果要扯到函数式编程的话就要扯到 lambda 演算，主要为三条规则：

• 函数定义
• 标识符引用
• 函数应用

说人话

我的理解是这三条规则为定义一个变量和函数，然后告诉你定义完了怎么去使用它

举个难一点的栗子（PS：为什么要举难一点的例子……答：装逼）

1

(lambda x y. x y) (lambda z . z * z) 3

流

从支持数据处理操作的源生成的元素序列

用过的人都说好……

定义

• 内部迭代
  将迭代封装在内部，例如

  1 2	Dish.menu.stream().map(Dish::toString).collect(Collectors.toList()); Dish.menu.stream().forEach(System.out::println);

• 使用规则

  • 数据源（例如集合）
  • 中间操作链
  • 终端操作
• 流只能遍历一次，只能消费一次

创建

1
2
3
4
5
6
7

// Stream.of
Stream.of("Java 8", "Lambdas", "In", "Action").map(String::toUpperCase).forEach(System.out::println);
// Stream.empty
Stream<String> emptyStream = Stream.empty();
// Arrays.stream
int[] numbers = {2, 3, 5, 7, 11, 13};
System.out.println(Arrays.stream(numbers).sum());

使用

筛选和切片

• filter
• distinct
  筛选互异元素
• limit
  取前几个元素
• skip
  跳过前几个元素

映射

• map

• flatMap
  将流中的每个值都换成另一个流，然后把所有的流连接起来成为一个流，个人理解为将流里的值继续转换为子流然后连接。

  1 2 3 4 5

  List<Integer> list1 = Arrays.asList(1, 2, 3); List<Integer> list2 = Arrays.asList(4,5); list1.stream().flatMap(i-> list2.stream().map(j->new int[]{i,j}) ).forEach(t-> System.out.println(t[0]+","+t[1]));

• mapToInt

查找和匹配

短路操作，找到一个符合条件的立即返回

• anyMatch
  至少匹配一个
• allMatch
  都匹配
• noneMatch
  没有匹配的
• findAny
• findFirst
  与楼上有并行的区别，findAny 不一定是返回第一个

规约

使用 reduce，第一个参数为初始值，第二个为执行函数直到规约到一个数

细节

• 数值流以及对象流相互的转化

  • IntStream
  • LongStream
  • DoubleStream

    1 2	int calories = menu.stream().mapToInt(Dish::getCalories).sum(); menu.stream().mapToInt(Dish::getCalories).boxed();

• 数值范围

  • rangeClosed

    1	long count = IntStream.rangeClosed(1, 100).filter(d -> d % 2 == 0).count();

  • range
    不包括结束值

收集器

前面的都是小儿科，在开发人员的代码里很多都是收集器

规约与汇总

• counting
• maxBy
  需要实现 Comparator
• summingInt/summingLong/summingDouble
• averagingInt/averagingLong/averagingDouble
• summarizingInt/summarizingLong/summarizingDouble
• joining

实现

通过 reducing() 实现，需要三参数，单参数为三参数的特殊情况，起点为第一个项目，转换函数为恒等函数，第三个为函数计算

1
2
3

menu.stream().map(Dish::getName).collect(joining());
menu.stream().map(Dish::getName).collect(reducing((s1,s2)->s1+s2)).get();
menu.stream().collect(reducing(" ",Dish::getName,(s1,s2)->s1+s2));

分组

groupingBy

• 单参数 groupingBy(f) 实际是 groupingBy(f,toList())
• 双参数，第二个参数为任意类型的收集器，也可为 groupingBy(f)
• 常用的联合使用收集器为 summingInt,counting,mapping 等
• 隐含参数可为 toSet()

分区

特殊的分组，分区函数返回 boolean

接口

• Supplier<A> supplier()
• BiConsumer<A, T> accumulator()
• Function<A, List<T>>()
• BinaryOperator<A> combiner()
• Set<Characteristics> characteristics()

自定义收集器

单纯的能看懂……

并行

• 避免共享状态
• 留意装箱
• limit 和 findFirst 依赖元素顺序

PS：如果想提高效率，自行实现 Spliterator 接口
为什么就一句话，因为我不太会

默认方法

Ootional说下个人理解，接口中引入了 default 关键字，使接口更新更加平滑，不需要更改已经编译出来的客户端 clas 文件，只需在上游添加默认方法即可。
其实官方就是为了方便引入 stream，防止升级之后出现客户端代码崩溃的问题

Optional

这个竟然在面试中被问到了，1.8 之后处理异常有什么改进。虽然有了解过，但是竟然被问懵了，还有区别？？？后来经过提醒才意识到原来他问的是空指针处理的 Optional……

他山之石

在很早之前好像是《七周七语言》里（具体我忘了哪本书）看到的说语言的设计者很痛恨引入空指针这个概念，因为程序员在业务中需要去进行繁琐的判断，后来才设计出 Haskell 的 Maybe 类型。
像 Groovy 处理就直接引入安全导航操作符，若引用链中有空指针传递下去，返回一个 null。

可以攻玉

1
2
3
4
5
6

public String getCarInsuranceName(Optional<Person> person) {
        return person.flatMap(Person::getCar)
            .flatMap(Car::getInsurance)
            .map(Insurance::getName)
            .orElse("Unknown");
    }

细节

在设计时没有考虑将其作为类的字段使用，没有实现 Serializable 接口，无法序列化
替代方案如下

1
2
3
4
5
6

public class Car {
    private Insurance insurance;
    public Optional<Insurance> getInsuranceAsOptional() {
        return insurance;
    }
}

个人感受

有点类似流，但不同于流的是它只是个对象，如 filter 是对对象属性的操作

CompletableFuture

工厂方法
CompletabelFuture.supplyAsync();

• 异步操作，相比于并行的 stream 可以自定义线程池，适用于 I/O 密集型任务
• 管理异常
• 可以将异步任务合并
  thenCombine
• 注册回调函数
  thenAcecpt
• 决定程序运行
  allOf anyOf

时间

• LocalDate
• LocalTime
• LocalDateTime

未完待续……

前言

整理录音的时候才发现自己有多菜，这都回答的啥呀……

面试题

• Java 八大基本类型
  • short 变量 +1，真的细，还好好久之前瞄了一眼
• New String(“123”) new 了几个对象
• equals 与 ==
• HashMap 原理
• 红黑树定义、优点与普通二叉树的区别，效率
• ConcurrentHashMap
• Synchronized
  1. 普通同步方法，锁是当前实例对象
  2. 静态同步方法，锁是当前类的class对象
  3. 同步方法块，锁是括号里面的对象
• volatile
• 反射
• IOC 原理以及好处
• AOP
  • JDK 原生
  • CGLib
• Spring 事务级别
• SpringBoot 自动化
• 垃圾回收
  • 引用计数
  • root 节点
• Mybatis 执行流程
• Mybatis 与 JDBC 的区别
• NIO
• TCP 与 UDP 区别
• TCP 三次握手
• MySQL 索引
• MySQL 死锁
• MySQL 乐观锁以及悲观锁
• 查看日志命令

人生

• 未来一年的规划
• 理想的工作环境

提要

总说春江水暖，但只有体验过才知道今年的水让我瑟瑟发抖。我就是死也不会考研？

感悟

四月快走了，仍然没有春招 Offer。不过最近的感悟倒是获得挺多，当然还有血淋淋的教训。

早

早就是优势。

投简历越早投越好，就是知道内推信息就得立刻马上投。不要像我这样收藏着一大波招聘内推消息，过了几礼拜才投，hc 早没了……加上自身学校没有 Buffer 加成，我也不知道两个月前哪来的自信（不要跟我扯招聘时间，真的是越早投机会越大，因为我就是看了招聘时间，结果很难受，我挺后悔的）不举例子了，因为排队的人太多，我已经被简历劝退了两三次了，真的是血淋林的教训啊。

不过从另一方面来讲，春天为秋天积攒了经验，总比秋天结束的时候才知道好，毕竟大目标还是秋天，只是夏天缺乏了漂亮光鲜的履历罢了，但说实话挺难受的。

革命尚未成功

有人说可以准备秋天了，但我并不认同。因为还有收官战，虽然金三银四转瞬即逝，但春天还没结束，拿起武器继续战斗吧！

未完，待续……

碎碎念

拖更一时爽，一直拖更一直爽

最近忙于找实习以及挑战杯省赛，两者聚在一起当然就忙得不可开交。关于省赛，前几篇文章也有提到，其实我是不太愿意花时间搞的，但是命运使然，只好寻找某一平衡点喽。

概念

介绍一些概念，当然也为了使自己印象深刻

线程

操作系统调度的最小单元，一个进程中的所有的线程都有完全一样的地址空间，意味着共享同样的全局变量。

上下文切换

CPU 分配给各个线程时间片，但因为时间片很短，所以 CPU 不停的切换线程。但是 CPU 切换前会保存上一个任务的状态（进程状态、优先级、程序 I/O 的状态、文件描述符等）到内存，以便下次切换回这个状态。

解决方案

多次上下文切换会影响多线程执行速度

• 无锁并发编程
• CAS 算法
• 使用最少线程
• 协程

线程间通信

等待/通知的经典范式

• 等待方

  1 2 3 4 5 6

  synchronized(对象){ while(条件不满足){ 对象.wait(); } 对应的处理逻辑 }

• 通知方

  1 2 3 4

  synchronized(对象){ 改变对象 对象.notifyAll(); }

Thread.join()

线程 A 执行了 thread.join() 语句时表示，当前线程 A 等待 thread 线程终止之后才从 thread.join() 返回。

ThreadLocal

个人看源码理解就是在虚拟机栈中存着引用，真正存值的是 ThreadLocalMap。而 ThreadLocalMap 内部用 Entry 存放 K-V，哈希冲突则采用的是开放寻址法。
另外，ThreadLocal 在线程池里容易存在内存泄漏，因为只要线程被 GC 回收，即使弱引用 Key 的值为 null，一般不会内存泄漏。就怕线程池回收利用，Key 为 null 了，value 则还有值。解决方法就是调用 remove() 方法，将值设置为 null。

前言

有输入肯定要有输出。

内存区域划分

• 程序计数器
  唯一一个没有规定 OOME 的地方。执行 Java 方法时记录当前方法的 JVM 指令地址；执行 Native 方法时，计数器为空。
• Java 虚拟机栈
• 本地方法栈
• 堆
  内存管理的核心区域，分为新生代和老年代，再细致一点分为 Eden 空间、From Survivor、To Survivor 等
• 方法区
  所有线程共享的内存区域，存储元数据，如类结构信息、字段、方法等。无法满足内存分配需求时，抛出 OOME。
  • 运行时常量池
    方法区的一部分，存放编译期生成的各种字变量，还有运行时的符号引用等。例如 String.intern() 后放置的地方。
• 直接内存
  JDK 1.4 引入 NIO 类，它可以使用　Native 函数库直接分配堆外内存，然后通过一个存储在 Java 堆中的 DirectByteBuffer 对象作为这块内存的引用进行操作。
• Code Cache
  JIT Compiler 在运行时对热点方法的编译；GC 运行时部分需要占用的空间等，但 JVM 规范中并没有涉及。

OutOfMemoryError

堆溢出

不断创建对象并且无法回收

栈溢出

在单线程下，当内存无法分配时，虚拟机抛出通常是 StackOverflowError 异常。

方法区运行时常量池溢出

JVM 对于方法区的回收非常不积极，例如老版本的 JDK 处理 String.Intern() 时占用太多空间。随着元数据区的移除永久代，类元数据只受本地内存影响。

本机直接内存溢出

垃圾回收不会主动收集 Direct Buffer，需要自己手动调 System.gc()。另外。不会在 Heap Dump 中看见。

垃圾回收

判断对象是否存活，引用计数法很难解决循环引用的问题，所以才有了可达性分析

GC Roots 的对象包括以下几种：

• 虚拟机栈中引用的对象
• 方法去类静态属性引用的对象
• 方法去常量引用的对象
• Native 方法引用的对象

可达性分析算法

至少两次标记过程，第一次标记筛选出有必要执行的 finalize() 方法的对象，对象可在 finalize() 中自救一次，因为 finalize() 方法只会被系统自动调用一次。

回收算法

• 标记-清除算法
  效率不高，会产生大量不连续的内存碎片
• 复制算法
  新生代采用复制算法收集内存，大对象通过分配担保机制进入老年代
• 标记-整理算法
  将存活的对象移至一端，减少内存碎片
• 分代收集算法
  根据年代特点采用最适当的算法，需要上述算法支持

内存分配

都可通过参数设定

• 对象优先在 Eden 中分配
• 大对象直接进入老年代
• 长期存活的对象将进入老年代
  年龄计数器
• 动态对象年龄判断
  Survivor 空间中相同年龄所有对象大小总合大于 Survivor 空间的一半，年龄大于或等于该年龄的对象就直接进入老年代
• 空间分配担保
  需要检查老年代的空间是否满足新生代所有对象空间，不够的话还要查看设置的值是否允许冒险，以决定 FullGC 是否有必要

类加载

• 加载
  获取字节流，生成对象，提供数据访问入口
• 验证
  是否符合虚拟机规范
• 准备
  为变量分配值
• 解析
  将符号引用替换为直接引用
• 初始化
  执行类构造器 () 方法

感悟

最近看《深入理解 Java 虚拟机》的一些笔记，又是一本相见恨晚的书，强烈推荐前几章和后面几章。

内存模型

此图来自《深入理解 Java 虚拟机》，看完以后感觉这个知识水平都提高了2333。这里的主内存不是内存条，而是虚拟机的内存的一部分。不同的线程通过刷新主内存中的值来进行同步。如果没有线程并发的考虑，闭着眼睛就能想到数据的不一致。

内存模型定义了以下 8 种操作来完成主内存与工作内存同步的细节，除去特殊情况，每一个操作是原子不可再分的

• lock
• unlock
• read
• load
• use
• assign
• store

另外还定义了一些规则，太多了没咋记住……不过也以此引出了最为常见的先行发生的原则，用于确定访问是否线程安全。

happen-before 规则

中文名叫先行发生规则，含义是Java 内存模型下天然存在一些关系，无需同步器去实现，可以在编码中直接使用。换句话说，不在先行发生规则的两个操作，虚拟机可以对它们进行重排序，也就是线程不安全了。

规则有八条：

• 程序次序规则
  同一线程按照控制流顺序
• 管程锁定规则
  unlock 指令操作先于 lock 操作
• volatile 变量规则、
  写操作先于读操作
• 线程启动规则
  start 最先发生
• 线程终止规则
  终止检测最后发生
• 线程中断规则
  interrupt() 先行发生于代码检测中断
• 对象终结规则
  初始化先于 finalize
• 传递性
  A 先于 B，B 先于 C

需要注意的一点是，时间先后顺序与先行发生顺序没有太大的关系，一切以先行发生的原则为准。

volatile

有了内存模型的概念，对 volatile 又有了几分理解
Java 虚拟机提供的最轻量的同步机制，当一个变量被定义为 volatile 时有一下两种语义

可见性

volatile 变量对所有线程是立即可见的，对 volatitle 变量所有写操作都能立即反映到其他线程中。但注意他并不是安全的，因为该操作不是原子性的。所谓原子性，就是该变量执行如运算等操作只有等它运算完写入主内存中，其他线程才能操作该变量。没错，保证原子性你可以理解为加个锁。

禁止指令重排序

指令重排序指操为了采用流水线机制加快指令的处理速度
重排序分为两类：编译期重排序和运行期重排序，分别对应编译时和运行时环境。重排序的前提是需要满足以下条件

1. 在单线程环境下不能改变程序运行的结果；
2. 存在数据依赖关系的不允许重排序

普通变量仅仅保证在方法执行过程中所有依赖赋值结果的地方能获取正确结果，而不能保证赋值操作和代码执行顺序一样

如何实现

• 在该变量的写操作之前编译器插入一个写屏障
• 在该变量的读操作之前编译器插入一个读屏障

翻译到汇编代码层面 lock addl $0x0,(%esp) 就是将 ESP 寄存器的值加 0，使本 CPU 的 Cache 写入内存，该写入操作会引起别的 CPU 或者别的内核无效化其 Cache。通过该空操作让前面对 volatile 变量的修改对其他 CPU 立即可见。

重排序为了优化，至于禁止重排序，也是将该变量的值强制刷出缓存，将修改同步到主内存，意味着所有之前的操作已经完成，也就达到了无法跨越内存屏障的效果了。这里要仔细体会。

注意点

• volatile 不保证原子性
• 屏蔽指令重排序操作 JDK 1.5 中才被修复，此前不可完全避免重排序

总结

强烈推荐《深入理解 Java 虚拟机》，看目录你会发现那些曾几何时听说过晦涩难懂的名字都会在此书中讲到。

前言

复习的时候就想写了，为自己做点笔记，加深印象理解原理吧。

题目

又一个我敬佩的人 CaoZ 老师分享在知识星球的片段

1. 从你浏览器输入网址，到网页打开。中间都经历了什么。
2. 如果现在有用户反馈你的网站打开很慢，或者说打不开，你考虑的判断和排查步骤是什么，以及为什么。
3. 现在数据库出现了 too many connections 错误，请问排查思路和后续动作是什么。

理解

第一题

乍一看像 DNS 题，定睛一看，还是一道 DNS 题。其实不尽然。说下我看完曹老师文章后的理解。

从输入网址，浏览器会检查域名是否在缓存当中，若是国内第三方“良心”浏览器会触发钩子，会跳转微软搜索页面。然后才是本地 host 文件的判断。这个文件映射的是键值对，在 GFW 没有升高之前，我通过更改 hosts 文件还去看了一下世界。当然那时候也不懂什么 hosts，到后来才慢慢接触了解到。

如若本地客户端仍没有完成解析，就会真正请求域名服务器来解析这个域名。首先从网络配置中获取本地 DNS 解析服务器地址，一般不会离得太远，而且性能极好，能完成 80% 的工作。缓存时间根据 TTL 值控制。

若本地 DNS 仍没有命中，需根据本地 DNS 设置（是否含有转发器进行查询）。如果没有转发模式，直接查找根服务器，要求查找该 URL 中顶级域名服务器（gTLD）。然后依次查找权威 DNS 服务器，例如 github.com 的权威服务器。之所以叫他权威服务器是因为管理着众多二级域名。他将给本地 DNS 服务器返回一个具体的 IP 地址。本地 DNS 服务器将缓存结果的同时发送给客户端。当然有很多权威服务器做了全局均衡代理，权威服务器将返回众多 IP。客户端 DNS 解析器缓存结果并通过随机或者轮询等机制进行访问。

如果用的是转发模式，本地 DNS 则会将请求转发至上一级 DNS 服务器。上一级则会将请求转发上上一级或者寻找根 DNS。

第二题

场景题，虽然还是学生，但是我认为很真实。

首先当然自己打开网站试试喽。如果正常，考虑全国测速，并进行 CDN 全国加速（CDN 部署时个人认为就要加上）。如果慢，一种特殊的情况是 DNS 解析出问题了，直接 IP 访问试试。还可以用 Chrome 开发者工具进行相应的抓包等。

第三题

查看连接池日志，当然我也会优先考虑数据库连接有没有 close 的问题，其次是高并发下出现阻塞，导致大量连接被阻塞。然后再查看数据库相关的连接配置。

参考链接

• what-happens-when
• caoz的梦呓
• mysql-error-too-many-connections

杂谈

2018 年终总结给自己立的每周输出两三篇博客的 flag 快倒了……此篇就当这几天为春招奋战的总结了。

现状

很不幸的是，在今天之前只投了两份简历，一份被拒了，还有一份内推到的笔试。然而这笔试什么玩意，分两场笔试，

一场 30 分钟的逻辑推理。这尼玛真的有病，浪费我感情。我看了几道根本看不出来规律，就开始乱选了。还有一场正规的笔试，没发挥好，也可以说第一次没经验，菜。很多基本的选择题没有复习，点了下一题后还不能改，三道算法题一道没写出来。不过唯一的好处就是，知道了 笔试的形式，也为以后做了准备23333。

笔试之后

当然是倍受打击了，至于能不能像小说主人公那样在后面逆转我就不知道了。

选择

上篇博文提到了希望杯比赛，可能很多人不知道。如果换个名字，挑战杯就会很熟悉了。上回说到，我为了校赛答辩准备很久，也牺牲了一部分准备春招的时间。天真的以为过了校赛答辩就可以松一口气了，但实验室的老师明显是想让我拼一拼从省一进国赛。我提出了接下来我的想法，老师不置可否。。

环境

我当然是想准备春招了，一生只有一次。

指导老师嘛总是忽悠我去努力争取一下省一，还提出了有奖金啊啥的，实习的事可以放一放，暑假的事又不急。

我当时心里一万个 mmp，终于体会到了什么叫做身不由己。首先，我很明确的想过，春招和挑战杯的事情，以春招占大头。因为我想进大厂，甚至想直接转正。这是乌鸡变凤凰的最好时机，而老师却认为暑期小公司实习就差不多了。

其次，跟我说奖金和报销经费。他们竟然认为我是为了钱才去实习的。拜托，搞清楚，这些小钱我根本不放在眼里。你确定 10000 块钱跟阿里、头条等大厂的实习 Offer 比起来算事么？？？我当时就差点甩出一句，现在你给我两万块钱现金，我眉头都不会皱一下地离开去准备春招。

当然上面的话都是我后面的心理活动，并没有在表面上与老师撕破脸皮，只是隐晦的表达我还是要准备面试的意思。但那天我真的很气。气自己没敢说，气老师信息获取滞后。其实，跟我们学院的总体环境有关系。我隐约认为他们根本没有意识到春招秋招的重要性，或者，他们太为自己、学院的名誉着想了，并不在意学生的前途。

理想

上面那些话窝在肚子里很久了，讲出来也舒服点。

最近在网络上发现了不少优秀大佬的博客笔记等

• 左耳朵耗子
  本文文章名也取自他的座右铭。其实，寒假的时候他的博客就在收藏夹里了，也订阅了他的极客专栏。这尼玛简直是程序员的偶像，也是我未来奋斗的目标。
  我一直想把博客做成他那样子，游客点进一篇文章，便被他的作者吸引得浏览全站。随后又发现了更多有意思的文章，就像酒香何必在意巷深那样，越品越有味道。我特别喜欢这种感觉，如若能交流一下交个朋友定是极好的，比如下面这位。
• Kuangcp
  我 GitHub 上唯一关注的人，他的笔记仓库让我叹为观止。

碎碎念

The devil is in the details.

被拒了简历，心情低落…

答辩

本来也没啥，就是整个团队去拿着项目参加比赛，我只是该项目总负责人以及后端开发。但是很不幸的是，团队里考研的考研，划水的划水，也就只剩我去演讲……

那么问题就来了，一写代码的让我分享技术啥的我倒还可以凑活，这尼玛直接介绍项目让我很难受啊……

以上纯属牢骚，有点偏题了，但是在金三银四的黄金校招周中，每分每秒都十分宝贵。然而我还是不敢跟老师明说，不过我已经说明，忙完希望杯就不干活了，就当这几天为以后收利息了吧，虽然付出的代价也挺大的。

细节

我在这立个 flag，能进省赛
答辩时的细节

• 微笑面对评委老师
  不过他们没怎么看我2333
• 在答辩结束后竟然还能询问
  真的是细节，我没有想到。这次比赛主要是给专家看有哪几个项目可以参加省赛的，有指导意义，也是老师不找演讲人的理由。所以，辅导员在结束后带着我们又找了一下三位和蔼可亲的评委老师。虽然已经评完分了，但我认为真的很有必要。

差距

我们学院还有一组是关于图像的科技创新作品，但是在论文学术类以及科技发明类摇摆不定，被评委建议目标应该明确。项目中有几篇是在 SCI （大概是叫这个名字吧，不了解）发表的，但评委说不在二区一文不值。一旦出校在省内比拼，浙大的论文水平绝对碾压我们学校，根本没有可比性。这时，我才意识到学校差距的存在。

我也加了很多内推实习群，当看到那些 985/211 的 ID，感慨竞争对手的强大，绝对不亚于高考。

高考我已经输过一次了，没有人想输第二次。

结语

古代剑客们在与对手狭路相逢时，无论对手有多么强大，就算对方是天下第一剑客，明知不敌，也要亮出自己的宝剑，即使倒在对手的剑下，也虽败尤荣。

杀入春招。

前言

前几天千魂剑问我关于树莓派的问题，好久不用了，感觉有点遗忘，就有了此篇文章。

安装系统

• 官方下载地址
  对是压缩包，所以 Windows 下的 Win32 Disk Imager 可以直接刻录 zip 到 TF 卡

工具推荐

• 读卡器
  虽然 SD 卡也可以，但现在很多电脑没有 SD 卡槽
• 镜像烧录
  • Win
    • Rufus
  • Mac
    买不起，没用过
  • Linux
    • dd 命令

ssh

两种方法，网线，热点，但两者需要在一个局域网内 。
拥有屏幕的用户请路过…

网线

连一根网线到路由器，在路由器后台查看 IP 撒花完结。

热点

其实，树莓派基金会为了达成这个需求， 2017-2018 年逐渐在改善系统来适应这种优雅的方式，所以此方法只适用于新版系统。

1. 打开烧录好的内存卡文件夹
2. 找到 /boot 分区
3. 建立一个空的 ssh 文件以及 wpa_supplicant.conf

   1 2 3 4 5 6 7

   country=GB ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev update_config=1 network={ ssid="你的Wifi名称，注意大小写" psk="你的Wifi密码" }

说明：空的 ssh 文件是为了开启 ssh 服务，系统默认不开启；wpa_supplicant.conf 是为了自动连接热点，ssid 支持中文。开机会将会删除以上两个文件。

raspi-config

默认管理员用户为 pi，密码为 raspberry

• 设置时间
• 将 tf 卡填充满
  默认系统只占很少的空间

镜像源更改

树莓派源分为两种，一种为树莓派基金会提供，另一种由独立开发者提供

• 查询版本号
  lsb_release -a 不一样的版本更改源的地址不一样，版本号有 Stretch、Jessie 等，一般最新的是 Stretch

• 官方源修改
  这个软件源相关资料比较少，修改树莓派基金会单独提供的源

  1	deb https://mirrors.tuna.tsinghua.edu.cn/raspberrypi/ stretch main ui

• 开发源修改

  1 2	deb http://mirrors.tuna.tsinghua.edu.cn/raspbian/raspbian/ stretch main contrib non-free rpi deb-src http://mirrors.tuna.tsinghua.edu.cn/raspbian/raspbian/ stretch main contrib non-free rpi

最后别忘了 sudo apt-get update 更新系统

个人体验

我是拿树莓派当本地服务器的

• 喜欢纯命令行，不喜欢 VNC，而且感觉有点卡顿
• 风扇有点响，据说要买那种悬浮的，然而我是一套
• 散热片、亚克力壳，就是好看
• 不下片的话，8G TF 卡够了

参考链接

• 树莓派—raspbian软件源（全）
• 树莓派如何完全无头(无屏无网线无键盘鼠标)安装

前言

算是 Git 的奇淫怪技

背景

偶然在水群时看到一条消息，有人将服务器密码提交到了 Git 记录上。众所周知，公有仓库的 Git 记录是所有人可见的。所以一旦有敏感信息，不法分子就可以从你的 commit 记录中寻找突破口。

解决

Git 命令行

1
2

git filter-branch --force --index-filter 'git rm --cached --ignore-unmatch sensitive-data.py' --prune-empty --tag-name-filter cat -- --all
git push origin --force –all

这是我谷歌的命令，大概是在 Git 记录中删除带有敏感信息的文件，然后强制 push

BFG

那么有没有更优雅的方法呢，答案是肯定的。

如标题所言，BFG Repo Cleaner 能帮到我们。该工具是用 Scala 写的，专门为清除 Git 提交记录中带有敏感信息而产生的。

使用

需要 Java 7 以上版本

• 安装以及使用
  • 点此下载 jar 包
    java -jar bfg.jar 命令参数
  • yay -S bfg
    bfg 命令参数

如上所示，有两种安装方式，第一种是通用的运行下载的 jar 包，另一种是为 Arch 用户准备的…（这时候就要喊出“Arch 牛逼”）因为我是 Arch 忠实粉丝，所以就以 Arch 中的命令作为示范…

测试

在 GitHub 仓库中创建一个专门来测试的仓库（我学 Git 的时候就已经有一个专门用来测试 Git 的仓库），将密码假装不小心上传到 GitHub。

当发现后，重新将密码去除后重新提交到 GitHub。此时，如果不看 commit 记录就不会知道历史版本，bfg 这个工具就为了防止有心人通过你的 commit 记录捕获你的敏感信息

• 克隆仓库的 .git 文件夹

  1	git clone --mirror git@github.com:yi-yun/git777github-learn.git

• 在本地创建 replace.txt
  文本名字是任意的，文本内容需要将密码填上，默认替换成 ***REMOVED***，也可以将其替换成自己想要的字符，规则如下所示

  1 2 3 4 5

  PASSWORD1 # Replace with '***REMOVED***' (default) PASSWORD2==>examplePass # replace with 'examplePass' instead PASSWORD3==> # replace with the empty string regex:password=\w+==>password= # Replace, using a regex regex:\r(\n)==>$1 # Replace Windows newlines with Unix newlines

• 执行命令
  需要注意两点，一是文本名字与路径，二是相关参数，也可用 --replace-text

  1	bfg -rt ~/replace.txt git777github-learn.git

• 提交更改

  1 2 3

  cd git777github-learn.git git reflog expire --expire=now --all && git gc --prune=now --aggressive git push

拓展

这货还能删除大文件，有需要的童鞋可以参考官网

参考

• 官网
• 清除历史提交记录中的敏感信息
• 不小心把密码上传到 GitHub 了，怎么办