虽然时间线拉的比较长，《Getting things done》 总算是看完了。

看完 GTD 之后对 GTD 理论有了更进一步的理解，通过通读，更加清晰了 GTD 四步法：收集，清理，组织，回顾，也明确的四步法与执行的关系，并顺便根据自己的理解将 GTD 这一套理论简化为 4 个原则，以方便执行和安利。

四步法与执行

曾经在知乎看到有人反对在不了解时间管理的情况下直接实践 GTD，而更是推荐番茄工作法之类简单的理论。在看完 GTD 这本书之后对这个观点有些认可，GTD 的执行需要形成一大堆习惯，而作者更是在书中坦言，将 GTD 完全接受并融入自己生活中，可能需要大约两年的摸索。 因此，在正式实践 GTD 之前请确定自己有改变生活的决心与坚持的勇气。

收集

GTD 的启动是从收集开始的，一切事情皆在被收集的清单内（没看错，是一切事物）。书中认为第一次收集一般花费 3-6 个小时，需要将一切事物，桌子上的、抽屉里的、角落里的，所有的东西都放在收集篮，而是只是单纯的放进收集篮子，并不做任何处理，处理这个工作放在后面。

而收集这个动作自 GTD 实践开始，就不会停止，而且实时进行，任何的灵光一闪，任何的想到的事情，都需要收集起来。

我恰好是在工作最混乱的时候启用 GTD 的（17 年 9 月左右），当时并没有完全理解 GTD，而是比着葫芦画瓢，将所有想做的事情扔到收件箱里，并每次做事情的时候从收件箱找找能做的事情。

这是一种非常糟糕的实践，但是却有用，因为我知道我所有要做的事情，开会确定的效果，吃饭时想到的新实现，洗澡时想到的潜在 bug，全在收件箱里，我不怕遗漏，我信任这个系统，因此不会像无头苍蝇不知出路与莫名烦躁。

收集的意义就在于把所有突然想到的事情记录下来，让这件事情在变成事故前完成，这样就可以大量减少救火的情况，而且一个良好的收集系统会让人产生安全感，我可以依赖这个系统，不怕自己遗忘，就像一个外脑。

清理

在收集的时候避免任何进一步思考和执行，而是把思考的阶段放在清理阶段。

清理阶段非常简单，就是把收集阶段的东西进行清理与梳理，当处理一件事情时，可以采取以下的选择：

1. 该事情没啥意义：扔到垃圾箱
2. 该事情两分钟内就能做完：立马去做
3. 该事情两分钟内做不完：推迟、委托他人

要明白为什么这样选择首先要明白两点：

1. 清理是什么
2. 两分钟原则

清理是什么？收件箱其实就是一个未处理清单，一堆从没有思考过是什么，怎么做，目标是什么的三无任务清单，清理就是将这堆任务想清楚，要不要做，要做成什么样子，要怎么做，并把收件箱清空。

因此，对于没有意义的事情，应该立即丢弃，而把有用的保留下来。不能让 GTD 系统中存在任何垃圾，毕竟垃圾越多意味着越低效。

两分钟原则是清理阶段的执行方式，如果一件事两分钟就可以解决，那就不要让这件事流入后面的处理阶段，因为一件事在 GTD 中经过的阶段越长，这件事的执行效率越低，一般一件事从收集后，经过清理，组织，回顾需要 3 分钟，而这件事本身不过两分钟就可以完成，那么把这件事在清理阶段就完成的，不要再拖延了。

我曾经疑惑为什么超过两分钟的事情就要 delay 呢？因为 清理 本身就是一件事情，如果在清理的时候就执行非常耗时的任务，就会中断清理，从而进入了不同从收件箱拿任务执行的恶性循环，从而让收件箱里的垃圾越来越多，最后放弃 GTD。因此我们要确保清理这件事情本身能成功完成，而耗时任务以后再说，哪怕是等清理完之后再说。

清理是对事情初步思考的环节，将收件箱里的垃圾丢掉，简单的事情完成，复杂的事情简单思考，那么剩下的事情，就是那些需要好好思考的任务了，而这些任务可以流入下一个环节。

组织

无论是小到写篇关于 GTD 的博客，还是大到计划买一套房，无论是今天下午就要着手做的事情，还是未来两年内完成的事情，只要这件事又完成的意义，就会流入组织环节。

虽然书中使用了 “组织” 一词，不过我认为 “梳理” 更适合。因为组织是在做两件事情：

1. 梳理清单，分门别类
2. 梳理任务，想清楚怎么执行

如果这件事近期不需要执行，而且你也不知道什么时候会执行，比如要看到书单，要学一门外语，那么可以把这件事放到 “也许、将来” 清单。如果这些事情需要在家完成，那么可以将这件事归到 “在家” 清单。将事情分门别类，可以方便下一步的执行，比如在家的时候，可以看一下 “在家” 这个清单，而书荒的时候，可以去翻翻看 “也许、将来” 里的书单。

清单的分类一般按照地点或客观条件，比如 “公司”、“在家”、“杂货店”、“需要电脑”，也可能会依赖某个人：“老板”，“女朋友”。这些都可以成为清单的梳理规则，考虑到清单是执行和回顾的依据，可以怎么有利于执行和回顾怎么分类。

除了梳理清单，还有把 “任务” 变为 “项目”，任务指的是我们在收件箱收集的事项，比如：“在卧室中安装空气净化器”。而这种任务完全没有可执行力，因此我们需要 “梳理任务”，想清楚下一步怎么做，比如：“调研有哪些空气净化器性价比高”。

回顾

如果一件事被收集到了 GTD 系统，而这个体系并没有经常更新，从而出现了遗忘的事项，那么你就不会再信任这个系统，从而又一次放弃 GTD。

因此，当一件件事被收集、清理、组织之后，会产生一个又一个的清单，如果清单没有被更新，这就和我们把要做的随手一记一样，并没有实质改观。因此我们需要定期回顾清单，比如曾经记下：“学习日语”，那么在回顾的时候你会又想起这件事情，说不定这次你就会考虑下怎么去做。

而有的项目因为没有更新，可能已经没有了执行的必要，或者有新的步骤需要添加，这时候在回顾环节可以更新这些项目。

回顾是更新整个系统的重要一环，也是防止整个系统不会落后于现实的保险。而作者建议在最后一个工作日拿出下班前的一到两个小时来回顾，以防止遗忘当周没有完成的事项。

执行

这里的执行分两种，一个是 GTD 整个流程的执行和 GTD 中托管的任务的执行。

GTD 四步走包括：收集，清理，组织，回顾。其中收集是无时无刻执行的，只要想起来就可以向收件箱中添加一项，因为有手机等移动设备，其实只要养成习惯，基本就没有耗时的感觉。而回顾是定期执行的，比如周五下班前，那么我们只需要设定一个闹钟或者提醒事项，提前预留出时间，或者稍微加一下班，也能让这个环节执行完。而 GTD 比较麻烦就是清理和组织。

清理和组织环节是比较消耗时间和脑力的，我们要把事情想清楚并归类，甚至还要想清楚下一步怎么执行，作者说他一般是在出差路上完成的，对于长期出差的商务人士，当然是个不错的选择。而对于打工仔，我一般是在饭间完成的，我更建议能经常拿出时间来清理和组织，尤其是组织，因为组织环节会梳理好下一步清单，而再次审视要执行的下一步清单，往往会产生改进，并获得更优的下一步行动列表。不过要注意的是，这两个环节需要脑力，在不清醒的时候并不适合这样的行动。

在执行任务上，人和计算机最大的不同点是人非常不擅长进程（正在执行的事情）切换，如果有新的事情插进来，往往会花很多事情来回忆（已经完成了啥）和思考（现在要做啥），就和每个进程都有一个上下文一样，任何任务也同样需要整个上下文，而 GTD 的下一步列表其实就是充当上下文的记录的作用。

因此，对于事情的事情就是在下一步清单中找到可以做的事情，并完成它，在执行的时候不应该产生 “我该怎么做”，“我已经做了啥” 这样的疑问，如果有的话可能还需要反省 GTD 的实践。

任务的时间点

在 GTD 中好像没有提到 “每日任务” 这样带有时间点的任务，因为在 GTD 中不建议，或者说反对设定每日任务，因为生活充满变数，人们经常完不成每日任务，而在多次把 “今日完成” 移动到 “明日完成” 之后，人们就会对这个日常管理系统失望并不再信任。

GTD 中认为一件事情分为两种：

1. ASAP（As Soon As Possible，越快越好）的任务
2. 有时间点的任务

第一类任务比如：“写一篇博客”，第二类比如：“明天 9 点预约了牙医”。

而 GTD 的下一步清单维护的其实只是第一种，而第二种才应该放在日程表中，这样就可以在指定日期提醒自己这件事在今天必须要做。而且日程表中的任务是比下一步清单中的任务要高的。

GTD 原则

GTD 是一套复杂的实践，我在尝试把它简化（方便执行和安利给别人），总结为：收集习惯、下一步清单、关注结果、定期回顾四个原则。

收集习惯

收集事无巨细，应该养成一种习惯，任何灵光一闪，或者将要提醒自己的事情，都要被收集。

下一步清单

收集的事情要被清理和整理，我们要明确每件事的下一步是什么，并总结出下一步清单，而剩下的就是无脑执行下一步清单里的内容。

关注结果

所有的事情都是可量化的，我们要想清楚这件事我们的目标是什么，想要达成的结果是什么，只有下一步可量化，我们才有执行和推进事情的依据。

定期回顾

定期回顾是保证 GTD 系统是最新有效的保险，定期的回顾非常重要，更新过去的想法，添加新的想法。

总结

作者在最后提到，很多人认为如此繁琐的步骤是浪费时间，只是让行动的效率变得更低下。那是因为还没完全依赖这个系统，毕竟如果考虑到全盘依赖大脑时，每次切换事情都要思考：“我之前做了啥”，“我现在应该做啥”，“我要做到什么程度” 所消耗的时间其实是更多的。

GTD 的一些思想在软件行业好像已经有了广泛应用，这一套收集、清理、组织、回顾，如果我们把 “task” 这个词换为 “user story”，把清单换成泳道是不是仿佛很熟悉。

无论是个人，还是团队，时间管理其实并不能获得更多时间，相反会消耗时间在管理本身上，但这道流程的存在，能防止事情失控，一切尽在掌控之中。

---

附图一张，在星巴克写了一下午，写完才发现被冷风吹的手脚冰凉。

这篇文章将讲解 Python 并发编程的基本操作。并发和并行是对孪生兄弟，概念经常混淆。并发是指能够多任务处理，并行则是是能够同时多任务处理。Erlang 之父 Joe Armstrong 有一张非常有趣的图说明这两个概念：

我个人更喜欢的一种说法是：并发是宏观并行而微观串行。

GIL

虽然 Python 自带了很好的类库支持多线程/进程编程，但众所周知，因为 GIL 的存在，Python 很难做好真正的并行。

GIL 指全局解释器锁，对于 GIL 的介绍：

全局解释器锁（英语：Global Interpreter Lock，缩写GIL），是计算机程序设计语言解释器用于同步线程的一种机制，它使得任何时刻仅有一个线程在执行。
- 维基百科

其实与其说 GIL 是 Python 解释器的限制，不如说是 CPython 的限制，因为 Python 为了保障性能，底层大多使用 C 实现的，而 CPython 的内存管理并不是线程安全的，为了保障整体的线程安全，解释器便禁止多线程的并行执行。

因为 Python 社区认为操作系统的线程调度已经非常成熟了，没有必要自己再实现一遍，因此 Python 的线程切换基本是依赖操作系统，在实际的使用中，对于单核 CPU，GIL 并没有太大的影响，但对于多核 CPU 却引入了线程颠簸（thrashing）问题。

线程颠簸是指作为单一资源的 GIL 锁，在被多核心竞争强占时资源额外消耗的现象。

比如下图，线程1 在释放 GIL 锁后，操作系统唤醒了 线程2，并将 线程2 分配给 核心2 执行，但是如果此时 线程2 却没有成功获得 GIL 锁，只能再次被挂起。此时切换线程、切换上下文的资源都将白白浪费。

因此，Python 多线程程序在多核 CPU 机器下的性能不一定比单核高。那么如果是计算密集型的程序，一般还是考虑用 C 重写关键部分，或者使用多进程避开 GIL。

多线程

在 Python 中使用多线程，有 thread 和 threading 可供原则，thread 提供了低级别的、原始的线程以及一个简单的锁，因为 thread 过于简陋，线程管理容易出现人为失误，因此官方更建议使用 threading，而 threading 也不过是对 thread 的封装和补充。（Python3 中 thread 被改名为 _thread）。

在 Python 中创建线程非常简单：

import time
import threading


def do_task(task_name):
    print("Get task: {}".format(task_name))
    time.sleep(1)
    print("Finish task: {}".format(task_name))


if __name__ == "__main__":
    tasks = []
    for i in range(0, 10):
        # 创建 task
        tasks.append(threading.Thread(
            target=do_task,
            args=("task_{}".format(i),)))
    for t in tasks:
        # 开始执行 task
        t.start()

    for t in tasks:
        # 等待 task 执行完毕
        # 完毕前会阻塞住主线程
        t.join()
    print("Finish.")

直接创建线程简单优雅，如果逻辑复杂，也可以通过继承 Thread 基类完成多线程：

import time
import threading


class MyTask(threading.Thread):
    def __init__(self, task_name):
        super(MyTask, self).__init__()
        self.task_name = task_name

    def run(self):
        print("Get task: {}".format(self.task_name))
        time.sleep(1)
        print("Finish task: {}".format(self.task_name))


if __name__ == "__main__":
    tasks = []
    for i in range(0, 10):
        # 创建 task
        tasks.append(MyTask("task_{}".format(i)))
    for t in tasks:
        # 开始执行 task
        t.start()

    for t in tasks:
        # 等待 task 执行完毕
        # 完毕前会阻塞住主线程
        t.join()
    print("Finish.")

多进程

在 Python 中，可以使用 multiprocessing 库来实现多进程编程，和多线程一样，有两种方法可以使用多进程编程。

直接创建进程：

import time
import random
import multiprocessing


def do_something(task_name):
    print("Get task: {}".format(task_name))
    time.sleep(random.randint(1, 5))
    print("Finish task: {}".format(task_name))


if __name__ == "__main__":
    tasks = []
    for i in range(0, 10):
        # 创建 task
        tasks.append(multiprocessing.Process(
            target=do_something,
            args=("task_{}".format(i),)))
    for t in tasks:
        # 开始执行 task
        t.start()

    for t in tasks:
        # 等待 task 执行完毕
        # 完毕前会阻塞住主线程
        t.join()
    print("Finish.")

继承进程父类：

import time
import random
import multiprocessing


class MyTask(multiprocessing.Process):
    def __init__(self, task_name):
        super(MyTask, self).__init__()
        self.task_name = task_name

    def run(self):
        print("Get task: {}".format(self.task_name))
        time.sleep(random.randint(1, 5))
        print("Finish task: {}".format(self.task_name))


if __name__ == "__main__":
    tasks = []
    for i in range(0, 10):
        # 创建 task
        tasks.append(MyTask("task_{}".format(i)))
    for t in tasks:
        # 开始执行 task
        t.start()

    for t in tasks:
        # 等待 task 执行完毕
        # 完毕前会阻塞住主线程
        t.join()
    print("Finish.")

multiprocessing 除了常用的多进程编程外，我认为它最大的意义在于提供了一套规范，在该库下有一个 dummy 模块，即 multiprocessing.dummy，里面对 threading 进行封装，提供了和 multiprocessing 相同 API 的线程实现，换句话说，class::multiprocessing.Process 提供的是进程任务类，而 class::multiprocessing.dummy.Process，也正是有 multiprocessing.dummy 的存在，可以快速的讲一个多进程程序改为多线程：

import time
import random
from multiprocessing.dummy import Process


class MyTask(Process):
    def __init__(self, task_name):
        super(MyTask, self).__init__()
        self.task_name = task_name

    def run(self):
        print("Get task: {}".format(self.task_name))
        time.sleep(random.randint(1, 5))
        print("Finish task: {}".format(self.task_name))


if __name__ == "__main__":
    tasks = []
    for i in range(0, 10):
        # 创建 task
        tasks.append(MyTask("task_{}".format(i)))
    for t in tasks:
        # 开始执行 task
        t.start()

    for t in tasks:
        # 等待 task 执行完毕
        # 完毕前会阻塞住主线程
        t.join()
    print("Finish.")

无论是多线程还是多进程编程，这也是我一般会选择 multiprocessing 的原因。

除了直接创建进程，还可以用进程池（或者 multiprocessing.dummy 里的进程池）：

import time
import random
from multiprocessing import Pool


def do_task(task_name):
    print("Get task: {}".format(task_name))
    time.sleep(random.randint(1, 5))
    print("Finish task: {}".format(task_name))


if __name__ == "__main__":
    pool = Pool(5)
    for i in range(0, 10):
        #     创建 task
        pool.apply_async(do_task, ("task_{}".format(i),))
    pool.close()
    pool.join()
    print("Finish.")

线程池：

import time
import random
from multiprocessing.dummy import Pool


def do_task(task_name):
    print("Get task: {}".format(task_name))
    time.sleep(random.randint(1, 5))
    print("Finish task: {}".format(task_name))


if __name__ == "__main__":
    pool = Pool(5)
    for i in range(0, 10):
        #     创建 task
        pool.apply_async(do_task, ("task_{}".format(i),))
    pool.close()
    pool.join()
    print("Finish.")

这里示例有个问题，pool 在 join 前需要 close 掉，否则就会抛出异常，不过 Python 之禅的作者 Tim Peters 给出解释：

As to Pool.close(), you should call that when - and only when - you're never going to submit more work to the Pool instance. So Pool.close() is typically called when the parallelizable part of your main program is finished. Then the worker processes will terminate when all work already assigned has completed.

It's also excellent practice to call Pool.join() to wait for the worker processes to terminate. Among other reasons, there's often no good way to report exceptions in parallelized code (exceptions occur in a context only vaguely related to what your main program is doing), and Pool.join() provides a synchronization point that can report some exceptions that occurred in worker processes that you'd otherwise never see.

同步原语

在多进程编程中，因为进程间的资源隔离，不需要考虑内存的线程安全问题，而在多线程编程中便需要同步原语来保存线程安全，因为 Python 是一门简单的语言，很多操作都是封装的操作系统 API，因此支持的同步原语蛮全，但这里只写两种常见的同步原语：锁和信号量。

通过使用锁可以用来保护一段内存空间，而信号量可以被多个线程共享。

在 threading 中可以看到 Lock 锁和 RLock 重用锁两种锁，区别如名。这两种锁都只能被一个线程拥有，第一种锁只能被获得一次，而重用锁可以被多次获得，但也需要同样次数的释放才能真正的释放。

当多个线程对同一块内存空间同时进行修改的时候，经常遇到奇怪的问题：

import time
import random
from threading import Thread, Lock

count = 0


def do_task():
    global count
    time.sleep(random.randint(1, 10) * 0.1)
    tmp = count
    tmp += 1
    time.sleep(random.randint(1, 10) * 0.1)
    count = tmp
    print(count)


if __name__ == "__main__":
    tasks = []
    for i in range(0, 10):
        tasks.append(Thread(target=do_task))
    for t in tasks:
        t.start()
    for t in tasks:
        t.join()
    print("Finish. Count = {}".format(count))

如上就是典型的非线程安全导致 count 没有达到预期的效果。而通过锁便可以控制某一段代码，或者说某段内存空间的访问：

import time
import random
from threading import Thread, Lock

count = 0
lock = Lock()


def do_task():
    lock.acquire()
    global count
    time.sleep(random.randint(1, 10) * 0.1)
    tmp = count
    tmp += 1
    time.sleep(random.randint(1, 10) * 0.1)
    count = tmp
    print(count)
    lock.release()


if __name__ == "__main__":
    tasks = []
    for i in range(0, 10):
        tasks.append(Thread(target=do_task))
    for t in tasks:
        t.start()
    for t in tasks:
        t.join()
    print("Finish. Count = {}".format(count))

当然，上述例子非常暴力，直接强行把并发改为串行。

对于信号量常见于有限资源强占的场景，可以定义固定大小的信号量供多个线程获取或者释放，从而控制线程的任务执行，比如下面的例子，控制最多有 5 个任务在执行：

import time
import random
from threading import Thread, BoundedSemaphore

sep = BoundedSemaphore(5)


def do_task(task_name):
    sep.acquire()
    print("do Task: {}".format(task_name))
    time.sleep(random.randint(1, 10))
    sep.release()


if __name__ == "__main__":
    tasks = []
    for i in range(0, 10):
        tasks.append(Thread(target=do_task, args=("task_{}".format(i),)))
    for t in tasks:
        t.start()
    for t in tasks:
        t.join()
    print("Finish.")

Queue 和 Pipe

因为多进程的内存隔离，不会存在内存竞争的问题。但同时，多个进程间的数据共享成为了新的问题，而进程间通信常见：队列，管道，信号。

这里只讲解队列和管道。

队列常见于双进程模型，一般用作生产者-消费者模式，由生产者进程向队列中发布任务，并由消费者从队列首部拿出任务进行执行：

import time
from multiprocessing import Process, Queue


class Task1(Process):
    def __init__(self, queue):
        super(Task1, self).__init__()
        self.queue = queue

    def run(self):
        item = self.queue.get()
        print("get item: [{}]".format(item))


class Task2(Process):
    def __init__(self, queue):
        super(Task2, self).__init__()
        self.queue = queue

    def run(self):
        print("put item: [Hello]")
        time.sleep(1)
        self.queue.put("Hello")


if __name__ == "__main__":
    queue = Queue()
    t1 = Task1(queue)
    t2 = Task2(queue)
    t1.start()
    t2.start()
    t1.join()
    print("Finish.")

理论上每个进程都可以向队列里的读或者写，可以认为队列是半双工路线。但是往往只有特定的读进程（比如消费者）和写进程（比如生产者），尽管这些进程只是开发者自己定义的。

而 Pipe 更像一个全工路线：

import time
from multiprocessing import Process, Pipe


class Task1(Process):
    def __init__(self, pipe):
        super(Task1, self).__init__()
        self.pipe = pipe

    def run(self):
        item = self.pipe.recv()
        print("Task1: recv item: [{}]".format(item))
        print("Task1: send item: [Hi]")
        self.pipe.send("Hi")


class Task2(Process):
    def __init__(self, pipe):
        super(Task2, self).__init__()
        self.pipe = pipe

    def run(self):
        print("Task2: send item: [Hello]")
        time.sleep(1)
        self.pipe.send("Hello")
        time.sleep(1)
        item = self.pipe.recv()
        print("Task2: recv item: [{}]".format(item))


if __name__ == "__main__":
    pipe = Pipe()
    t1 = Task1(pipe[0])
    t2 = Task2(pipe[1])
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    print("Finish.")

库

除了上面介绍的 threading 和 multiprocessing 两个库外，还有一个好用的令人发指的库 concurrent.futures。和前面两个库不同，这个库是更高等级的抽象，隐藏了很多底层的东西，但也因此非常好用。用官方的例子：

with ThreadPoolExecutor(max_workers=1) as executor:
    future = executor.submit(pow, 323, 1235)
    print(future.result())

该库中自带了进程池和线程池，可以通过上下文管理器来管理，而且对于异步任务执行完后，结果的获得也非常简单。再拿一个官方的多进程计算的例子作为结束：

import concurrent.futures
import math

PRIMES = [
    112272535095293,
    112582705942171,
    112272535095293,
    115280095190773,
    115797848077099,
    1099726899285419]

def is_prime(n):
    if n % 2 == 0:
        return False

    sqrt_n = int(math.floor(math.sqrt(n)))
    for i in range(3, sqrt_n + 1, 2):
        if n % i == 0:
            return False
    return True

def main():
    with concurrent.futures.ProcessPoolExecutor() as executor:
        for number, prime in zip(PRIMES, executor.map(is_prime, PRIMES)):
            print('%d is prime: %s' % (number, prime))

if __name__ == '__main__':
    main()