Python_理解线程与进程

1. 简单理解线程与进程
   进程与线程
   线程：
   多个指令的集合
   线程是操作系统能够调度的最小单位

   进程：
   qq要以一个整体的形式暴露给操作系统管理，里面包含各种资源调用，内存的管理，网络接口的调用
   对各种资源管理的集合 就可以称为 进程

   进程 要操作CPU， 必须要先创建一个线程
   进程与线程的区别：

   1. 线程是执行的指令集，进程是资源的集合
   2. 线程共享内存空间，进程的内存是独立的
   3. 线程启动速度快，进程启动速度慢
   4. 同一个进程的线程之间可以直接交流，两个进程想通信必须通过一个中间代理来实现
   5. 新的线程容易创建，新的进程需要对其父进程进行一次克隆
   6. 一个线程可以控制和操作同一个进程里的其他线程，但是进程只能操作子进程
   7. 改变主线程的同时可能改变其他线程，修改父进程不影响子进程

   守护线程
   不用等待守护线程执行完，程序（主线程）就可以结束

   全局解释器锁：
   cpython只能对用C语言定义的线程进行调用，不能进行其他操作
   因此，调用多个线程时只有一个线程在应用上下文语境执行

2. 简单的多线程任务创建并且并发实现

# Author : Xuefeng

import time
import threading

def run(n):
    print("task ",n)

# t1 = threading.Thread(target=run, args=("t1", ))
# t2 = threading.Thread(target=run, args=("t2", ))
# t1.start()
# t2.start()

start_time = time.time()
for i in range(50):
    t = threading.Thread(target=run, args=("t-%s" % i,))
    t.start()
print("---------All Threads have finished--------")
print("Cost time: ", time.time()-start_time)

3. 用threading创建自己的线程类进行多个线程的并发实现，理解守护线程与主线程

# Author : Xuefeng

import threading
import time

class MyThread(threading.Thread):
    def __init__(self, num, sleep_time):
        super(MyThread,self).__init__()
        self.n = num
        self.sleep_time = sleep_time

    def run(self):
        print("task ", self.n)
        start_time = time.time()
        time.sleep(self.sleep_time)
        print("task %s done cost %s" % (self.n, time.time()-start_time))

t1 = MyThread("t1", 1)
t2 = MyThread("t2", 3)
# t1.run()
# t2.run()

# 两个线程串行，耗时是两个线程运行时间之和
# starttime = time.time()
# t1.start()              # t1 开始
# t1.join()               # t1 等待结束
# t2.start()              # t2 开始
# t2.join()               # t2 等待结束
# print(time.time()-starttime)
#
# print("---------All finished-------")

# 两个线程并行，耗时是两个线程中耗时最长的线程所耗时间
starttime = time.time()
t2.setDaemon(True)      # 设置 t2线程为守护线程
t1.start()              # t1 开始
t2.start()              # t2 开始
time.sleep(0.5)
# 查看当前线程与当前线程个数
print(threading.current_thread(), threading.active_count())

# t1.join()               # t1 等待结束
# t2.join()               # t2 等待结束
print(time.time()-starttime)

print("---------All finished- ------")
print(threading.current_thread(), threading.active_count())

# 主线程是当前程序，不是指某一具体线程

4. 全局解释器锁串行实现多线程

# Author : Xuefeng

import time
import threading

num = 0
a = 1
lock = threading.Lock()

def run():
    lock.acquire()          # 加锁之后线程变串行
    global num
    num += 1
    time.sleep(0.1)
    lock.release()


start_t = time.time()
t_obj = []                  # 存线程实例
for i in range(50):
    t = threading.Thread(target=run)
    t.start()
    t_obj.append(t)         # 为了不阻塞线程的启动，这里不直接进行join，先放到列表里

for i in t_obj:             # 循环线程实例列表，直到所有线程执行完毕
    i.join()

print("---------All Threads have finished--------")
print(num)
print(time.time() - start_t)