Python之路,Day9, 进程、线程、协程篇

1. 操作系统发展史介绍（略）
2. 进程、与线程区别
3. python GIL全局解释器锁
4. 线程
1. 语法
2. join
3. 线程锁之Lock\Rlock\信号量
4. 将线程变为守护进程
5. Event事件　
6. queue队列
7. 生产者消费者模型
8. Queue队列
9. 开发一个线程池
5. 进程
   1. 语法
   2. 进程间通讯
   3. 进程池　

 

进程与线程

什么是进程(process)？An executing instance of a program is called a process.

程序并不能单独运行，只有将程序装载到内存中，系统为它分配资源才能运行，而这种执行的程序就称之为进程。

区别就在于：程序是指令的集合，它是进程运行的静态描述文本；进程是程序的一次执行活动，属于动态概念。

缺陷：　　

• 进程只能在一个时间干一件事，如果想同时干两件事或多件事，进程就无能为力了。

• 进程在执行的过程中如果阻塞，例如等待输入，整个进程就会挂起，即使进程中有些工作不依赖于输入的数据，也将无法执行。

 

什么是线程(thread)？线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

进程与线程的区别？

进程快还是线程快1.没有可比性（进程通过线程来运行）
启动进程快还是启动线程快1.启动一个线程快
1.线程共享内存空间，进程是独立的
2.每个线程共享一份资源，子进程相当于克隆父进程，数据是独立的，不能直接访问
3.同一个进程的线程之间可以直接交流（数据共享，信息传递）
两个进程想通信，必须通过一个中间代理来实现
4.创建新线程很简单，创建新进程需要对父进程进行一份克隆
5.一个线程可以控制和操作同一进程里的其他线程
进程只能操作子进程
6.对于主线程的修改会影响到其他线程的运行
对于父进程的修改不会影响到子线程

Python threading模块

直接调用：

import threading
import time

def run(n):　　#定义每个线程要运行的函数
    print("task ",n)
    time.sleep(2)

# run("t1")
# run("t2")
#启动线程

if __name__ == '__main__':
    t1 = threading.Thread(target=run, args=("t1",))
    t2 = threading.Thread(target=run, args=("t2",))
    
    t1.start()
    t2.start()
    #并行等待2秒
    
    print(t1.getName())  # 获取线程名
    print(t2.getName())


继承调用：

import threading
import time
start_time = time.time()
class MyThread(threading.Thread):
    def __init__(self, n, sleep_time):
        super(MyThread, self).__init__()
        self.n = n
        self.sleep_time = sleep_time
    def run(self):
        print("running task ", self.n)
        time.sleep(self.sleep_time)
        print("task done!", self.n)
        print("cust time:", time.time() - start_time)

if __name__ == '__main__':
    t1 = MyThread("t1",5)　　#运行类方法
    t2 = MyThread("t2",4)
    
    t1.start()
    #t1.join()   #wait   变成串行
    t2.start()
    
    t1.join()   #第一个结果不完成，程序不往下走
    print("mian thread...")

　　

Join & Daemon

import threading
import time
#子线程和主线程没有先后关系
def run(n):
    print("task ",n)
    time.sleep(2)
    print("task done",n, threading.current_thread(), time.time() - start_time)

start_time = time.time()
t_obj = []  #存线程实例
for i in range(5):
    t = threading.Thread(target=run, args=("t-%s" %i,))
    print("t-%s:"%i,t)
    t.setDaemon(True)   #把当前线程设置为守护线程
    t.start()
    t_obj.append(t)
# for t in t_obj: #循环线程实例表，等待所有线程执行完毕
#     t.join()

#time.sleep(3)
print()
print("all threads has finished!",threading.current_thread())    #all threads has finished! <_MainThread(MainThread, started 49112)>  其余线程为运行完
print("cost:",time.time() - start_time)”

=========================================================

import time

import threading

 

 

def run(n):

 

    print('[%s]------running----\n' % n)

    time.sleep(2)

    print('--done--')

 

def main():

    for i in range(5):

        t = threading.Thread(target=run,args=[i,])

        t.start()

        t.join(1)

        print('starting thread', t.getName())

 

 

m = threading.Thread(target=main,args=[])

m.setDaemon(True) #将main线程设置为Daemon线程,它做为程序主线程的守护线程,当主线程退出时,m线程也会退出,由m启动的其它子线程会同时退出,不管是否执行完任务

m.start()

m.join(timeout=2)

print("---main thread done----")

 

 

 

 

 

 

来源：https://www.cnblogs.com/alex3714/articles/5230609.html