并发编程

并发编程是网络编程中必须考虑的问题,实现并发的方式有多种:多进程,多线程,IO多路复用.

python中调用的是操作系统的线程和进程.

进程:

　　进程表示资源分配的基本单位,是调度运行的基本单位.例如,用户运行一个程序时,系统就创建一个进程,为它分配资源,然后放入进程就绪队列.进程调度程序选中它,为它分配CPU,进程就开始运行.进程是系统中的并发执行单位.进程之间有数据隔离,进程是为了提供线程工作的环境.

线程:

　　线程是进程中执行运算的最小单位,也是执行CPU调度的基本单位.线程属于进程,线程运行在进程空间内,同一进程产生的线程共享同一内存空间,当进程退出的时候,该进程产生的所有线程都会被强制退出并清除.线程可与属于同一进程的其他线程共享进程拥有的全部资源,线程本身基本上不拥有系统资源,只拥有一点在运行中必不可少的信息.

进程和线程的关系:

　　1.一个线程只能属于一个进程,一个进程可以拥有多个线程,至少有一个线程.线程是操作系统可识别的最小执行和调度单位.

　　2.资源分配给进程,同一个进程的所有线程共享该进程的所有资源.同一进程中的多个线程共享代码段(代码和常量),数据段(全局变量和静态变量),扩展段(堆存储).每个线程拥有自己的栈段,栈段又叫运行时段,用来存放所有的局部变量和临时变量.

　　3.真正在CPU上运行的是线程.

　　4.线程在执行过程中,需要协作同步.不同进程的线程间要利用消息通信的办法实现同步.

threading模块

　　threading模块建立在thread模块之上.thread模块以低级,原始的方式来处理和控制线程,而threading模块通过对thread进行二次封装,提供了更方便api来处理线程.

　　thread方法说明:

t.start():      激活线程
t.getName():    获取线程名称
t.setName():    设置线程名称
t.name:         获取或设置线程名称
t.is_alive():   判断线程是否为激活状态
t.isAlive():    判断线程是否为激活状态
t.setDaemon():  主线程执行完,等待子线程执行完后,程序停止
t.isDaemon():   判断是否为守护线程
t.ident():      获取线程的标识符.线程标识符是一个非零整数,只有在调用了start方法后该属性才有效,否则返回None
t.join():       逐个执行每个线程,执行完毕后继续往下执行,该方法使得多个多线程变得无意义(可以设置主线程的等待时间)
t.run():        线程被CPU调度后自动执行线程对象的run方法

def func(arg):
    print(arg)
t = threading.Thread(target=func,args=(11,))
t.start()
print('end')
结果:
11
end

import threading
import time
def func(arg):
    time.sleep(arg)
    print(arg)
t1 = threading.Thread(target=func,args=(3,))
t1.start()
t2 = threading.Thread(target=func,args=(9,))
t2.start()
print('end')
结果:
end
3
9

import threading
import time
def func(arg):
    time.sleep(2)
    print(arg)
t1 = threading.Thread(target=func,args=(3,))
t1.setDaemon(True)    #主线程不等待,主线程终止则子线程终止
t1.start()
t2 = threading.Thread(target=func,args=(9,))
t2.setDaemon(True)
t2.start()
print('end')
结果:
end

import threading
import time
def func(arg):
    time.sleep(0.01)
    print(arg)
print('创建子线程t1')
t1 = threading.Thread(target=func,args=(3,))
t1.start()
# 无参数，让主线程在这里等着，等到子线程t1执行完毕，才可以继续往下走。
# 有参数，让主线程在这里最多等待n秒，无论是否执行完毕，会继续往下走。
t1.join(2)
print('创建子线程t2')
t2 = threading.Thread(target=func,args=(9,))
t2.start()
t2.join(2) # 让主线程在这里等着，等到子线程t2执行完毕，才可以继续往下走。
print('end')
结果:
创建子线程t1
3
创建子线程t2
9
end

def func(arg):
    # 获取当前执行该函数的线程的对象
    t = threading.current_thread()
    # 根据当前线程对象获取当前线程名称
    name = t.getName()
    print(name,arg)
t1 = threading.Thread(target=func,args=(11,))
t1.setName('admin')
t1.start()
t2 = threading.Thread(target=func,args=(22,))
t2.setName('root')
t2.start()
print('end')
结果:
admin 11
rootend
 22

def func(arg):
    print(arg)
t1 = threading.Thread(target=func,args=(11,))
t1.start()
# start 是开始运行线程吗？不是
# start 告诉cpu，我已经准备就绪，你可以调度我了。
print(123)
结果:
11
123

#常见方式
def func(arg):
    print(arg)
t1 = threading.Thread(target=func,args=(11,))
t1.start()
#继承方式
class MyThread(threading.Thread):
    def run(self):
        print(11111,self._args,self._kwargs)
t1 = MyThread(args=(11,))
t1.start()
t2 = MyThread(args=(22,))
t2.start()
print('end')

python多线程情况下:

　　计算密集型操作: 效率低(GIL锁)

　　IO操作: 效率高

python多进程情况下:

　　计算密集型操作: 效率高(浪费资源),不得已

　　IO操作:效率高(浪费资源)

多线程与多进程的使用场景:

　　IO密集型使用多线程: 文件/输入输出/socket网络通信

　　计算密集型使用多进程

python中线程和进程(GIL锁)

　　GIL锁,全局解释器锁.用于限制一个进程中同一时刻只有一个线程被CPU调度.(GIL默认执行100个CPU指令(过期时间))