import time
import os
from multiprocessing import Process
def func ():
    time.sleep(1)
    print(1,os.getpid(),os.getppid())

if __name__ == '__main__':
    #异步执行func,在一秒钟的时间通过生成多个子进程来执行多个func
    #1.先实例化
    #2.实例化对象.start()
    # 目标函数：target=
    Process(target=func).start()   #process类通知操作系统要为当前代码快在开辟一个进程，是异步过程

使用Process模块

import time
from multiprocessing import Process
class Myprocess(Process): #继承Process类
    def __init__(self,name):  #重新父类的__init__方法
        super().__init__()
        self.name =name

    def run(self):  #必须是run函数名
        print(os.getpid(),os.getppid(),'我爱你%s' % self.name)
        time.sleep(3)
if __name__ == '__main__':
    start_time = time.time()
    p1 = Myprocess('kobe')
    p2 = Myprocess('kobe')
    p3 = Myprocess('kobe')
    p1.start()
    p2.start()
    p3.start()
    p1.join()  #阻塞，直到p1对应的进程结束之后，才结束阻塞，是异步阻塞，阻塞等待一个子进程结束
    p2.join()
    p3.join()
    print(time.time()-start_time)
    ##阻塞一个子进程：p.join()
    #阻塞多个子进程，将子进程加入到列表，然后分别阻塞
'''
10600 9384 我爱你kobe
10448 9384 我爱你kobe
10032 9384 我爱你kobe
1.1659998893737793
从上面结果来看，我们知道join也是异步阻塞的，在同一秒钟分别执行了p1,p2,p3的time.sleep()
和我本来预想的要阻塞3s+是结果是不同的
'''

继承Process类创建多进程

from threading import Thread
import os
def func():
    print('in fucn ',os.getpid())
print('in main ',os.getpid())
Thread(target=func).start()
#两个打印pid是一样的，说明线程是由进程产生的

使用Thread模块

from threading import Thread
import time
class Sayhi(Thread):
    def __init__(self,name):
        super().__init__()   #重写父类的__init__方法
        self.name=name
    def run(self):
        time.sleep(2)
        print('%s say hello' % self.name)

if __name__ == '__main__':
    t = Sayhi('kobe')
    t.start()
    print('主线程')

继承Thread类创建多线程

线程和进程的区别
   进程： 数据隔离(但是也可以丛进程间的数据共享)  开销大
   线程： 数据共享 开销小
   cpython中多进程可以使用多核(并发编程)，多线程不可以使用多核　 通俗来讲：比如有个4核(cpu)的主机，当使用多进程的时候，系统会自动的根据进程调度算法来分配今晨给资源，然后分别在不同的cpu上面执行，这就是多进程　　　　　　　　　　　　　　　　　　　　当时用多线程的时候，由于GIL锁的存在，多线程始终是在一个cpu上面执行，造成闲的cpu闲死，忙的cpu忙死

#线程
from threading import Thread
import os
import time
def func():
    print('in func',os.getpid())
tt = Thread(target=func)
tt.start()
print('in main', os.getpid())#进程
from multiprocessing import Process
import os
import time
def func():
    print('in func',os.getpid())
if __name__ == '__main__':
    tt = Process(target=func)
    tt.start()
    print('in main', os.getpid())

注意：线程不需要if __name__ == '__main__':　　进程和线程的创建原理不同，所以不需要if __name__ == '__main__'，但是可以使用这种方式　　因为新的线程是在主线程的内存中，所以新的线程和主线程共享同一段代码，不需要import导入，也就不存在子线程中又重复一次创建线程的过程

二者pid对比：　　在进程内，父进程创建的所有子进程都是不同的pid，说明父进程只是创建了子进程并在子进程执行代码的时候会import 父进程文件，其余父子相互之间独立，使用不同的内存空间，所以pid不同　　在线程中，主线程和子线程的pid完全相同，说明子线程是在主线程内部创建出来的，并且主线程会所有子线程的结束才结束。

#线程开销时间
import time
from threading import Thread
def func(item):
  item +=1
if __name__ == '__main__':
    start = time.time()
    t_l = []
    for i in range(100):
        t = Thread(target=func,args=(i,))
        t.start()
        t_l.append(t)
    for t in t_l:
        t.join()
    print(time.time()-start)

#进程开销时间
import time
def func(item):
  item +=1
from multiprocessing import Process
if __name__ == '__main__':
    start = time.time()
    t_l = []
    for i in range(100):
        t = Process(target=func,args=(i,))
        t.start()
        t_l.append(t)
    for t in t_l:
        t.join()
    print(time.time()-start)

注意：为什么要join()?　　因为要等待所有线程或进程全部都运行完，才计算时间　　不能再func()函数里面写join()方法，这样就是同一时间只有一个线程或进程在之心，变成同步的了

二者开销对比：　　分别执行上面代码，能够看到，做相同的操作，100个进程使用的时间比100个线程使用时间更长　　说明进程在创建\销毁\上下文切换之间，需要更多的时间和系统资源

#多个线程之间共享全局变量
from threading import Thread
item = 0
def func():
    global item
    item +=1
f_l= []
for ii in range(1000):
    tt = Thread(target=func)
    tt.start()
    f_l.append(tt)

[x.join() for x in f_l ]
print(item)

#多个进程之间数据不共享(但是可以通过Manager来实现共享)
from multiprocessing import Process,Manager
item = 0
def func():
    global item
    item +=1
if __name__ == '__main__':
    f_l= []
    for ii in range(10):
        tt = Process(target=func)
        tt.start()
        f_l.append(tt)
    [x.join() for x in f_l ]
    print(item)

二者数据是否共享：　　在线程内，主线程内的全局变量对于子线程来说完全共享，其他不是全局的就不共享　　在进程内，父进程和子线程的数据完全隔离，因为父子之间分别有不同的内存空间。