class Thread:
?
    """注释被我删掉了"""
    
    _initialized = False  # 这是一个状态位，来表示该线程是否被被初始化过
?
    def __init__(self, group=None, target=None, name=None,
                 args=(), kwargs=None, *, daemon=None):
                 
        """注释被我删掉了"""             
      
        assert group is None, "group argument must be None for now" #如果不是 None，daemon参数将显式地设置该线程是否为守护模式。 如果是 None (默认值)，线程将继承当前线程的守护模式属性。
        if kwargs is None:
            kwargs = {}  # kwargs 是用于调用目标函数的关键字参数字典。默认是 {}。
        self._target = target  # 对于第一种调用方式来说，它就是我们的task函数。
        self._name = str(name or _newname())  # 线程名
        self._args = args  # _args是用于调用目标函数的参数元组。默认是 ()。
        self._kwargs = kwargs 
        if daemon is not None: # 判断其是否为守护线程
            self._daemonic = daemon
        else:
            self._daemonic = current_thread().daemon
        self._ident = None # 这个是线程的编号
        if _HAVE_THREAD_NATIVE_ID:  # 判断是否具有本地ID
            self._native_id = None
        self._tstate_lock = None  # 锁定的状态
        self._started = Event() # 开始
        self._is_stopped = False # 状态位，是否停止
        self._initialized = True  # 将初始化状态为改为True
        # Copy of sys.stderr used by self._invoke_excepthook()
        self._stderr = _sys.stderr
        self._invoke_excepthook = _make_invoke_excepthook()
        # For debugging and _after_fork()
        _dangling.add(self)

def run(self):
?
    """注释被我删掉了"""
    
    try:
        if self._target:  # 简单吧，这个方法，就是判断你有没有传入一个函数。即我们定义的task
            self._target(*self._args, **self._kwargs)  # 有的话就立即执行，我们传入的name其实就放在了_args中。这里将它打散出来了，所以我们的task函数中的第一个参数name能收到。
    finally:
        # Avoid a refcycle if the thread is running a function with
        # an argument that has a member that points to the thread.
        del self._target, self._args, self._kwargs  # 不管处不出错，都会清理他们。当然，如果有则是执行完成后清理

import threading
import time

print("主线程任务开始运行")

class Threading(threading.Thread):
    """自定义类"""

    def run(self):
        print(self._args)  # (‘线程[1]‘,)
        print(self._kwargs)  # {}

        print("子线程任务开始处理,参数:{0}".format(self._args[0]))
        time.sleep(3)  # <-- 这里睡眠了三秒，可以看见主线程继续往下走了
        print("子线程任务运行完毕")



if __name__ == ‘__main__‘:
    
    t1 = Threading(args=("线程[1]",))
    t1.start()  # 等待CPU调度..请注意这里不是立即执行
    
    
    print("主线程任务处理完毕")

# ==== 执行结果 ====
    
"""
主线程任务开始处理
(‘线程[1]‘,)
主线程任务处理完毕
{}
子线程任务开始处理,参数:线程[1]
子线程任务处理完毕
"""

# ==== 情况一 ====

import threading
import time

print("主线程任务开始处理")

def task(th_name):
    print("子线程任务开始处理,参数:{0}".format(th_name))
    time.sleep(3)
    print("子线程任务处理完毕")

if __name__ == ‘__main__‘:

    t1 = threading.Thread(target=task,args=("线程[1]",))

    t1.setDaemon(True)  # <--- 放在start()上面，主线程运行完后会立即终止子线程的运行。但是由于有join()，故不生效。

    t1.start()  #  等待CPU调度..请注意这里不是立即执行

    t1.join()  # <--- 放在start()下面，等2秒后主线程继续执行

    print("主线程任务处理完毕")

# ==== 执行结果 ====

"""
主线程任务开始处理
子线程任务开始处理,参数:线程[1]
子线程任务处理完毕
主线程任务处理完毕
"""

# ==== 情况二 ====

import threading
import time

print("主线程任务开始处理")

def task(th_name):
    print("子线程任务开始处理,参数:{0}".format(th_name))
    time.sleep(3)
    print("子线程任务处理完毕")

if __name__ == ‘__main__‘:

    t1 = threading.Thread(target=task,args=("线程[1]",))

    t1.setDaemon(True)  # <--- 放在start()上面，主线程运行完后会立即终止子线程的运行。但是由于有join()，故不生效。

    t1.start()  #  等待CPU调度..请注意这里不是立即执行

    t1.join(2)  # <--- 放在start()下面，等2秒后主线程继续执行

    print("主线程任务处理完毕")

# ==== 执行结果 ====

"""
主线程任务开始处理
子线程任务开始处理,参数:线程[1]
主线程任务处理完毕
"""

import threading
import time

num = 0
def add():
    global num
    for i in range(10000000): # 一千万次
        num += 1

def sub():
    global num
    for i in range(10000000):  # 一千万次
        num -= 1

if __name__ == ‘__main__‘:
    start_time = time.time()

    add()
    sub()

    end_time = time.time()
    print("执行时间:",end_time - start_time)
    
# ==== 执行结果 ==== 三次采集

"""
大约在 1.3 - 1.4 秒
"""

# coding:utf-8

import threading
import time

num = 0
def add():
    global num
    for i in range(10000000):  # 一千万次
        num += 1

def sub():
    global num
    for i in range(10000000):  # 一千万次
        num -= 1

if __name__ == ‘__main__‘:
    start_time = time.time()

    t1 = threading.Thread(target=add,)
    t2 = threading.Thread(target=sub,)
    t1.start()
    t2.start()
    t1.join()
    t2.join()

    end_time = time.time()
    print(u"执行时间:",end_time - start_time)

# ==== 执行结果 ==== 三次采集

"""
大约 4 - 5 秒
"""