线程 Thread类 GIL锁信号量 Event事件

线程的开启方法

进程是操作系统调度的最小单位，一个进程最少有一个主线程，而一个进程中可以开启多个线程

from threading import Thread

def task():

    print('A child thread')

if __name__ == '__main__': # 这里是可以不用写的，但是规范起见还是写了

    t = Thread(target=task)

    t.start()

    print('==>main thread')

GIL锁

"""

 1. Python在设计之初就考虑到要在主循环中，同时只有一个线程在执行

 2. Python 解释器中可以“运行”多个线程，但在任意时刻只有一个线程在解释器中运行。

 1、GIL锁它是在python解释器中的， 只在cpython中有， pypy解释器是没有GIL锁的，

 2、起一个垃圾回收线程， 一个是正常执行的线程

 3、设置了一把锁（GIL锁），  一个线程要想执行，必须拿到这把锁

 4、同一时刻，开启一个进程，一个进程中可以有多个线程， 只能有一个线程在执行

 5、如果是计算密集型：要开进程

 6、如果是io密集型：要开线程

"""

进程与线程的比较

线程与进程的区别可以归纳为以下4点：

地址空间和其它资源（如打开文件）：进程间相互独立，同一进程的各线程间共享。某进程内的线程在其它进程不可见。
通信：进程间通信IPC，线程间可以直接读写进程数据段（如全局变量）来进行通信——需要进程同步和互斥手段的辅助，以保证数据的一致性。
调度和切换：线程上下文切换比进程上下文切换要快得多。
在多线程操作系统中，进程不是一个可执行的实体。

进程消耗的资源比线程要大的多，相对的，调用起来也比线程要慢

# 进程调用时间演示

import time

from multiprocessing import Process

def task():

    time.sleep(1)

    print('A child process')

if __name__ == '__main__':

    start = time.time()

    p = Process(target=task)

    p.start()

    p.join()

    print('master process')

    print(time.time() - start)

# 输出结果

# A child process

# master process

# 1.069324016571045

# 线程调用时间演示

import time

from threading import Thread

def task():

    time.sleep(1)

    print('A child thread')

if __name__ == '__main__':

    start = time.time()

    t = Thread(target=task)

    t.start()

    t.join()

    print('==>main thread')

    print(time.time()-start)

# 输出结果

# A child thread

# ==>main thread

# 1.005803108215332

线程间的数据是共享的

def task():

  global n

  n=0

if __name__ == '__main__':

  n=1

  t=Thread(target=task)

  t.start()

  t.join()

  print('主',n) # 查看结果为0,因为同一进程内的线程之间共享进程内的数据

Thread类的方法

t.is_alive() # 返回线程是否活动

t.getName()  # 获取线程名

t.setName()  # 更新线程名

threading.currentThread() # 返回当前的线程变量

threading.enumerate() # 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程

threading.activeCount() # 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果

守护线程

from threading import Thread

import time

def task():

    time.sleep(1)

    print("我是子线程")

if __name__ == '__main__':

    t = Thread(target=task,)

    t.setDaemon(True)  # 开启守护线程，  主线程结束，子线程跟着结束

    t.start()

    print("主线程")

线程互斥锁

from threading import Thread,Lock

import time

import random

def task(lock):

   #上锁

   lock.acquire()

   global n

   # 10个线程同时涌入导致数据不安全

   time.sleep(random.random())

   n -= 1

   # 释放锁

   lock.release()

if __name__ == '__main__':

   start = time.time()

   lock = Lock()

   n = 100

   l = []

   for i in range(10):

       t = Thread(target=task,args=(lock,))

       t.start()

       l.append(t)

   for j in l:

       j.join()

   print('运算完毕：n = %s' %n)

   print(time.time()-start)

信号量

from threading import Thread,Semaphore

import time

def task(i, sm):

    # 上锁

    sm.acquire()

    print("%s：这个人开始上厕所了" % i)

    time.sleep(3)

    print("%s：这个人上完了" % i)

    # 释放锁

    sm.release()

# Semaphore:信号量可以理解为多把锁，同时允许多个线程来更改数据

if __name__ == '__main__':

    sm = Semaphore(2)  #

    for i in range(10):

        t = Thread(target=task, args=(i, sm))

        t.start()

Event事件

from threading import Thread, Event

import time

def girl(event):

    print("都女士正在恋爱中...")

    time.sleep(3)

    print("都女生分手了")

    # 发出分手的信号

    event.set()

def boy(i, event):

    print("渣男:%s正在等待都女生分手" % i)

    # 卡住

    event.wait()

    print("渣男：%s开始追了" % i)

if __name__ == '__main__':

    event = Event()

    t = Thread(target=girl, args=(event,))

    t.start()

    for i in range(10):

        b_t = Thread(target=boy, args=(i, event))

        b_t.start()

释放出信号，而读数据课以收信号，一旦示范出可以读的信号该线程才会运行

巴特西

线程 Thread类 GIL锁信号量 Event事件

线程的开启方法

GIL锁

进程与线程的比较

Thread类的方法

守护线程

线程互斥锁

信号量

Event事件

最新文章

热门文章

巴特西

线程 Thread类 GIL锁 信号量 Event事件

线程的开启方法

GIL锁

进程与线程的比较

Thread类的方法

守护线程

线程互斥锁

信号量

Event事件

最新文章

热门文章

线程 Thread类 GIL锁信号量 Event事件