进程、线程与协程的简单介绍以及使用python如何创建线程

进程

进程，它是CPU资源分配和调度的独立单位。进程一般由程序、数据集、进程控制块三部分组成。我们编写的程序用来描述进程要完成哪些功能以及如何完成；数据集则是程序在执行过程中所需要使用的资源；进程控制块用来记录进程的外部特征，描述进程的执行变化过程，系统可以利用它来控制和管理进程，它是系统感知进程存在的唯一标志。 进程的局限是创建、撤销和切换的开销比较大。

进程（任务）：
  - 在计算机中，其实进程就是一个任务。
  - 在操作系统中，进程是程序执行和资源分配的基本单元。
- 单核CPU实现多任务
  - 只是将CPU的时间快速的切换和分配到不同的任务上。
  - 主频足够高，切换足够快，人的肉眼无法分辨而已。
- 多核CPU实现多任务
  - 如果任务的数量不超过CPU的核心数，完全可以实现一个核心只做一个任务。
  - 在操作系统中几乎是不可能的，任务量往往远远大于核心数。

  - 同样采用轮训的方式，轮流执行不同的任务，只是做任务的'人'有多个而已。

进程锁

- 问题：当多个进程操作同一资源时，可能会造成混乱，甚至错误。如：写文件等

- 解决：通常我们可以通过加锁的方式进行解决

 进程池

- 说明：创建少量的进程可以通过创建Process对象完成。如果需要大量的进程创建和管理时就比较费劲了。

- 解决：可以通过进程池加以解决，而且可以通过参数控制进程池中进程的并发数，提高CPU利用率

操作：
  1.创建进程池
  2.添加进程
  3.关闭进程池
  4.等待进程池结束

  5.设置回调

线程以及多线程

线程，有时被称为轻量级进程,是程序执行流的最小单元。线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。线程有就绪、阻塞和运行三种基本状态。每一个程序都至少有一个线程，若程序只有一个线程，那就是程序本身。由线程ID、程序计数器、寄存器集合和堆栈共同组成。一个进程可以包含多个线程。
线程的优点是减小了程序并发执行时的开销，提高了操作系统的并发性能，缺点是线程没有自己的系统资源，只拥有在运行时必不可少的资源，但同一进程的各线程可以共享进程所拥有的系统资源，如果把进程比作一个车间，那么线程就好比是车间里面的工人。不过对于某些独占性资源存在锁机制，处理不当可能会产生“死锁”。

线程是程序中一个单一的顺序控制流程。进程内有一个相对独立的、可调度的执行单元，是系统独立调度和分派CPU的基本单位指令运行时的程序的调度单位。在单个程序中同时运行多个线程完成不同的工作，称为多线程。

线程简介

- 在一个进程中，若想做多个子任务，我们把这些子任务称为线程。
- 线程可以理解为轻量级的进程。
- 进程之间的数据是独立的，而一个进程下的线程数据是共享的。
- 线程是CPU分配时间的最小单位。进程和线程的调度都是操作系统的事。
- 一个进程默认都有一个线程，我们称为主线程。

### 线程模块

- _thread：低级模块
- threading：高级模块，是对_thread的封装
- 以后建议大家使用高级模块threading

线程、进程

进程是资源集合，线程是使用资源去做一些事情。

线程和进程的区别在于，子进程和父进程有不同的代码和数据空间，而多个线程则共享数据空间，每个线程有自己的执行堆栈和程序计数器为其执行上下文。多线程主要是为了节约CPU时间，发挥利用，根据具体情况而定。线程的运行中需要使用计算机的内存资源和CPU。通常在一个进程中可以包含若干个线程，它们可以利用进程所拥有的资源。在引入线程的操作系统中，通常都是把进程作为分配资源的基本单位，而把线程作为独立运行和独立调度的基本单位。由于线程比进程更小，基本上不拥有系统资源，故对它的调度所付出的开销就会小得多，能更高效的提高系统内多个程序间并发执行的程度，从而显著提高系统资源的利用率和吞吐量。因而近年来推出的通用操作系统都引入了线程，以便进一步提高系统的并发性，并把它视为现代操作系统的一个重要指标。

线程何时切换：在python3中根据固定的时间间隔来切换线程。

线程、协程

子程序，或者称为函数，在所有语言中都是层级调用，比如A调用B，B在执行过程中又调用了C，C执行完毕返回，B执行完毕返回，最后是A执行完毕。所以子程序调用是通过栈实现的，一个线程就是执行一个子程序。

子程序调用总是一个入口，一次返回，调用顺序是明确的。而协程的调用和子程序不同。

协程看上去也是子程序，但执行过程中，在子程序内部可中断，然后转而执行别的子程序，在适当的时候再返回来接着执行。

注意，在一个子程序中中断，去执行其他子程序，不是函数调用，有点类似CPU的中断。比如子程序A、B：

但是在A中是没有调用B的，所以协程的调用比函数调用理解起来要难一些。

看起来A、B的执行有点像多线程，但协程的特点在于是一个线程执行，那和多线程比，协程有何优势？

最大的优势就是协程极高的执行效率。因为子程序切换不是线程切换，而是由程序自身控制，因此，没有线程切换的开销，和多线程比，线程数量越多，协程的性能优势就越明显。

第二大优势就是不需要多线程的锁机制，因为只有一个线程，也不存在同时写变量冲突，在协程中控制共享资源不加锁，只需要判断状态就好了，所以执行效率比多线程高很多。

因为协程是一个线程执行，那怎么利用多核CPU呢？最简单的方法是多进程+协程，既充分利用多核，又充分发挥协程的高效率，可获得极高的性能。

创建线程Thread

        （1）面向过程的方式创建线程
            t = threading.Thread(target=xxx, name=xxx, args=(xx, xx))
            target: 线程启动之后要执行的函数
            name: 线程的名字  
            获取线程名字 ：threading.current_thread().name
            args: 主线程向子线程传递参数
            t.start() : 启动线程
            t.join() : 让主线程等待子线程结束
        （2）面向对象的方式创建线程
            定义一个类，继承自threading.Thread,重写一个方法run方法，需要线程名字、传递参数，重写构造方法，在重写构造方法的时候，一定要注意手动调用父类的构造方法。
       （3） 线程需要进行同步
            线程之间共享全局变量，很容易发生数据的紊乱问题，这个时候要使用线程锁，线程之间需要进行抢，谁抢到，谁就能使用，上锁之后，其他线程无法进行使用。
            创建锁
                suo = threading.Lock()
            上锁
                suo.acquire()
            释放锁
                suo.release()

示例：

import threading
import time

def th1(a):
    print('线程为%s,接收过来的参数为%s' % (threading.current_thread().name, a))
    for x in range(1, 6):
        print('在做第一件事')
        time.sleep(1)

def th2(a):
    print('线程为%s,接收过来的参数为%s' % (threading.current_thread().name, a))
    for x in range(1, 6):
        print('在做第二件事')
        time.sleep(1)

def main():
    a = '小明'
    # 创建做第一件事的线程
    th1 = threading.Thread(target=sing, name="第一件事", args=(a, ))
    # 创建做第二件事的线程
    th1 = threading.Thread(target=dance, name="第二件事", args=(a, ))
    # 启动线程
    th1.start()
    th2.start()
    # 让主线程等待子线程结束之后在结束
    th1.join()
    th2.join()
    # 这里是主线程在运行
    print('这是主线程在执行！')

if __name__ == '__main__':
    main()