Python 之并发编程之线程上

一.线程概念

进程是资源分配的最小单位

线程是计算机中调度的最小单位

　多线程（即多个控制线程）的概念是，在一个进程中存在多个控制线程，多个控制线程共享该进程的地址空间，相当于一个车间内有多条流水线，都共用一个车间的资源。（一个进程里面开多个线程（共享同一个进程里面的内存空间））

#线程的缘起

资源分配需要分配内存空间,分配cpu:

分配的内存空间存放着临时要处理的数据等,比如要执行的代码,数据

而这些内存空间是有限的,不能无限分配

目前配置高的主机,5万个并发已是上限.线程概念应用而生.

#线程的特点

线程是比较轻量级,能干更多的活,一个进程中的所有线程资源是共享的.

一个进程至少有一个线程在工作

### 线程的缺陷

#线程可以并发,但是不能并行(即可以1个cpu执行,不能多个cpu一起执行)

#原因:

   python是解释型语言,执行一句编译一句,而不是一次性全部编译成功,不能提前规划,都是临时调度

   容易造成不同的cpu却反复执行同一个程序.所以加了一把锁叫GIL

   全局解释器锁(Cpython解释器特有) GIL锁:同一时间一个线程只能被一个cpu执行

#想要并行的解决办法:

    (1)用多进程间接实现线程的并发

    (2)换一个Pypy,Jpython解释器

#程序分为计算密集型和io密集型

对于计算密集型程序会过度依赖cpu,但网页,爬虫,OA办公,这种io密集型的程序里,python绰绰有余

### 线程相关函数

线程.is_alive()    检测线程是否仍然存在

线程.setName()     设置线程名字

线程.getName()     获取线程名字

currentThread().ident 查看线程id号

enumerate()        返回目前正在运行的线程列表

activeCount()      返回目前正在运行的线程数量

pyhton上是一个任务首先在一个进程上执行，在多个线程内循环执行，然后换到另外一个进程再继续执行，再循环线程，不停的切换，不能进行并行，可以的是进程并发操作，就是这个任务先暂停一下，先换成另外一个任务进程执行。

因为python中有一个GIL锁。

而java上的线程是，多个任务在多个线程上进行执行。不需要不停地进行更换，线程。

二.线程的基本语法

在下面开始之前都需要导入：

from threading import Thread

from multiprocessing import Process

import os, time, random

1.一个进程可以多个线程

def func(num):

    time.sleep(random.uniform(0.1, 1))

    print("子线程", num, os.getpid())

for i in range(10):

    t = Thread(target=func, args=(i,))

    t.start()

2.并发多线程和多进程的速度对比? 多线程更快

def func(i):

    #time.sleep(random.uniform(0.1,1))

    print("子线程",i,os.getpid())

if __name__ == "__main__":

    # 1. 计算多线程的执行速度

    startime = time.perf_counter()

    lst= []

    for i in range(1000):

        t = Thread(target=func,args=(i,))

        t.start()

        lst.append(t)

    for i in lst:

        i.join()

    print("程序执行结束")

    endtime = time.perf_counter()

    print(endtime-startime) #0.2554951

    # 2.计算多进程的执行速度

    startime = time.perf_counter()

    lst = []

    for i in range(1000):

        p = Process(target=func,args=(i,))

        p.start()

        lst.append(p)

    for i in lst:

        i.join()

    print("程序执行结束")

    endtime = time.perf_counter()

    print(endtime-startime) #66.66021479999999

3.多线程共享同一份进程资源

最后得出的数值为0，说明资源共享。

例：

num = 100

lst = []

def func():

    global num

    num -= 1

for i in range(100):

    t = Thread(target=func)

    t.start()

    lst.append(t)

for i in lst:

    i.join()

print(num)

4.线程相关函数

线程.is_alive()   检测线程是否仍然存在

线程.setName()    设置线程名字

线程.getName()    获取线程名字

例：

def func():

    #time.sleep(0.1)

    pass

t = Thread(target=func)

t.start()

print(t.is_alive()) # False

print(t.getName()) #Thread-1

t.setName("hsz")

print(t.getName()) # hsz

time.sleep(2)

print(t.is_alive()) #False,线程已经结束了所有False

1.currentThread().ident 查看线程id

2.enumerate()       返回目前正在运行的线程列表

3.activeCount()     返回目前正在运行的线程数量

# 1.currentThread().ident 查看线程id号

from threading import current_thread

def func():

    print("子线程:",current_thread().ident)

t = Thread(target=func)

t.start()

print("主线程:",current_thread().ident)

# 2.enumerate() 返回目前正在运行的线程列表

from threading import current_thread

from threading import enumerate

def func():

    print("子线程:", current_thread().ident)

    time.sleep(0.5)

for i in range(10):

    t = Thread(target=func)

    t.start()

print(len(enumerate()))

time.sleep(3)

# 10个子线程 + 1个主线程  =  11个正在运行的线程

print(enumerate())

print(len(enumerate()))

# 3.activeCount() 返回目前正在运行的线程数量

from threading import current_thread

from threading import activeCount

def func():

    print("子线程:", current_thread().ident)

    time.sleep(0.5)

for i in range(10):

    t = Thread(target=func)

    t.start()

print(activeCount())

三.守护线程

 守护线程 :等待所有线程执行结束之后,在自动结束,守护所有线程.

例：

from threading import Thread

import time

def func1():

    while True:

        time.sleep(0.5)

        print("我是守护线程")   

def func2():

    print("func2 -> start")

    time.sleep(3)

    print("func2 -> end")

t1 = Thread(target=func1)

# setDaemon 讲t1线程对象变成守护线程

t1.setDaemon(True)

t1.start()

t2 = Thread(target=func2)

t2.start()

time.sleep(5)

print("主线程执行结束")