并发编程——进程

Posted 2021-01-04 linagcheng

 

一、什么是进程

进程其实一个资源单位，而进程内的线程才是cpu上的执行单位，线程其实指的就是代码的执行过程

二、进程和线程的区别

1. 同一进程下的多个线程共享该进程内的资源
2. 创建线程的开销要远远小于进程

三、利用Thread类开启线程的两种方式

1、Thread类

Thread实例对象的方法
  # isAlive(): 返回线程是否活动的。
  # getName(): 返回线程名。
  # setName(): 设置线程名。

threading模块提供的一些方法：
  # threading.currentThread(): 返回当前的线程变量。
  # threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
  # threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

2、开启线程

from multiprocessing import Thread
import time

def task(name):
    print(‘%s is running ‘ % name)
    time.sleep(2)
    print(‘%s is done ‘ % name)


if __name__ == ‘__main__‘:
    t = Thread(target=task, args=(‘线程1‘,))
    t.start()
    print(‘主‘)

方式一

class Mythread(Thread):
    def run(self):
        print(‘%s is running ‘ % self.name, current_thread().name)
        time.sleep(2)
        print(‘%s is done ‘ % self.name, current_thread().name)


if __name__ == ‘__main__‘:
    t = Mythread()
    t.start()
    print(‘主‘, active_count(), current_thread().name)

方式二

四、统一进程下线程间资源共享

同一进程下的多个线程共享该进程内的资源

from threading import Thread

n = 100


def task():
    global n
    n = 0


if __name__ == ‘__main__‘:
    t = Thread(target=task)
    t.start()
    t.join()
    print(n)




# 0

统一进程下的线程间资源共享

五、守护线程

无论是进程还是线程，都遵循：守护xxx会等待主xxx运行完毕后被销毁

★★运行完毕并非终止运行

 

#1.对主进程来说，运行完毕指的是主进程代码运行完毕

#2.对主线程来说，运行完毕指的是主线程所在的进程内所有非守护线程统统运行完毕，主线程才算运行完毕

 

#1 主进程在其代码结束后就已经算运行完毕了（守护进程在此时就被回收）,然后主进程会一直等非守护的子进程都运行完毕后回收子进程的资源(否则会产生僵尸进程)，才会结束，

#2 主线程在其他非守护线程运行完毕后才算运行完毕（守护线程在此时就被回收）。因为主线程的结束意味着进程的结束，进程整体的资源都将被回收，而进程必须保证非守护线程都运行完毕后才能结束。

from threading import Thread
import time


def task(name):
    print(‘%s is running‘ % name)
    time.sleep(2)
    print(‘%s is done‘ % name)


if __name__ == ‘__main__‘:
    t = Thread(target=task, args=(‘线程1‘,))
    t.daemon = True       
    t.start()
    print(‘主‘)

守护进程

六、互斥锁

 

from threading import Thread,Lock
import time

mutex=Lock()  # 线程是共享资源的，所以不需要把锁当参数传
n=100
def task():
    global n
    mutex.acquire()
    temp=n
    time.sleep(0.1)
    n=temp-1
    mutex.release()

if __name__ == ‘__main__‘:
    t_l=[]
    for i in range(100):
        t=Thread(target=task)
        t_l.append(t)
        t.start()

    for t in t_l:
        t.join()
    print(n)

互斥锁