python如何理清进程和线程的学习思路?

python如何理清进程和线程的学习思路?

学习Python的进程和线程时，我觉得可以遵循以下思路：

1. 理解基本概念：

   • 进程：进程是操作系统分配资源的基本单位。每个进程都有自己独立的内存空间和系统资源，相互之间互不干扰。进程间的通信（IPC，Inter-Process Communication）通常需要使用特定的机制。
   • 线程：线程是操作系统调度的基本单位，它是进程中的一个实体，是被系统独立调度和分派的基本单位。一个进程可以包含多个线程，这些线程共享该进程的内存空间和资源。

2. 理解进程与线程的区别：

   • 进程有自己独立的内存空间，而线程则共享其所属进程的内存空间。
   • 进程之间的通信相对复杂，而线程间可以直接读写进程级别的共享内存。
   • 创建新进程需要复制父进程的内存空间，因此开销较大；而线程的创建和销毁开销较小。
   • 多进程程序更健壮，多线程程序执行效率可能更高（但也依赖于具体的应用场景和硬件环境）。

3. 学习Python中的多进程和多线程库：

   • 对于多进程，Python标准库提供了multiprocessing模块。你可以使用这个模块来创建、管理和同步多个进程。

     • """
       解释:对于一个py文件,我们的main函数就是一个主进程,那么主进程没有创建子进程和子线程的时候,是自上而下顺序执行的
       """
       # 1.创建多进程的三个步骤(导包--创建子进程-开启子进程)
       
       # 1.1导包
       import multiprocessing
       
       # 定义函数1
       def run():
           print('我会跑')
       
       # 定义函数2
       def eat():
           print('我会吃')
       
       # main 函数里创建进程
       if __name__ == '__main__':
           # 1.2创建子进程对象
           p1 = multiprocessing.Process(target=run)
           p2 = multiprocessing.Process(target=eat)
       
           # 1.3开启子进程
           p1.start()
           p2.start()
       
       

   • 对于多线程，Python标准库提供了threading模块。这个模块允许你创建和管理线程，并提供了基本的线程同步机制。

     • """
       解释:对于一个py文件,我们的main函数就是一个主进程,那么主进程没有创建子进程和子线程的时候,是自上而下顺序执行的
       """
       # 1.创建多线程的三个步骤(导包--创建子线程-开启子进程)
       
       # 1.1导包
       import threading
       
       
       # 1.1定义函数1
       def run():
           print('我会跑')
       
       
       # 1.2定义函数2
       def eat():
           print('我会吃')
       
       
       # main 函数里创建线程
       if __name__ == '__main__':
           # 1.2创建子线程对象
           t1 = threading.Thread.(target=run)
           t2 = threading.Thread.(target=eat)
       
           # 1.3开启子线程
           t1.start()
           t2.start()
       
       

4. 理解并发与并行：

   • 并发：多个任务交替执行，在一段时间内都得以进行。在单核CPU上，多线程实际上是并发的，因为同一时间只能执行一个线程。
   • 并行：多个任务同时执行。在多核CPU上，多个线程或进程可以真正实现并行执行。

5. 掌握同步机制(针对于线程来说的)：

   • 当多个线程同时访问全局变量时，为了避免数据竞争和不一致，需要使用同步机制。常见的同步机制包括锁（互斥锁、读写锁等）、条件变量、信号量等。

     """
     解释:
     
     1.原因:互斥锁的加装是因为,对于一个进程里的多个线程来说是共享全局变量的,所以就出现避免数据竞争和不一致现象
     
     2.解决方式:处理办法就是,给操作同一个全局变量的代码区增加互斥锁
     
     3.加互斥锁的三个步骤:
         1.创建互斥锁对象  mutex = threading.Lock()
         2.获取锁  mutex.acquire()
         3.释放锁  mutex.release()
     
     """
     # 1.1导包
     import threading
     
     # 定义一个全局变量
     sum1 = 0
     mutex = threading.Lock()
     
     # 1.1定义函数1
     def run():
         mutex.acquire()
         for i in range(1000000):
             global sum1
             sum1 += 1
         mutex.release()
         print(f"在run函数里sum1值为{sum1}")
     
     # 1.2定义函数2
     def eat():
         mutex.acquire()
         for i in range(1000000):
             global sum1
             sum1 += 1
         mutex.release()
         print(f"在eat函数里sum1值为{sum1}")
     
     # main 函数里创建线程
     if __name__ == '__main__':
         # 1.2创建子线程对象
         t1 = threading.Thread(target=run)
         t2 = threading.Thread(target=eat)
     
         # 1.3开启子线程
         t1.start()
         t2.start()
     
     

6. 实践与应用：

   • 通过编写简单的多进程和多线程程序来加深理解。例如，可以使用多线程或多进程下载一个网页、处理图像等。
   • 了解何时使用多进程、何时使用多线程。通常，对于I/O密集型任务（如网络请求、文件读写等），多线程可能更合适；而对于计算密集型任务（如大量数学计算），多进程可能更有效，因为Python的全局解释器锁（GIL）会限制同一时刻只有一个线程在执行Python字节码。

7. 性能调优与问题诊断(扩展小白建议先学习上述6步):

   • 学习如何使用性能分析工具（如cProfile、timeit等）来评估和优化多进程/多线程程序的性能。

   • 了解常见的并发问题和调试技巧，如死锁、活锁、资源争用等，并学会如何避免和解决这些问题。

     性能调优可以参考:
     https://baijiahao.baidu.com/sid=1681944767760237007&wfr=spider&for=pc
     最后:如果以pc设备为例,多进程比作设备中的同时运行的多个应用软件,那么我们就可以把线程理解成一个应用软件中的多个功能同时运行