2018.11.09python学习第三十七天

Posted CUIHUANIHAO

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了2018.11.09python学习第三十七天相关的知识,希望对你有一定的参考价值。

一:线程理论

1.什么是线程
    在传统操作系统中,每个进程用一个地址空间,而且默认就有一个控制线程
    线程顾名思义,就是一条流水线工作的过程,一条流水线必须属于一个车间,一个车间的工作过程是一个进程。
    车间负责把资源整合到一起,是一个资源单位,而一个车间内至少有一条流水线
    流水线的工作需要电源,电源就相当于CPU
    所以,进程只是用来把资源集中到一起(进程只是一个资源单位,或者说是资源集合),而线程才是CPU上的执行单位。
    多线程(即多个控制线程)的概念是,在一个进程中存在多个控制线程,多个控制线程共享该进程的地址空间,相当于一个车间内有多条流水线,都共用一个车间资源。
2.线程与进程的区别
1.# 线程的创建开销小
2.# 线程共享创建它的进程的namespace,进程有自己的namespace
3.# 线程可以直接访问其进程的数据,而进程拥有自己父进程的数据的副本
4.# 线程是CPU执行单位,而进程是一个资源单位

二:开启线程的两种方式

方式一:导入模块
from threading import Thread

def task():
    print(‘m‘)

# 创建线程对象
t = Thread(target = task)
# 执行线程
t.start()
方式二:创建类
from threading import Thread
class Mythread(Thread):
    def run():
        print(‘子线程任务‘)
# 创建一个对象        
m = Mythread()
# 执行对象
m.start()

三:线程特性介绍

from threading import Thread,current_thread,active_count,enumerate
import time

def task():
    print(‘子进程...‘)
    time.sleep(1)
    print(current_thread())
    
t = Thread(target = task,name =‘aaa‘)
t.daemon = True     
print(t.name)
t.start()

print(active_count())
print(enumerate())
print(‘over‘)


active_count()      # 获取当前活跃线程的数量
enumerate()         # 返回活跃的线程对象枚举
t.daemon = True     # 守护线程,执行顺序和进程一样
current_thread()    # 获取当前线程对象

四:守护线程

无论是进程还是线程,都遵循:守护xxx会等待主xxx运行完毕后被销毁
需要强调的是:运行完毕并非终止运行
from threading import Thread
import time
def sayhi(name):
    time.sleep(2)
    print(‘%s say hello‘ %name)

if __name__ == ‘__main__‘:
    t = Thread(target = sayhi,args = (‘aaa‘,))
    t.setDaemon(True)
    t.start()

    print(‘主线程‘)
    print(t.is_alive)

五:线程互斥锁

# 多线程是可以共用同一个进程的数据的,所以在共用这些数据的同时,会产生对数据的竞争,竞争# 带来的就是错乱,所以,我们同样需要用锁,来将这些竞争变得有序
from threading import Thread,Lock
mutex = Lock()

def task1():
    mutex.acquire()
    for i in range(100):
        print(‘====‘)
    mutex.release()
    
def task2():
    mutex.acquire()
    for i in range(100):
        print(‘!!!!!!‘)
    mutex.release()

def task3():
    mutex.acquire()
    for i in range(100):
        print(‘****‘)
    mutex.release()

t1 = Thread(target=task1)
t2 = Thread(target=task2)
t3 = Thread(target=task3)

t1.start()
t2.start()
t3.start()

六:死锁

from threading import Thread,Lock
import time

mutex1 = Lock()
mutex2 = Lock()

def task():
    mutex1.acquire()
    print(‘aaa‘)
    time.sleep(2)
    mutex2.acquire()
    print(‘bbb‘)
    mutex2.release()
    mutex1.release()
    
def func():
    mutex2.acquire()
    print(‘ccc‘)
    mutex1.acquire()
    print(‘ddd‘)
    time.sleep(2)
    mutex1.release()
    mutex2.release()

t1 = Thread(target = task)
t2 = Thread(target = func)
t1.start()
t2.start()

print(‘s‘)

七:递归锁

from threading import Thread,RLock

mutex = RLock()
def task():
    mutex.acquire()
    print(‘aaa‘)
    mutex.acquire()
    print(‘bbb‘)
    
t = Thread(target=task)
t.start()
    
# 如果是mutex=Lock的话,第8行打印不出来,因为第一次锁没有被mutex.release()释放,会# 处于锁死的状态。

八:信号量

from threading import Thread,Semaphore,current_thread,active_count

sm = Semaphore(2)

def task():
    sm.acquire()
    for i in range(10):
        print(current_thread())
        time.sleep(0.5)
    sm.release()
    
def task2():
    for i in range(10):
        print(current_thread())
        time.sleep(0.5)

for i in range(5):
    Thread(target=task).start()
    Thread(target=task2).start()
print(active_count())

# 用于控制 同时执行被锁定代码的线程数量 也就是线程并发数量
# 也是一种锁

九:线程和进程的区别

1.# 进程是一个资源单位,一个进程可以包含多个线程
2.# 多个线程之间可以共享区域
3.# 线程启动的消耗的资源较小

以上是关于2018.11.09python学习第三十七天的主要内容,如果未能解决你的问题,请参考以下文章

走入计算机的第三十七天(python的高级用法)

python第三十七天,GIL全局解释器锁*****,线程池与进程池 同步异步,阻塞与非阻塞,异步回调

第三十七天

第三十七天 一乐在当中—Android的小游戏打飞机环境搭建

2018.10.11python学习第十七天

WPF学习第三十七章 触发器