3-31周末总结

最新推荐文章于 2025-09-06 22:56:13 发布

weixin_33834137

最新推荐文章于 2025-09-06 22:56:13 发布

阅读量62

点赞数

CC 4.0 BY-SA版权

文章标签：数据库操作系统

原文链接：https://juejin.im/post/5ca1f5086fb9a05e5516385a

本文深入讲解了进程与线程的概念及实现方法，包括进程的创建、线程的使用、线程间的通信等内容，并探讨了多线程编程中的锁机制。

线程进程总结

进程

含义：

对于操作系统来说，一个任务就是一个进程（Process），比如打开一个浏览器就是启动一个浏览器进程，打开一个记事本就启动了一个记事本进程

实现方法

linux，unix:

Unix/Linux操作系统提供了一个fork()系统调用

import os

print('Process (%s) start...' % os.getpid())
# Only works on Unix/Linux/Mac:
pid = os.fork()    # 函数返回两个值，对返回值判断
if pid == 0:   
print('I am child process (%s) and my parent is %s.' % (os.getpid(), os.getppid()))
else:
print('I (%s) just created a child process (%s).' % (os.getpid(), pid))
复制代码

划重点：

**调用getppid()就可以拿到父进程的ID

调用getpid()得到本进程ID**

wondiows和Linux跨平台

from multiprocessing import Process import os

子进程要执行的代码

def run_proc(name):
print('Run child process %s (%s)...' % (name, os.getpid()))  # 得到进程号

if __name__=='__main__':
print('Parent process %s.' % os.getpid())
p = Process(target=run_proc, args=('test',))  # 实例化
print('Child process will start.')
p.start()  
p.join()
print('Child process end.')
复制代码

划重点：

** start是让进程开始工作

join为等待子进程结束 **

windows

Pool

如果要启动大量的子进程，可以用进程池的方式批量创建子进程： from multiprocessing import Pool import os, time, random

def long_time_task(name):
print('Run task %s (%s)...' % (name, os.getpid()))
start = time.time()
time.sleep(random.random() * 3)
end = time.time()
print('Task %s runs %0.2f seconds.' % (name, (end - start)))

if __name__=='__main__':
print('Parent process %s.' % os.getpid())
p = Pool(4)
for i in range(5):
p.apply_async(long_time_task, args=(i,))
print('Waiting for all subprocesses done...')
p.close()
p.join()
print('All subprocesses done.')
复制代码

划重点：

join()之前必须先调用close()，调用close()之后就不能继续添加新的Process了。

线程

含义：

对于操作系统来说，一个任务就是一个进程（Process），比如打开一个浏览器就是启动一个浏览器进程，打开一个记事本就启动了一个记事本进程线程

包含模块：

thread和threading，_thread是低级模块，threading是高级模块，对thread进行了封装。

import time, threading

# 新线程执行的代码:
def loop():
print('thread %s is running...' % threading.current_thread().name)
n = 0
while n < 5:
n = n + 1
print('thread %s >>> %s' % (threading.current_thread().name, n))
time.sleep(1)
print('thread %s ended.' % threading.current_thread().name)

print('thread %s is running...' % threading.current_thread().name)
t = threading.Thread(target=loop, name='LoopThread')
t.start()
t.join()
print('thread %s ended.' % threading.current_thread().name)
复制代码

划重点

threading.current_thread().name返回线程名

ThreadLocal

局部变量只有线程自己能看见，不会影响其他线程，而全局变量的修改必须加锁。 import threading

# 创建全局ThreadLocal对象:
local_school = threading.local()

def process_student():
# 获取当前线程关联的student:
std = local_school.student
print('Hello, %s (in %s)' % (std, threading.current_thread().name))

def process_thread(name):
# 绑定ThreadLocal的student:
local_school.student = name
process_student()

t1 = threading.Thread(target= process_thread, args=('Alice',), name='Thread-A')
t2 = threading.Thread(target= process_thread, args=('Bob',), name='Thread-B')
t1.start()
t2.start()
t1.join()
t2.join()
复制代码

作用：

ThreadLocal最常用的地方就是为每个线程绑定一个数据库连接，HTTP请求，用户身份信息等，这样一个线程的所有调用到的处理函数都可以非常方便地访问这些资源。

线程锁

为什么要锁？

多线程和多进程最大的不同在于，多进程中，同一个变量，各自有一份拷贝存在于每个进程中，互不影响，而多线程中，所有变量都由所有线程共享，所以，任何一个变量都可以被任何一个线程修改，因此，线程之间共享数据最大的危险在于多个线程同时改一个变量，把内容给改乱了。

作用

change_it()上一把锁，当某个线程开始执行change_it()时，我们说，该线程因为获得了锁，因此其他线程不能同时执行change_it()，只能等待，直到锁被释放后，获得该锁以后才能改。

进程间通信

def write(q):
print('Process to write: %s' % os.getpid())
for value in ['A', 'B', 'C']:
print('Put %s to queue...' % value)
q.put(value)
time.sleep(random.random())

# 读数据进程执行的代码:
def read(q):
print('Process to read: %s' % os.getpid())
while True:
value = q.get(True)
print('Get %s from queue.' % value)

if __name__=='__main__':
# 父进程创建Queue，并传给各个子进程：
q = Queue()
pw = Process(target=write, args=(q,))
pr = Process(target=read, args=(q,))
# 启动子进程pw，写入:
pw.start()
# 启动子进程pr，读取:
pr.start()
# 等待pw结束:
pw.join()
# pr进程里是死循环，无法等待其结束，只能强行终止:
pr.terminate()
复制代码