Python线程

线程的创建

1.通过创建Thread类指定target来实现

from threading import Thread
import time

def test():
    print("----------1-------")
    time.sleep(1)

for i in range(5):
    t = Thread(target=test)
    t.start()

2.通过继承Thread类重写run方法来实现

from threading import Thread
import time

def test():
    print("----------1-------")
    time.sleep(1)

class MyThread(Thread):
    def run(self):
        test()
for i in range(5):
    t = MyThread()
    t.start()

3.同一个进程中的线程之间共享全局变量

线程与进程的区别

定义的不同

• 进程是系统进行资源分配和调度的一个独立单位.
• 线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.

互斥锁

#创建锁
mutex = threading.Lock()
#锁定
mutex.acquire([blocking])
#释放
mutex.release()

死锁

避免死锁的方式
1.上锁添加超时时间

mutex = Lock()
mutex.acquire(timeout=3)

2.银行家算法

生产者与消费者模式

#encoding=utf-8
import threading
import time

#python2中
from Queue import Queue

#python3中
# from queue import Queue

class Producer(threading.Thread):
    def run(self):
        global queue
        count = 0
        while True:
            if queue.qsize() < 1000:
                for i in range(100):
                    count = count +1
                    msg = '生成产品'+str(count)
                    queue.put(msg)
                    print(msg)
            time.sleep(0.5)

class Consumer(threading.Thread):
    def run(self):
        global queue
        while True:
            if queue.qsize() > 100:
                for i in range(3):
                    msg = self.name + '消费了 '+queue.get()
                    print(msg)
            time.sleep(1)


if __name__ == '__main__':
    queue = Queue()

    for i in range(500):
        queue.put('初始产品'+str(i))
    for i in range(2):
        p = Producer()
        p.start()
    for i in range(5):
        c = Consumer()
        c.start()

队列就是用来给生产者和消费者解耦的

ThreadLocal

import threading

# 创建全局ThreadLocal对象:
local_school = threading.local()


def process_student():
    # 获取当前线程关联的student:
    std = local_school.student
    print('Hello, %s (in %s)' % (std, threading.current_thread().name))


def process_thread(name):
    # 绑定ThreadLocal的student:
    local_school.student = name
    process_student()


t1 = threading.Thread(target=process_thread, args=('dongGe',), name='Thread-A')
t2 = threading.Thread(target=process_thread, args=('老王',), name='Thread-B')
t1.start()
t2.start()
t1.join()
t2.join()

异步

from multiprocessing import Pool
import time
import os


def test():
    print("---进程池中的进程---pid=%d,ppid=%d--" % (os.getpid(), os.getppid()))
    for i in range(3):
        print("----%d---" % i)
        time.sleep(1)
    return "hahah"


def test2(args):
    print("---callback func--pid=%d" % os.getpid())
    print("---callback func--args=%s" % args)


pool = Pool(3)
pool.apply_async(func=test, callback=test2)

time.sleep(5)

print("----主进程-pid=%d----" % os.getpid())

GIL 全局解释器锁

python解释器在解释python程序时，多线程的任务会存在GIL问题，也就是多线程执行时实际是只有单线程会占用CPU，多核CPU并不会同时执行多线程的程序。
避免GIL问题的方式：
1.采用多进程来实现多任务
2.采用C语言来实现多线程任务

把一个ｃ语言文件编译成一个动态库的命令（linux平台下）:
gcc xxx.c -shared -o libxxxx.so

from ctypes import *
from threading import Thread

#加载动态库
lib = cdll.LoadLibrary("./libdeadloop.so")

#创建一个子线程，让其执行ｃ语言编写的函数，此函数是一个死循环
t = Thread(target=lib.DeadLoop)
t.start()

#主线程，也调用ｃ语言编写的那个死循环函数
#lib.DeadLoop()

while True:
    pass