Python高级系列教程：Python的进程和线程

news2024/11/24 1:51:25

学习目标

1、了解多任务的概念

2、了解进程的概念以及多进程的作用

3、掌握多进程完成多任务的工作原理及案例编写

4、掌握进程编号的获取方式以及进程使用的注意事项

5、了解线程的概念以及多线程的作用

6、掌握多进程完成多任务的工作原理及案例编写

一、多任务的概念

1、举个栗子

思考：我们在使用网盘下载资料的时候，为什么要多个任务同时下载呢？答：多个任务同时执行可以大大提高程序的执行效率

2、提出问题

问题：利用我们目前所学的技术，我们能否实现多任务操作呢？答：不能，因为之前所写的程序都是单任务的，也就是说一个函数或者方法执行完成 , 另外一个函数或者方法才能执行。要想实现多个任务同时执行就需要使用多任务。多任务的最大好处是充分利用CPU资源，提高程序的执行效率。

3、什么是多任务

多任务是指在同一时间内执行多个任务。例如: 现在电脑安装的操作系统都是多任务操作系统，可以同时运行着多个软件。

4、多任务的两种表现形式

① 并发 ② 并行

5、并发操作

并发：在一段时间内交替去执行多个任务。例如：对于单核cpu处理多任务,操作系统轮流让各个任务交替执行，假如:软件1执行0.01秒，切换到软件2，软件2执行0.01秒，再切换到软件3，执行0.01秒……这样反复执行下去, 实际上每个软件都是交替执行的 。但是，由于CPU的执行速度实在是太快了，表面上我们感觉就像这些软件都在同时执行一样，这里需要注意单核cpu是并发的执行多任务的。

6、并行操作

并行：在一段时间内真正的同时一起执行多个任务。对于多核cpu处理多任务，操作系统会给cpu的每个内核安排一个执行的任务，多个内核是真正的一起同时执行多个任务。这里需要注意多核cpu是并行的执行多任务，始终有多个任务一起执行。

二、进程的概念

1、程序中实现多任务的方式

在Python中，想要实现多任务可以使用多进程来完成。

2、进程的概念

进程（Process）是资源分配的最小单位，它是操作系统进行资源分配和调度运行的基本单位，通俗理解：一个正在运行的程序就是一个进程。例如:正在运行的qq , 微信等 他们都是一个进程。

注：一个程序运行后至少有一个进程

3、多进程的作用

☆ 未使用多进程

思考: 图中是一个非常简单的程序 , 一旦运行hello.py这个程序 , 按照代码的执行顺序 , func_a函数执行完毕后才能执行func_b函数 . 如果可以让func_a和func_b同时运行 , 显然执行hello.py这个程序的效率会大大提升 .

☆ 使用了多进程

三、多进程完成多任务

1、多进程完成多任务

 

 

① 导入进程包
 import multiprocessing

 ② 通过进程类创建进程对象
 进程对象 = multiprocessing.Process()

 ③ 启动进程执行任务
 进程对象.start()
 

 

2、通过进程类创建进程对象
 

 

 

进程对象 = multiprocessing.Process([group [, target=任务名 [, name]]])
 

参数说明：
 

 
参数名
 		 
说明
 
 
target
 		 
执行的目标任务名，这里指的是函数名(方法名)
 
 
name
 		 
进程名，一般不用设置
 
 
group
 		 
进程组，目前只能使用None
 
 

 

3、进程创建与启动的代码
 

边听音乐边敲代码：
 

 

 

import multiprocessing
 import time


 def music():
 for i in range(3):
 print('听音乐...')
 time.sleep(0.2)


 def coding():
 for i in range(3):
 print('敲代码...')
 time.sleep(0.2)

 if __name__ == '__main__':
 music_process = multiprocessing.Process(target=music)
 coding_process = multiprocessing.Process(target=coding)

 music_process.start()
 coding_process.start()
 

运行结果：
 

 

 

听音乐...
 敲代码...
 听音乐...
 敲代码...
 听音乐...
 敲代码...
 

这是一个使用Python multiprocessing模块实现并行任务的代码。代码中定义了两个函数music()和coding()，分别表示听音乐和敲代码这两个任务，每个任务都会执行3次，且每次执行后都会暂停0.2秒。
 

代码通过multiprocessing.Process()方法创建了两个进程music_process和coding_process，每个进程都指定了一个target参数，即对应的任务music或coding。
 

接着通过start()方法启动了这两个进程，它们会异步的同时执行。if name == 'main':这一行是Python程序入口，用来保证在多进程环境中不会重复启动进程。执行该代码后，会看到两个进程并行执行各自的任务，即打印“听音乐…”和“敲代码…”。
 

 

4、进程执行带有参数的任务
 

 

 

Process([group [, target [, name [, args [, kwargs]]]]])
 

参数说明：这是Python中的一个函数，用于创建一个进程对象并启动一个新的进程。它的参数包括：
 

  •  
    group：指定进程组，通常不需要使用，默认为None。
     
  •  
    target：指定进程启动时要执行的函数。必须是可调用的对象。
     
  •  
    name：指定进程的名称，通常不需要使用，默认为None。
     
  •  
    args：指定传递给目标函数的参数元组。args=(1,2,'anne',)
     
  •  
    kwargs：指定传递给目标函数的关键字参数字典。kwargs={'name':'anne','age':18}
     
 

案例：args参数和kwargs参数的使用
 

 

 

import multiprocessing
 import time

 def music(num):
 for i in range(num):
 print('听音乐...')
 time.sleep(0.2)

 def coding(count):
 for i in range(count):
 print('敲代码...')
 time.sleep(0.2)

 if __name__ == '__main__':
 music_process = multiprocessing.Process(target=music, args=(3,))
 coding_process = multiprocessing.Process(target=coding, kwargs={'count': 3})

 music_process.start()
 coding_process.start()

 music_process.join()
 coding_process.join()
 

加入join()方法是为了保证主进程在所有子进程执行完毕后再结束，否则主进程会在子进程还没执行完毕就结束了。在多进程编程中，子进程的执行是异步的，主进程和子进程是并发执行的，如果主进程没有等待子进程执行完毕就结束了，那么子进程可能会被强制终止，导致程序出现异常或者数据丢失等问题。
 

因此，在启动子进程后，应该调用join()方法等待子进程执行完毕后再结束主进程，以保证程序的正常运行。join()方法会阻塞主进程，直到所有的子进程都执行完毕后才会继续执行主进程。
 

案例：多个参数传递
 

 

 

import multiprocessing
 import time


 def music(num, name):
 for i in range(num):
 print(name)
 print('听音乐...')
 time.sleep(0.2)


 def coding(count):
 for i in range(count):
 print('敲代码...')
 time.sleep(0.2)


 if __name__ == '__main__':
 music_process = multiprocessing.Process(target=music, args=(3, '多任务开始'))
 coding_process = multiprocessing.Process(target=coding, kwargs={'count': 3})

 music_process.start()
 coding_process.start()
 

运行结果：
 

 

 

多任务开始
 听音乐...
 敲代码...
 多任务开始
 听音乐...
 敲代码...
 多任务开始
 听音乐...
 敲代码...
 

这段代码实现了多进程并发执行不同任务的示例。具体实现如下：
 

导入了multiprocessing和time模块。
 

定义了两个函数：music()和coding()。music()函数通过循环执行num次输出字符串name和“听音乐...”字符串并sleep 0.2秒，模拟“听音乐”任务。coding()函数通过循环执行count次输出“敲代码...”字符串并sleep0.2秒，模拟“敲代码”任务。
 

在程序主入口中执行两个子进程：music_process和coding_process。其中music_process进程调用music()函数，传入参数num=3和name='多任务开始'，coding_process进程调用coding()函数，传入参数count=3。
 

启动music_process和coding_process进程。
 

进程开始并发执行，其中music_process进程输出num次name和“听音乐...”字符串，coding_process进程输出count次“敲代码...”字符串。每次输出之后程序会sleep 0.2秒，以模拟不同的任务执行。
 

进程执行完毕后程序结束。
 

四、获取进程编号
 

 

1、进程编号的作用
 

当程序中进程的数量越来越多时 , 如果没有办法区分主进程和子进程还有不同的子进程 , 那么就无法进行有效的进程管理 , 为了方便管理实际上每个进程都是有自己编号的。
 

 

2、两种进程编号
 

① 获取当前进程编号
 

 

 

getpid()
 

② 获取当前进程的父进程ppid = parent pid
 

 

 

getppid()
 

 

3、获取当前进程编号
 

 

 

import os


 def work():
 # 获取当前进程的编号
 print('work进程编号', os.getpid())
 # 获取父进程的编号
 print('work父进程的编号', os.getppid())


 work()
 

案例：获取子进程编号
 

 

 

import multiprocessing
 import time
 import os


 def music(num):
 print('music>> %d' % os.getpid())
 for i in range(num):
 print('听音乐...')
 time.sleep(0.2)


 def coding(count):
 print('coding>> %d' % os.getpid())
 for i in range(count):
 print('敲代码...')
 time.sleep(0.2)


 if __name__ == '__main__':
 music_process = multiprocessing.Process(target=music, args=(3, ))
 coding_process = multiprocessing.Process(target=coding, kwargs={'count': 3})

 music_process.start()
 coding_process.start()
 

运行结果：
 

 

 

music>> 12232
 听音乐...
 coding>> 1868
 敲代码...
 听音乐...
 敲代码...
 听音乐...
 敲代码...
 

这是一个使用Python的multiprocessing模块创建多进程的例子。
 

首先，定义了两个函数：music和coding，分别输出进程ID，然后使用for循环和time.sleep语句模拟耗时操作。其次，在程序的主程序中，使用multiprocessing.Process创建了两个进程music_process和coding_process，分别使用target参数指定要执行的函数，以及args或kwargs参数将要执行函数的参数传递进去。然后调用start方法启动这两个进程，从而在两个进程中同时执行不同的任务。
 

需要注意的是，使用if name == 'main' 是为了防止子进程递归创建子进程导致的一系列问题，因为在Windows系统下，所有的Python程序都会自动运行一遍，而在Linux/MacOS系统下则不会。
 

案例：获取父进程与子进程编号
 

 

 

import multiprocessing
 import time
 import os


 def music(num):
 print('music>> %d' % os.getpid())
 print('music主进程>> %d' % os.getppid())
 for i in range(num):
 print('听音乐...')
 time.sleep(0.2)


 def coding(count):
 print('coding>> %d' % os.getpid())
 print('music主进程>> %d' % os.getppid())
 for i in range(count):
 print('敲代码...')
 time.sleep(0.2)


 if __name__ == '__main__':
 print('主进程>> %d' % os.getpid())
 music_process = multiprocessing.Process(target=music, args=(3, ))
 coding_process = multiprocessing.Process(target=coding, kwargs={'count': 3})

 music_process.start()
 coding_process.start()
 

运行结果：
 

 

 

主进程>> 15080
 music>> 10320
 music主进程>> 15080
 听音乐...
 coding>> 19220
 music主进程>> 15080
 敲代码...
 听音乐...
 敲代码...
 听音乐...
 敲代码...
 

这段代码使用Python的multiprocessing模块创建了两个进程来模拟听音乐和编写代码两个任务的同时执行。
 

首先定义了两个函数music()和coding()分别用于在进程中执行听音乐和编写代码的任务。在函数中使用了os.getpid()和os.getppid()获取当前进程和父进程的ID。
 

在代码中使用了 multiprocessing.Process()  函数来创建两个进程。music_process进程执行 music() 函数，而 coding_process 进程执行 coding() 函数。
 

最后，在主进程中使用 .start()方法启动两个子进程的执行，观察运行结果可以发现，music() 和 coding() 函数的任务在两个子进程中并行执行。
 

 

五、进程应用注意点
 

 

1、进程间不共享全局变量
 

实际上创建一个子进程就是把主进程的资源进行拷贝产生了一个新的进程，这里的主进程和子进程是互相独立的。
 

 

案例：
 

 

 

import multiprocessing

 my_list = []


 def write_data():
 for i in range(3):
 my_list.append(i)
 print('add:', i)
 print(my_list)


 def read_data():
 print('read_data', my_list)


 if __name__ == '__main__':
 # 创建写入数据进程
 write_process = multiprocessing.Process(target=write_data)
 # 创建读取数据进程
 read_process = multiprocessing.Process(target=read_data)

 # 启动进程执行相关任务
 write_process.start()
 time.sleep(1)
 read_process.start()
 

原理分析：
 

 

 
 
三个进程分别操作的都是自己进程里面的全局变量my_list, 不会对其它进程里面的全局变量产生影响，所以进程之间不共享全局变量，只不过进程之间的全局变量名字相同而已，但是操作的不是同一个进程里面的全局变量。
 

 

知识点小结：创建子进程会对主进程资源进行拷贝，也就是说子进程是主进程的一个副本，好比是一对双胞胎，之所以进程之间不共享全局变量，是因为操作的不是同一个进程里面的全局变量，只不过不同进程里面的全局变量名字相同而已。
 

 

2、主进程与子进程的结束顺序
 

 

代码演示：
 

 

 

import multiprocessing
 import time


 # 工作函数
 def work():
 for i in range(10):
 print('工作中...')
 time.sleep(0.2)


 if __name__ == '__main__':
 # 创建子进程
 work_process = multiprocessing.Process(target=work)
 # 启动子进程
 work_process.start()

 # 延迟1s
 time.sleep(1)
 print('主进程执行完毕')
 

执行结果：
 

 

 

这段代码使用了Python的multiprocessing模块来创建并启动一个子进程，同时在主进程中延迟1秒后输出一条信息。具体解释如下：
 

  1.  
    导入multiprocessing和time模块。
     
  2.  
    定义一个名为work的函数，函数内部使用for循环和time.sleep()函数模拟一些耗时的工作。
     
  3.  
    在if name == 'main':语句块中，创建一个名为work_process的子进程，该进程的目标函数为work。
     
  4.  
    启动子进程，调用work_process.start()。
     
  5.  
    使用time.sleep(1)函数在主进程中延迟1秒。
     
  6.  
    输出一条信息，表示主进程执行完毕。
     
 

因为子进程和主进程是并行执行的，所以在主进程延迟1秒后，子进程仍然在执行工作函数中的任务。因此，输出的信息可能会在子进程的输出信息之前或之后，具体取决于操作系统的调度策略
 

 

☆ 解决方案一：设置守护进程
 

 

 

import multiprocessing
 import time


 # 工作函数
 def work():
 for i in range(10):
 print('工作中...')
 time.sleep(0.2)


 if __name__ == '__main__':
 # 创建子进程
 work_process = multiprocessing.Process(target=work)
 # 设置守护主进程，主进程退出后子进程直接销毁，不再执行子进程中的代码
 work_process.daemon = True
 # 启动子进程
 work_process.start()

 # 延迟1s
 time.sleep(1)
 print('主进程执行完毕')
 

运行结果：
 

 

 

工作中...
 工作中...
 工作中...
 工作中...
 工作中...
 主进程执行完毕
 

这段代码使用了Python的multiprocessing模块，实现了创建一个子进程并在其中执行一个工作函数。
 

首先定义了一个工作函数work()，该函数会循环执行10次，每次输出“工作中...”，并睡眠0.2秒。
 

在主程序中，首先创建了一个子进程work_process，将work函数作为其target参数传递进去，表示该子进程需要执行work函数。
 

然后将work_process的daemon属性设置为True，表示该子进程是守护进程，即当主进程退出时，该子进程也会随之退出，不再执行子进程中的代码。
 

接下来启动子进程work_process，子进程开始执行work函数中的代码。主进程延迟1秒后，输出“主进程执行完毕”，然后退出。
 

由于子进程是守护进程，随着主进程的退出，子进程也会被销毁，不再执行work函数中的代码。
 

 

☆ 解决方案二：销毁子进程
 

 

 

import multiprocessing
 import time


 # 工作函数
 def work():
 for i in range(10):
 print('工作中...')
 time.sleep(0.2)


 if __name__ == '__main__':
 # 创建子进程
 work_process = multiprocessing.Process(target=work)
 # 启动子进程
 work_process.start()

 # 延迟1s
 time.sleep(1)

 # 让子进程直接销毁，表示终止执行， 主进程退出之前，把所有的子进程直接销毁就可以了
 work_process.terminate()

 print('主进程执行完毕')
 

 
 
提示: 以上两种方式都能保证主进程退出子进程销毁
 

 

运行结果：
 

 

 

工作中...
 工作中...
 工作中...
 工作中...
 工作中...
 主进程执行完毕
 

这段代码使用了Python的multiprocessing模块，实现了创建一个子进程，让子进程执行一个工作函数work()，并在主进程中控制子进程的运行和终止。具体解释如下：
 

  1.  
    导入multiprocessing和time模块。
     
  2.  
    定义一个工作函数work()，该函数会循环执行10次，每次打印一条信息“工作中...”，并休眠0.2秒。
     
  3.  
    在if name == 'main'条件语句中，创建一个子进程work_process，它的目标函数是work()。
     
  4.  
    启动子进程work_process，它会开始执行work()函数中的循环语句。
     
  5.  
    主进程延迟1秒，等待子进程执行一段时间。
     
  6.  
    调用work_process.terminate()方法，强制终止子进程的执行。
     
  7.  
    打印出“主进程执行完毕”信息。
     
 

总体来说，这段代码展示了如何在Python中使用multiprocessing模块创建和控制子进程的运行和终止。
 

 

六、线程的概念
 

 

1、线程的概念
 

在Python中，想要实现多任务还可以使用多线程来完成。
 

 

2、为什么使用多线程？
 

进程是分配资源的最小单位 , 一旦创建一个进程就会分配一定的资源 , 就像跟两个人聊QQ就需要打开两个QQ软件一样是比较浪费资源的。
 

线程是程序执行的最小单位 , 实际上进程只负责分配资源 , 而利用这些资源执行程序的是线程 , 也就说进程是线程的容器 , 一个进程中最少有一个线程来负责执行程序 。同时线程自己不拥有系统资源，只需要一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源 。这就像通过一个QQ软件(一个进程)打开两个窗口(两个线程)跟两个人聊天一样 , 实现多任务的同时也节省了资源。
 

 

3、多线程的作用
 

 

 

def func_a():
 print('任务A')


 def func_b():
 print('任务B')


 func_a()
 func_b()
 

 

☆ 单线程执行
 

 

 

☆ 多线程执行
 

 

 

七、多线程完成多任务
 

 

1、多线程完成多任务
 

 

 

① 导入线程模块
 import threading

 ② 通过线程类创建线程对象
 线程对象 = threading.Thread(target=任务名)

 ② 启动线程执行任务
 线程对象.start()
 

 
参数名
 		 
说明
 
 
target
 		 
执行的目标任务名,这里指的是函数名(方法名)
 
 
name
 		 
线程名，一般不用设置
 
 
group
 		 
线程组，目前只能使用None
 
 

 

2、线程创建与启动代码
 

单线程案例：
 

 

 

import time


 def music():
 for i in range(3):
 print('听音乐...')
 time.sleep(0.2)


 def coding():
 for i in range(3):
 print('敲代码...')
 time.sleep(0.2)


 if __name__ == '__main__':
 music()
 coding()
 

多线程案例：
 

 

 

import time
 import threading


 def music():
 for i in range(3):
 print('听音乐...')
 time.sleep(0.2)


 def coding():
 for i in range(3):
 print('敲代码...')
 time.sleep(0.2)


 if __name__ == '__main__':
 music_thread = threading.Thread(target=music)
 coding_thread = threading.Thread(target=coding)

 music_thread.start()
 coding_thread.start()
 

 

3、线程执行带有参数的任务
 

 
参数名
 		 
说明
 
 
args
 		 
以元组的方式给执行任务传参
 
 
kwargs
 		 
以字典方式给执行任务传参
 
 

 

 

import time
 import threading


 def music(num):
 for i in range(num):
 print('听音乐...')
 time.sleep(0.2)


 def coding(count):
 for i in range(count):
 print('敲代码...')
 time.sleep(0.2)


 if __name__ == '__main__':
 music_thread = threading.Thread(target=music, args=(3, ))
 coding_thread = threading.Thread(target=coding, kwargs={'count': 3})

 music_thread.start()
 coding_thread.start()
 

在主线程中，通过 music_thread.start() 和 coding_thread.start() 启动两个线程，使它们可以同时运行。由于线程是并发执行的，因此 music() 和 coding() 函数会交替执行，输出相应的信息。
 

 

4、主线程和子线程的结束顺序
 

 

 

import time
 import threading


 def work():
 for i in range(10):
 print('work...')
 time.sleep(0.2)


 if __name__ == '__main__':
 # 创建子进程
 work_thread = threading.Thread(target=work)
 # 启动线程
 work_thread.start()

 # 延时1s
 time.sleep(1)
 print('主线程执行完毕')
 

运行结果：
 

 

 

work...
 work...
 work...
 work...
 work...
 主线程执行完毕
 work...
 work...
 work...
 work...
 work...
 

这段代码使用了 Python 的 threading 模块，创建了一个线程 work_thread，执行 work() 函数。
 

work() 函数会输出 'work...'，并且每次循环会暂停 0.2 秒，循环次数为 10。
 

在主线程中，通过 work_thread.start() 启动线程，使它可以开始执行。
 

接着，主线程会延时 1 秒钟，然后输出 '主线程执行完毕'。由于 work_thread 线程需要 2 秒钟才能完成全部工作，因此主线程先于 work_thread 线程执行完毕。
 

通过使用线程，可以让程序在多个任务之间切换执行，提高程序的效率和响应速度。
 

 

☆ 设置守护线程方式一
 

 

 

import time
 import threading


 def work():
 for i in range(10):
 print('work...')
 time.sleep(0.2)


 if __name__ == '__main__':
 # 创建子线程并设置守护主线程
 work_thread = threading.Thread(target=work, daemon=True)
 # 启动线程
 work_thread.start()

 # 延时1s
 time.sleep(1)
 print('主线程执行完毕')
 

运行结果：
 

 

 

work...
 work...
 work...
 work...
 work...
 主线程执行完毕
 

这段代码使用了Python的time和threading模块。
 

首先定义了一个函数work()，用于在子线程中执行任务。该函数循环10次，每次输出字符串"work..." ，并使用time.sleep(0.2)来模拟任务执行的时间。
 

接下来，在主程序中，创建了一个子线程work_thread，并将work()函数作为其目标函数，设置了daemon=True以将其设置为守护线程。然后，使用work_thread.start()启动子线程。
 

接着，主线程使用time.sleep(1)延时1秒，以等待子线程执行任务。最后，主线程输出字符串"主线程执行完毕"。
 

由于子线程被设置为守护线程，当主线程执行完毕后，子线程也会随之结束。因此，如果没有设置守护线程，子线程将会一直执行下去，直到任务完成或者被手动停止。
 

 

☆ 设置守护线程方式二
 

 

 

import time
 import threading


 def work():
 for i in range(10):
 print('work...')
 time.sleep(0.2)


 if __name__ == '__main__':
 # 创建子线程
 work_thread = threading.Thread(target=work)
 # 设置守护主线程
 work_thread.setDaemon(True)
 # 启动线程
 work_thread.start()

 # 延时1s
 time.sleep(1)
 print('主线程执行完毕')
 

运行结果：
 

 

 

work...
 work...
 work...
 work...
 work...
 主线程执行完毕
 

这段代码使用了 Python 的 threading 模块创建了一个子线程，并将其设置为守护主线程，然后启动了该子线程。子线程的工作是输出 'work...' 字符串并休眠 0.2 秒，重复执行 10 次。
 

在主线程中，代码延时 1 秒后输出 '主线程执行完毕' 字符串。因为子线程被设置为守护主线程，所以当主线程执行完毕后，子线程也会随之结束。
 

如果没有设置子线程为守护主线程，那么主线程执行完毕后，子线程仍然会继续执行，直到完成所有工作。
 

 

5、线程间的执行顺序
 

 

 

for i in range(5):
 sub_thread = threading.Thread(target=task)
 sub_thread.start()
 

思考：当我们在进程中创建了多个线程，其线程之间是如何执行的呢？按顺序执行？一起执行？还是其他的执行方式呢？
 

 

  
 

 

答：线程之间的执行是无序的，验证
 

 

☆ 获取当前线程信息
 

 

 

# 通过current_thread方法获取线程对象
 current_thread = threading.current_thread()

 # 通过current_thread对象可以知道线程的相关信息，例如被创建的顺序
 print(current_thread)
 

 

☆ 线程间的执行顺序
 

 

 

import threading
 import time

 def get_info():
 # 可以暂时先不加，查看效果
 time.sleep(0.5)
 current_thread = threading.current_thread()
 print(current_thread)


 if __name__ == '__main__':
 # 创建子线程
 for i in range(10):
 sub_thread = threading.Thread(target=get_info)
 sub_thread.start()
 

 
 
总结：线程之间执行是无序的，是由CPU调度决定某个线程先执行的。
 

 

 

6、线程间共享全局变量
 

 

☆ 线程间共享全局变量
 

多个线程都是在同一个进程中 , 多个线程使用的资源都是同一个进程中的资源 ，因此多线程间是共享全局变量
 

 

示例代码：
 

 

 

import threading
 import time


 my_list = []


 def write_data():
 for i in range(3):
 print('add：', i)
 my_list.append(i)
 print(my_list)


 def read_data():
 print('read：', my_list)


 if __name__ == '__main__':
 write_thread = threading.Thread(target=write_data)
 read_thread = threading.Thread(target=read_data)

 write_thread.start()
 time.sleep(1)
 read_thread.start()
 

运行结果：
 

 

 

add：0
 add：1
 add：2
 [0, 1, 2]
 read：[0, 1, 2]
 

这是一个使用 Python 中的 threading 模块进行多线程编程的例子。
 

代码定义了两个函数 write_data() 和 read_data()，分别实现向一个空列表 my_list 中添加数据和读取列表中的数据。
 

代码中还定义了两个线程 write_thread 和 read_thread，分别用于执行写入数据和读取数据这两个任务。程序的主函数中，首先将 write_thread 和 read_thread 分别指向 write_data() 和 read_data() 函数，并调用 start() 启动 write_thread 线程，等待 1 秒钟后启动 read_thread 线程。
 

在程序执行时，write_thread 和 read_thread 两个线程将同时运行，write_thread 将数据添加到 my_list 列表中，read_thread 读取 my_list 列表并打印输出，由于线程之间并没有进行同步操作，所以可能会出现 race conditions，即写入和读取的顺序不确定。
 

 

7、总结：进程和线程对比
 

 

☆ 关系对比
 

① 线程是依附在进程里面的，没有进程就没有线程。
 

② 一个进程默认提供一条线程，进程可以创建多个线程。
 

 

 

☆ 区别对比
 

① 进程之间不共享全局变量
 

② 线程之间共享全局变量
 

③ 创建进程的资源开销要比创建线程的资源开销要大
 

④ 进程是操作系统资源分配的基本单位，线程是CPU调度的基本单位
 

 

☆ 优缺点对比
 

① 进程优缺点: 优点：可以用多核 缺点：资源开销大
 

② 线程优缺点 优点：资源开销小 缺点：不能使用多核

                

        

        

            

            

            

              

                本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/648713.html
              

              如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！
            

            
            

              
            

          


            
相关文章

          
            
                  

                    

                      

                        

                          
                            微服务 springcloud 05 hystrix框架，降级，可视化Hystrix dashboard 仪表盘，熔断
                        

                      

                      

                        

                          微服务 springcloud 05 hystrix框架，降级，可视化Hystrix dashboard 仪表盘，熔断
                        

                        

                          01.微服务宕机时，ribbon 无法转发请求 关闭 user-service 和 order-service   02.hystrix框架   03.创建hystrix项目，hystrix与ribbon经常一起出现 第一步：复制 sp06-ribbon 项目，命名为sp07-hystrix 选择 sp06-ribbon 项目&#…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            一个Java程序员的C++学习之路
                        

                      

                      

                        

                          一个Java程序员的C++学习之路
                        

                        

                          最近接到了一个Windows客户端开发，需要用到C，由于大学嵌入式学习的时候用到了这种东西，虽然没忘记吧，但是还是打算用一周的时间复习一下，下面是我的复习笔记，当然了，也是基于尚硅谷和黑马的笔记…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            NLP——Ethics伦理
                        

                      

                      

                        

                          NLP——Ethics伦理
                        

                        

                          文章目录 Core NLP ethics conceptsbiasprivacy Group discussionAutomatic Prison Term PredictionAutomatic CV ProcessingLanguage Community Classification Core NLP ethics concepts 
自然语言处理（NLP）的伦理问题是一个日益重要的领域&#xff0c…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            007、体系架构之PD
                        

                      

                      

                        

                          007、体系架构之PD
                        

                        

                          PD PD架构主要功能路由功能 TSO分配TSO概念分配过程时间窗口同步过程 调度总流程信息收集调度的实现调度需求生成调度执行调度调度的基本操作调度的策略 lablelabel与高可用label的配置 PD架构 PD：有高可用和强一致性。 也有leader。使用奇数的节点数量。它需要存储…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            10 分钟理解微服务、容器和 Kubernetes及其关系
                        

                      

                      

                        

                          10 分钟理解微服务、容器和 Kubernetes及其关系
                        

                        

                          什么是微服务？ 
什么是微服务？你应该使用微服务吗？微服务与容器和 Kubernetes 有什么关系？如果这些事情在您的日常生活中不断出现，并且您需要在 10 分钟内进行概述，那么这篇博文适合您。 从根本上讲&#x…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            小红书企业号限流原因有哪些，限流因素
                        

                      

                      

                        

                          小红书企业号限流原因有哪些，限流因素
                        

                        

                          作为企业、品牌在小红书都有官方账号，很多人将注册小红书企业号看作是获取品牌宣推“特权”的必行之举。事实真的如此吗，那为什么小红书企业号限流频发，小红书企业号限流原因有哪些，限流因素。 一、小红书企业号限流真的存在吗 首…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            SpringBoot中Redis的基础使用
                        

                      

                      

                        

                          SpringBoot中Redis的基础使用
                        

                        

                          基础使用 首先引入依赖 <!-- redis依赖--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency><dependency><groupId>redis.clients</g…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            中断处理流程以及程序状态寄存器CPSR的本质
                        

                      

                      

                        

                          中断处理流程以及程序状态寄存器CPSR的本质
                        

                        

                          文章目录 前言一、当前程序状态寄存器&#xff08;CPSR&#xff09;二、异常的分类2.1 7个异常源2.2 异常的优先级2.3 为什么FIQ比IRQ快&#xff1f;2.4 异常与工作模式的区别 三、异常的处理流程3.1 异常处理机制3.2 进入异常处理流程&#xff1a;3.3 退出异常的处理流程&…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            送给蓝初小萌新系列（1）——Linux入侵排查
                        

                      

                      

                        

                          送给蓝初小萌新系列（1）——Linux入侵排查
                        

                        

                          一、linux系统资源 1、linux被入侵的症状 
linux系统资源用户和日志文件和命令篡改启动项和定时任务挖矿脚本分析 
2、linux系统资源 
2.1、CPU内存磁盘 
top -c -o %CPU:查看cpu占用情况&#xff08;按cpu排序&#xff09; top -c -o %MEM:查看内存占用情况&#xff08;按内存…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            兼容性测试如何提高网站的可用性?
                        

                      

                      

                        

                          兼容性测试如何提高网站的可用性?
                        

                        

                          兼容性测试如何提高网站的可用性? 在现代社会&#xff0c;网站已经成为了人们获取信息、进行交流的主要渠道之一。但是&#xff0c;在网站的设计和开发中&#xff0c;往往会存在兼容性问题&#xff0c;导致不同浏览器或设备的用户无法顺利地访问和使用网站&#xff0c;降低了网…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            华为OD机试之最长连续子序列（Java源码）
                        

                      

                      

                        

                          华为OD机试之最长连续子序列（Java源码）
                        

                        

                          最长连续子序列 
题目描述 
有N个正整数组成的一个序列。给定整数sum&#xff0c;求长度最长的连续子序列&#xff0c;使他们的和等于sum&#xff0c;返回此子序列的长度&#xff0c; 
如果没有满足要求的序列&#xff0c;返回-1。 输入描述 
第一行输入是&#xff1a;N个正整数…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            【Spring 核心 | IoC】
                        

                      

                      

                        

                          【Spring 核心 | IoC】
                        

                        

                          IoC IoC 简介定义&#xff1a;IoC 和 DIBeanIoC 容器Ioc IoC容器 IoC 简介 
定义&#xff1a; IoC即控制反转&#xff08;Inversion of Control&#xff0c;缩写为 IoC&#xff09;。IoC又称为依赖倒置原则&#xff08;设计模式六大原则之一&#xff09;。 IoC意味着将你设计好…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            走近mysql运算符|靠它就够啦
                        

                      

                      

                        

                          走近mysql运算符|靠它就够啦
                        

                        

                          这里写目录标题 比较运算符的使用等号运算符<>安全等于不等于运算符<>/!非符号类型的运算符BETWEEN ANDINLIKEPEGEXP/ RLIKE 逻辑运算符使用位运算符 比较运算符的使用 
等号运算符 判断等号两边的值&#xff0c;字符串或表达式是否相等&#xff0c;如果相等则返回…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            Hadoop/Hive/Spark小文件处理
                        

                      

                      

                        

                          Hadoop/Hive/Spark小文件处理
                        

                        

                          什么是小文件&#xff1f; 
小文件指的是文件size比HDFS的block size小很多的文件。Hadoop适合处理少量的大文件&#xff0c;而不是大量的小文件。 
hadoop小文件常规的处理方式 
1、小文件导致的问题 
首先&#xff0c;在HDFS中&#xff0c;任何block&#xff0c;文件或者目录…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            吴恩达471机器学习入门课程1第1周——梯度下降
                        

                      

                      

                        

                          吴恩达471机器学习入门课程1第1周——梯度下降
                        

                        

                          文章目录 1加载数据集2计算COST(均值平方差&#xff0c;1/2m(y_pre - y))3计算梯度4画出成本曲线5梯度下降 import math, copy
import numpy as np
import matplotlib.pyplot as plt
plt.style.use(./deeplearning.mplstyle)
from lab_utils_uni import plt_house_x, plt_conto…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            华为OD机试真题 JavaScript 实现【找出通过车辆最多颜色】【2023Q1 100分】
                        

                      

                      

                        

                          华为OD机试真题 JavaScript 实现【找出通过车辆最多颜色】【2023Q1 100分】
                        

                        

                          一、题目描述 
在一个狭小的路口&#xff0c;每秒只能通过一辆车&#xff0c;假如车辆的颜色只有3种&#xff0c;找出n秒内经过的最多颜色的车辆数量。 
三种颜色编号为0、1、2。 
二、输入描述 
第一行输入的是通过的车辆颜色信息 [0 1 1 2] 代表4秒钟通过的车辆颜色分别是0 1…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            手把手教你使用CONN（预处理）
                        

                      

                      

                        

                          手把手教你使用CONN（预处理）
                        

                        

                          CONN软件介绍 
&#xff08;1&#xff09;CONN是一个基于Matlab的跨平台软件&#xff0c;用于计算、显示和分析功能磁共振成像&#xff08;fcMRI&#xff09;中的功能连通性。也可用于静息状态数据&#xff08;rsfMRI&#xff09;以及任务相关设计。 
&#xff08;2&#xff09…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            Vue的组合式
                        

                      

                      

                        

                          Vue的组合式
                        

                        

                          1. 概念 
选项式API&#xff1a;将相同类型的代码放在一起&#xff08;比如所有数据、所有用到的方法等等&#xff09;当代码业务板块过多时&#xff0c;不方便写代码和后期维护 
组合式API&#xff1a;将同一业务的相关代码放在一起&#xff08;比如说数据&#xff0c;方法&am…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            什么是同源策略
                        

                      

                      

                        

                          什么是同源策略
                        

                        

                          文章目录 同源策略同源策略的目的同源策略分类 同源策略 
同源策略是指浏览器的一种安全机制&#xff0c;用于限制来自不同源&#xff08;即域、协议或端口&#xff09;的文档或脚本之间的交互操作。 
根据同源策略&#xff0c;浏览器只允许当前网页与同一源下的其他资源进行交…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            Linux之CentOS 7.9部署Oracle 11g r2 静默安装实测验证（无桌面模式）
                        

                      

                      

                        

                          Linux之CentOS 7.9部署Oracle 11g r2 静默安装实测验证（无桌面模式）
                        

                        

                          前言&#xff1a;因前段时间一直部署的windows环境的oracle&#xff0c;这次记录下linux下的部署方式&#xff0c;当然还有更多的其他部署&#xff0c;大家可根据自身环境及学习来了解。一般静默安装主要还是要提前准备源包&#xff0c;还有很多依赖包&#xff0c;另外就是配置…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
       
      
        

        

          

            



                
                
                

            

          

          

            



              
推荐文章

              
            

          


          

            


                
                
                
            

          

          

            

              
最新文章

              
            

          

          

            

            
            
            
            

          

        

      

    

    

      

        

                    Copyright @ 2022~2023