发表于 | 分类于 ，

命令格式

1
2
m      h    dom        mon   dow       command
minute hour dayOfMonth Month dayOfWeek commandToRun

定时任务示例命令

启动任务

1
@reboot root /boot.sh

定时关机

示例

1
0 4   *   *   *    /sbin/shutdown -r +5

Usage

Example add task by Bash

1
2
3
4
5
6
7
#write out current crontab
crontab -l > mycron
#echo new cron into cron file
echo "00 09 * * 1-5 echo hello" >> mycron
#install new cron file
crontab mycron
rm mycron

发表于 | 分类于 ，

bashrc

在~/.bashrc中定义

1
2
3
4
5
6
7
8
9
alias kapply="kubectl apply -f"
alias kdel="kubectl delete -f"
alias ll='ls -al'
alias la='ls -a'
alias gita='git add'
alias gitc='git commit'
alias kexec='kubectl exec -it'
alias kbuild='gcloud builds submit --config'
alias klog='kubectl log -f'

生效命令

1
source ~/.bashrc

Usage

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
alias untar='tar -zxvf '

alias wget='wget -c '

# 生成随机的 20 个字符的密码
alias getpass="openssl rand -base64 20"

# 测试校验文件
alias sha='shasum -a 256 '

alias ping='ping -c 5'

# 想知道你的网络有多快？只需下载 Speedtest-cli 并使用此别名即可。你可以使用 speedtest-cli --list 命令选择离你所在位置更近的服务器。
alias speed='speedtest-cli --server 2406 --simple'

# 你的外部 IP 地址
alias ipe='curl ipinfo.io/ip'

# 本地 IP 地址
alias ipi='ipconfig getifaddr en0'

发表于 | 分类于 ，

At

at 命令的运行方式是在后面紧跟着你想要运行任务的运行时间。

时间格式

  • Minute at now + 5 minutes 任务在5分钟后运行
  • Hour at now + 1 hour 任务在1小时后运行
  • Days at now + 3 days 任务在3天后运行
  • Weeks at now + 2 weeks 任务在两周后运行
  • Fixed at midnight 任务在午夜运行
  • Fixed at 10:30pm 任务在晚上10点30分
  • Fixed at 23:59 12/31/2018　　 任务在2018年12月31号23点59分　

Manjaro需要安装at命令，然后启动atd服务
`

发表于 | 分类于 ，

JOIN

join type

  • (INNER) JOIN: Returns records that have matching values in both tables

  • LEFT (OUTER) JOIN: Return all records from the left table, and the matched records from the right table

  • RIGHT (OUTER) JOIN: Return all records from the right table, and the matched records from the left table

  • FULL (OUTER) JOIN: Return all records when there is a match in either left or right table

Example

  1. 插入另一张表的某个字段
1
2
3
4
SELECT Orders.OrderID, Customers.CustomerName, Orders.OrderDate
FROM Orders
INNER JOIN Customers
ON Orders.CustomerID=Customers.CustomerID;

执行结果

  1. 合并两张表查询结果，并排序
1
2
3
4
5
SELECT * FROM (
SELECT currency_type, amount, status, created_at, updated_at FROM t_deposit_trans
UNION ALL
SELECT currency_type, amount, status, created_at, updated_at FROM t_withdraw_trans
) trans_table ORDER BY trans_table.created_at DESC;

UNION

UNION 操作符用于合并两个或多个 SELECT 语句的结果集。

请注意，UNION内部的 SELECT语句必须拥有相同数量的列。列也必须拥有相似的数据类型。同时，每条SELECT语句中的列的顺序必须相同。

语法

1
2
3
SELECT column_name(s) FROM table_name1
UNION
SELECT column_name(s) FROM table_name2

默认地，UNION 操作符选取不同的值。如果允许重复的值，请使用 UNION ALL。

UNION ALL 命令和 UNION 命令几乎是等效的，不过 UNION ALL 命令会列出所有的值。

Example

  1. 合并两个表查询结果
1
2
3
SELECT currency, amount, status, created_at, updated_at FROM deposit
UNION
SELECT currency, amount, status, created_at, updated_at FROM withdraw;

注意，这里不能使用order by

  1. 合并结果，并排序
1
2
3
4
SELECT currency, amount, status, created_at, updated_at FROM deposit
UNION ALL
SELECT currency, amount, status, created_at, updated_at FROM withdraw
ORDER BY created_at DESC;

发表于 | 分类于 ，

LV.1 技术管理入门

技术管理者要不要一直精通技术？

这里面的“精通”是一个词，也是两个词。

  • 精就是说，你事无巨细，很多的事情你会在第一时间知道它所有的细节；
  • 通的意思就是你可能从一个比较高的层次，知道它的脉络，知道它的来龙去脉，但是你不一定非要知道很多的细节。

随着你从技术人往管理人方向转的时候，在通的方面，你可能会有一些提升，因为你不是一个人去做，而是同时带领着一个小的团队去做，或者甚至是中等、大团队。这样你接触的东西更多，你会把更多的点连通到一起，所以从通的方面来说，你可能会有一定的精进。

但是从精这个方面，因为毕竟人的能力、精力和时间是有限的。当你把很大一部分的时间放在管理上，你就没有那么多时间自己去写代码，去针对一点点细节去啃。所以，在精这一方面，你肯定是会有所折中及退化的。

因此，精通还是会精通，但是可能会随着从技术转管理的过渡，精会降低，通会提高。

额外补充：工程师的工作量会类似于一个小山坡这样的梯度。

  • 初始阶段，有很多设计、产品之间的多分迭代过程，在这个过程中，很多时候没有太多的代码及技术可做，因为很多东西还未敲定。
  • 在最后敲定阶段，你就会进入一个开发高峰期，就是你有大量的代码要写。
  • 写完了到后期，开始慢慢的一点一点的，应该叫Run out，一点一点开始做测试的时候，你的代码量又开始降低。

对每一位程序员或者工程师来说，你在某一段时间有更多的工作，某一段时间会轻松一点。每个人可以根据自己的节奏调整。

一个人从单打独斗到带领小团队，甚至更大团队，如何转变？

对于做技术的人来说，做技术比做管理的时间要长得多，那对我来说，单打独斗的时候反而是完全由着自己的心去做一些特别喜欢，所有的事情
都在你自己的控制之中。等你转到管理，带两到三个人的时候，这个过程也是非常好的。因为很多时候你可以去帮助别人，大家一起把这件事情
做完。

但是其中会遇到一个比较难过的坎，很多时候还是什么东西都想着自己亲手去做，比如说我带那两三个人里面，如果他是个新人，或者说他在某一方面的技术对他来说还是比较新的话，我会忍不住，想冲上去自己把这件事情做了算了。因为你教别人把这件事情做到你满意的程度，可能要三天，但你自己动手，可能只要三个小时。

所以，在最初转管理的时候，很多时候，你就不想花那个时间，你就非常抑制不住冲动要冲上去自己做。但是，一个人的时间和精力有限，不可能有时间自己全做了，而且到了一定的程度，你就不可能做更大、更多的事。

对你周围的人来说，自己冲上去做，对他们的帮助和成长是比较小的。

从三、四人团队到十几人团队

这就又面临一个完全不同的挑战。虽然在带领三、四人的时候，你可能已经学会放权，把事情分配给这三、四个人做。但等有这么多人的时候，你不可能事无巨细，每件事都自己去管，所以，另外一个挑战就是，要带一些能成为你左右手的小伙伴，让他们去承担一部分事情，就COPY 你之前带领三、四人那样。这样操作，你还是能保持之前带着三、四人的状态。

最好的管理，是一个人带三到六个人，超过这个人数，很难说真的能花很多的时间在团队上。

要带一个不算大也不算小的团队，这时候你可能是技术最精通的，很多人遇到问题都会来找你，这时候你会成为团队发展的瓶颈。去放权，慢慢把自己很多东西输出给团队，帮助团队成长。你的团队成长了，整个公司也好，个人也会更好，才能做更大的事情，这是一个良性的正向循环。

当你到研发总监，或者技术总监这个层次，可能会更多的偏向这种产品和业务，要去研究怎么通过技术更好得促进产品和业务的发展，这样你的精力就不会是在精通技术上。还有更胜者，在规划产品、做业务，就是看怎么能够让公司的产品成长的更好。

技术转管理碰到的坑

  1. 一个就是当你带到的人比较少的时候，你要学会放权，怎么样让别人跟你一起做，而不是说你比别人做得快，你就帮他做了，甚至哪怕你比
    别人快个几倍。

  2. 当你开始带大团队的时候，如果你不开始 培养一些得力助手，帮着你去带人，你会变得非常的累。

  3. 对一个人的评判经常会变成静态的，就是说你觉得这个人这一方面的能力不行，或者在那个方面有欠缺，就会导致你在下一次分配工作的时候，你会比较、担忧，把这些工作分给他是否能做好？每个人都是在成长的，就是说你不要用一个固定的眼光去看待别人。一方面，每个人都是需要犯错空间的，哪怕他上次犯了这样一个错，导致这件事情没有做好，如果你给他足够的帮助，下一次他还是有可能能做成，甚至做的更好。

一本书叫《特鲁夫给经理人的第一节课》，里面有说到，其实不管是大公司还是小公司，一个工程师、技术人、产品人，做不好事情只有两个原因，一是他不会做，二是他没有动力不想做。

作为管理人，一方面，就需要你给与他一个机会或者带着他做，教会他这样的本领，可能现在他不会，下次就会了。如果他是因为不想做，或者没有激情做，那作为管理者，则需要激励他，让他更有动力把事情做成做好。完成这个是需要两个方面努力的，一是你要有动态的眼光，二是你要去做一些支持和帮助，帮助员工成功，往成长的方向去引导。

  1. 我是一个技术 Leader，我也愿意授权，事实上我也授权了，但最后发现团队并没有把事情做好。安姐是怎么看？或者怎么去处理？

  • 如果你交给别人，别人没有做好，可能是他不会做，可能是他没有这个动力去做，你是不是在授权之前就确保这两个问题都已经解决掉了？

  • 有没有给他激励机制、奖励？惩罚，我们很少用。

  • 是否有一些外在不可控因素，进度受到阻碍。

首先作为放权的人，自己要去反思，到底是哪个方面让这个人没有达到预期目标。你放权之后，要给到他所有的支持，这个支持就包括他遇到这些他不可控因素的时候，你是不是可以帮他去排除这些障碍。

从另外一个角度，在放权的过程，不是说这事我交给你了，我就不管了，而是说因人而异，因事而异。你要清楚他的背景是什么，能力怎样，
可能欠缺什么，你要给他哪些帮助，需要制订一个计划，然后一个星期或者两个星期去跟进，看看他是不是按照你的进度在进行。

因事而异，这件事情是不是有给他犯错的空间，可能有的任务非常关键，是绝对不允许出错的，这个时候你更需要自己手把手去带，更紧密稿频次跟进。因人而异，因事而异，外加紧密跟进。

放权，不代表就不管不问了。

我还想补充一点，你要跟对方有一个双向的、非常开放的交流，不仅是你从上往下地下达你想要的意愿，你想要的结果，同时，你也要鼓励他，在他遇到问题、有任何的想法，甚至是置疑你这个方向对不对的时候，给他空间和机会去表达他的想法。

双向交流，可极大程度地降低犯错成本。

技术管理者应该具备什么样的素质？

  1. 硬性

硬性素质，就是大家经常技术功底要扎实，这样才能帮助团队做出比较正确的选择，或者在他们有困难的时候，你能够第一时间了解所有的情况，做出正确的判断。

  1. 软性

要有较强的沟通能力，要有高一点的情商。

作为技术人员更重要的素质，第一个是责任心，因为管理，尤其是技术管理的时候，你管理的不仅是技术，还有做技术的这些小伙伴。责任心就显得很重要：

  • 一是要把事做好
  • 二是要把人带好。

技术人更擅长把事情做好，但把人带好，不是你自己成长，项目做好就够了，更要关注别人的成长。这些都基于你有一份责任心。

第二就是开放的心态。不要觉得什么事情你都懂，懂的最多。很多时候人都会犯错，尤其是在你自己都不能意识到的地方。因为你的性格、背景、认知会有一些偏见，不一定什么时候你都是对的。那保持一个开放的心态，去倾听别人的意见，愿意接受自己就是随时都有可能犯错的情况。这也是一个很重要的事情。

作为一个技术人，如果一个程序写错了，或者说是一件事情做错了，那还是有挽回的余地。但提建议或者指出错误，方法不得到的话，可能对别人就是一个永恒的伤害。因为，你在处理的不是一个技术，不是一个能改的Bug，而是人。作为管理者，要有这样一颗心，愿意去给对方最好的支持，然后倾听，帮助对方。

发表于 | 分类于

Singleton

单例就是所有的请求都用一个对象来处理，比如我们常用的service和dao层的对象通常都是单例的，而多例则指每个请求用一个新的对象来处理，比如action;

之所以用单例，是因为没必要每个请求都新建一个对象，这样子既浪费CPU又浪费内存；

之所以用多例，是为了防止并发问题；即一个请求改变了对象的状态，此时对象又处理另一个请求，而之前请求对对象状态的改变导致了对象对另一个请求做了错误的处理；

@Autowired

默认情况下，创建的是单例对象。如果需要多例模式，则使用scope=”prototype”。

发表于 | 分类于 ，

为知笔记CORS

1
2
response.setHeader("Access-Control-Allow-Origin", "*")
response.setHeader("Access-Control-Allow-Methods", "POST,GET,DELETE,PUT,OPTIONS")

发表于 | 分类于

进程 vs 线程

进程(process) 与 线程(thread) 最大的区别是进程拥有自己的地址空间，某进程内的线程对于其他进程不可见，即进程A不能通过传地址的方式直接读写进程B的存储区域。进程之间的通信需要通过进程间通信(Inter-process communication，IPC)。与之相对的，同一进程的各线程间之间可以直接通过传递地址或全局变量的方式传递信息。

此外，进程作为操作系统中拥有资源和独立调度的基本单位，可以拥有多个线程。通常操作系统中运行的一个程序就对应一个进程。在同一进程中，线程的切换不会引起进程切换。在不同进程中进行线程切换，如从一个进程内的线程切换到另一个进程中的线程时，会引起进程切换。相比进程切换，线程切换的开销要小很多。线程于进程相互结合能够提高系统的运行效率。

从概念上来说：

  • 进程：一个程序对一个数据集的动态执行过程，是分配资源的基本单位。
  • 线程：一个进程内的基本调度单位。一个进程包含一个或者多个线程。

Thread Category

线程可以分为两类：

  1. 用户级线程(user level thread)
  2. 内核级线程(kernel level thread)

用户级线程(user level thread)
对于这类线程，有关线程管理的所有工作都由应用程序完成，内核意识不到线程的存在。在应用程序启动后，操作系统分配给该程序一个进程号，以及其对应的内存空间等资源。应用程序通常先在一个线程中运行，该线程被成为主线“程。在其运行的某个时刻，可以通过调用线程库中的函数创建一个在相同进程中运行的新线程。 用户级线程的好处是非常高效，不需要进入内核空间，但并发效率不高。

内核级线程(kernel level thread)
对于这类线程，有关线程管理的所有工作由内核完成，应用程序没有进行线程管理的代码，只能调用内核线程的接口。内核维护进程及其内部的每个线程，调度也由内核基于线程架构完成。内核级线程的好处是，内核可以将不同线程更好地分配到不同的CPU，以实现真正的并行计算。

事实上，在现代操作系统中，往往使用组合方式实现多线程，即线程创建完全在用户空间中完成，并且一个应用程序中的多个用户级线程被映射到一些内核级线程上，相当于是一种折中方案。

什么是守护线程(daemon thread)？

守护线程是运行在后台的一种特殊进程，它独立于控制终端，并且周期性地执行某种任务或着等待处理某些发生的事件。也就是在程序运行的时候在后台提供一种通用服务的线程。

daemon是相于user线程而言的，可以理解为一种运行在后台的服务线程，比如时钟处理线程、idle线程、垃圾回收线程等都是daemon线程。

daemon线程有个特点就是”比较次要”，程序中如果所有的user线程都结束了，那这个程序本身就结束了，不管daemon是否结束。而user线程就不是这样，只要还有一个user线程存在，程序就不会退出。

在Java中java.lang.Thread.isDaemon()方法用来测试线程是否为守护线程

1
public final boolean isDaemon() //  if return true, the thread is daemon thread

注意：

  1. Thread.Daemon(true) 必须在Thread.start()方法之前设置，否则会出现IllegalThreadStateException异常
  2. 不能把正在运行的常规线程设置为守护线程
  3. 守护线程应该永远不去访问固有资源，如：数据库、文件等。因为它会在任何时候甚至在一个操作的中间发生中断。

Context Switch

对于单核单线程CPU而言，在某一时刻只能执行一条CPU指令。上下文切换(Context Switch)是一种将CPU资源从一个进程分配给另一个进程的机制。从用户角度看，计算机能够并行运行多个进程，这恰恰是操作系统通过快速上下文切换造成的结果。在切换的过程中，操作系统需要先存储当前进程的状态(包括内存空间的指针，当前执行完的指令等等)，再读入下一个进程的状态，然后执行此进程。

Semaphore / Mutex

当用户创立多个线程／进程时，如果不同线程／进程同时读写相同的内容，则可能造成读写错误，或者数据不一致。此时，需要通过加锁的方式，控制核心区域(critical section)的访问权限。对于semaphore而言，在初始化变量的时候可以控制允许多少个线程／进程同时访问一个critical section，其他的线程／进程会被堵塞，直到有人解锁。

Mutex相当于只允许一个线程／进程访问的semaphore。此外，根据实际需要，人们还实现了一种读写锁(read-write lock)，它允许同时存在多个阅读者(reader)，但任何时候至多只有一个写者(writer)，且不能于读者共存。

Deadlock

死锁是指两个或多个线程／进程之间相互阻塞，以至于任何一个都不能继续运行，因此也不能解锁其他线程／进程。例如，线程A占有lock A，并且尝试获取lock B；而线程2占有lock B，尝试获取lock A。此时，两者相互阻塞，都无法继续运行。

总结产生死锁的四个条件(只有当四个条件同时满足时才会产生死锁)：

  1. Mutual Exclusion – Only one process may use a resource at a time
  2. Hold-and-Wait – Process holds resource while waiting for another
  3. No Preemption – Can’t take a resource away from a process
  4. Circular Wait – The waiting processes form a cycle

How to solve deadlock?

  1. 检测死锁并且恢复。
  2. 仔细地对资源进行动态分配，以避免死锁。
  3. 通过破除死锁四个必要条件之一，来防止死锁产生

在 MySQL 中是如何处理死锁？

Producer-Consumer

场景说明：

  • 有一个或多个生产者生产某种数据，生产的数据放在某个缓冲区；
  • 有一个消费者从缓冲区读取数据，每次只能取一项；
  • 系统负责保证在任何时候只有一个主体(生产者或消费者)可以访问缓冲区。
  • 当缓冲区已满时，生产者不会继续向缓冲区添加数据；当缓冲区为空时，消费者不会继续从缓冲区读取数据；

IPC - Inter-Process-Communication

一个进程不能直接读写另一个进程的数据，两者之间的通信需要通过进程间通信(inter-process communication, IPC)进行。进程通信的方式通常遵从生产者消费者模型，需要实现数据交换和同步两大功能。

  • Shared-memory + semaphore: 不同进程通过读写操作系统中特殊的共享内存进行数据交换，进程之间用semaphore实现同步。
  • Message passing: 进程在操作系统内部注册一个port，并且监测有没有数据，其他进程直接写数据到该port。该通信方式更加接近于网络通信方式。事实上，网络通信也是一种IPC，只是进程分布在不同机器上而已。

实现方式：

  1. 管道(pipe)：管道是单向的、先进先出的、无结构的、固定大小的字节流，它把一个进程的标准输出和另一个进程的标准输入连接在一起。
  2. 信号(signal)：信号是一种比较复杂的通信方式，用于通知接收进程某个事件已经发生。
  3. 信号量(semaphore)：信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其它进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。
  4. 消息队列(message-queu)：消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。
  5. 共享内存(shared-memory)：共享内存就是映射一段能被其它进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的IPC方式，它是针对其它进程间通信方式运行效率低而专门设计的。它往往与其它通信机制（如信号量）配合使用，来实现进程间的同步和通信。
  6. 套接字(socket)：套接字也是一种进程间通信机制，与其它通信机制不同的是，它可用于不同机器间的进程通信。

Pipe

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
fun main() {
    val inputPipe = PipedInputStream()
    val outputPipe = PipedOutputStream()
    outputPipe.connect(inputPipe)

    thread {
        /*  Input   */
        while (true) {
            val read = inputPipe.read()
            println("read is $read")
        }
    }

    thread {
        /*  Output  */
        var writeData = 0
        while (true) {
            writeData += 1
            outputPipe.write(writeData)
            println("write is $writeData")
            Thread.sleep(500)
        }
    }

    while (true) {
        Thread.yield()
    }
}

// write is 1
// write is 2
// read is 1
// read is 2
// write is 3
// write is 4
// read is 3
// read is 4

Semaphore

What is Semaphore?

Semaphore acts as a permit. The thread that wants access to the shared resource tries to acquire a permit. If the semaphore’s count is greater than zero, then the thread is able to get a permit. Once a thread gets the permit, the semaphore’s count decrements. Otherwise, the thread will be blocked until a permit can be acquired.

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
fun main() {
    val semaphore = Semaphore(0, true)

    thread {
        try {
            while (true) {
                Thread.sleep(1500)
                println("Producer --> ${System.currentTimeMillis()}")
                semaphore.release()
            }
        } finally {
        }
    }

    thread {
        try {
            while (true) {
                semaphore.acquire()
                println("Consumer --> ${System.currentTimeMillis()}")
            }
        } finally {
        }
    }

    while (true) Thread.yield()
}

Reference