python 进程与线程的概念，以及联系与区别，以及进程池和多线程的使用

python 进程与线程的概念，以及联系与区别，以及进程池和多线程的使用

进程可以被称为执行的程序，一个进程拥有完整的数据空间和代码空间，每一个进程的地址空间都是独立的，进程之间不能共享数据。

线程是进程的一部分，也可以称为mini 进程。在同一个进程中的线程共用同一个地址空间，单有自己独立的堆栈和局部变量。所以除了堆栈中的数据，其余所有数据都可以共享。

如果再形象点就引用一哥们的比喻，很形象：

比如一个公司，有很多不同的部门，每个部门不在 同一个城市，而每个部门都有许多的员工。

公司就好比是一个CPU，不同的部门就相当于不同的进程，他们是你干你的，我干我的，所利用的空间不同。想共享些什么数据，需要email与传真；而一个部门的每个员工，相当于不同的线程，共在同一个部门，所有东西都可以共享。假如说一个人在用打印机，也就     是数据进入堆栈了，我再用打印机，你就用不了了，得等。

联系：

 进程包括线程，可以有一个或者多个

区别：

 1.进程有独立的地址空间，多进程较稳定，因为其中一个出现状况不影响另外一个；同一个进程的多个线程，共用地址空间，多线程相比于多进程，稳定性要差，因为一个线程出现问题会严重影响其他线程。

 2.进程之间需要共享数据，要利用进程间通讯；同一个进程中的线程不需要。

3.进程只是资源分配的最小单位；线程是执行的最小单位，也就是说实际执行的是线程。

进程池：

from multiprocessing import Pool
import time
import random
import os


def processing(p):
    print("Current Prcess name is {}, pid is {}".format(p, os.getpid()))
    t = random.random()
    time.sleep(t)
    print("Current Prcess is sleep{}, name is {}".format(t,p))


if __name__ == "__main__":
    print("Main process pid is {}".format(os.getpid()))
    # processing("test")
    # 声明进程池
    p = Pool(4)
    for i in range(7):
        #将需要执行的动作添加进进程池
        p.apply_async(processing,args=("test"+str(i),))
    print("Add sub processing in Pool")
    # 进程池关闭
    p.close()
    # 主进程阻塞
    p.join()
    print("sub process end")
    print("Main process is end")

多线程：一个进程里可以包含多个线程，线程之前是可以共享资源的，所以假如不加线程锁会导致两个线程同时修改一个值的状框，例如设置一个变量，默认值为0，使用多线程，不加线程锁，循环修改值，最后得到的值，可能会是18888

import threading
import os

balance = 0


def change(number):
    global balance
    balance = balance + number
    balance = balance - number


def change_account(number):
    for i in range(2000000):
        change(number)


t = threading.Thread(target=change_account, args=(5,))
t2 = threading.Thread(target=change_account, args=(18,))
t.start()
t2.start()
t.join()
t2.join()
print("balance:" , balance)

加线程锁，目的是为了给这个线程上锁，我在修改这个变量的时候，其他线程无法进行操作，等我修改 完了在进行释放，其他线程才可以对它进行操作。如此上面的结果是20000

import threading
# balance = 0
# # 线程锁
# lock = threading.Lock()
#
#
# def change_it(n):
#     # 先存后取，结果应该为0:
#     global balance
#     balance = balance + n
#     balance = balance - n
#
#
# def run_thread(n):
#     for i in range(2000000):
#         # change_it(n)
#         lock.acquire()
#         try:
#             change_it(n)
#         finally:
#             lock.release()
#
#
# t1 = threading.Thread(target=run_thread, args=(5,))
# t2 = threading.Thread(target=run_thread, args=(8,))
# t1.start()
# t2.start()
# t1.join()
# t2.join()
# print(balance)