python的多线程--莫凡

#什么是多线程
#分批量在同一时间做很多东西
#添加线程
import threading
#实现线程的功能
def thread_job():
    print('This is an added Thread,number is %s'%threading.current_thread())

def main():
    #添加一个新的线程
    added_thread=threading.Thread(target=thread_job)
    added_thread.start()
    #看一下现在有多少个激活了的线程
    # print(threading.active_count())
    # #查看是哪两个线程
    # print(threading.enumerate())
    # #运行的时候是哪个线程
    # print(threading.current_thread())
if __name__=='__main__':
    main()

输出:
This is an added Thread,number is <Thread(Thread-1, started 140224541427456)>

#什么是多线程
#分批量在同一时间做很多东西
#添加线程
import threading
#实现线程的功能
def thread_job():
    print('This is an added Thread,number is %s'%threading.current_thread())

def main():
    #添加一个新的线程
    added_thread=threading.Thread(target=thread_job)
    #added_thread.start()
    #看一下现在有多少个激活了的线程
    print(threading.active_count())
    #查看是哪两个线程
    print(threading.enumerate())
    #运行的时候是哪个线程
    print(threading.current_thread())
if __name__=='__main__':
    main()

输出:
1
[<_MainThread(MainThread, started 140699175049024)>]
<_MainThread(MainThread, started 140699175049024)>

#多线程的应用,特别是在join方面的应用
import threading
import time
#实现线程的功能
def thread_job():
        print('T1 start\n')
        for i in range(10):
            time.sleep(0.1)
        print('T1 finish\n')

def main():
    #添加一个新的线程
    added_thread=threading.Thread(target=thread_job,name='T1')
    added_thread.start()
    #线程是同时开始运行的
    added_thread.join()#加了join就是要等待前面运行完所有线程之后再运行后面的额
    print('all done\n')

if __name__=='__main__':
    main()

输出:
T1 start

T1 finish

all done

#多线程的应用,特别是在join方面的应用
import threading
import time
#实现线程的功能
def thread_job():
        print('T1 start\n')
        for i in range(10):
            time.sleep(0.1)
        print('T1 finish\n')
def T2_jpb():
    print('T2 start\n')
    print('T2 finish\n')
def main():
    #添加一个新的线程
    added_thread=threading.Thread(target=thread_job,name='T1')
    thread2=threading.Thread(target=T2_jpb,name='T2')
    added_thread.start()
    # #线程是同时开始运行的
    # added_thread.join()#加了join就是要等待前面运行完所有线程之后再运行后面的额
    thread2.start()
    thread2.join()
    added_thread.join()
    print('all done\n')

if __name__=='__main__':
    main()

输出:
T1 start

T2 start

T2 finish

T1 finish

all done

#Queue功能
import threading
import time
from queue import Queue
def job(l,q):
    for i in range(len(l)):
        l[i]=l[i]**2
    q.put(l)
def multithreading():
    q=Queue()
    threads=[]
    data=[[1,2,3],[3,4,5],[4,4,4],[5,5,5]]
    for i in range(4):
        t=threading.Thread(target=job,args=(data[i],q))
        t.start()
        threads.append(t)
    for thread in threads:
        thread.join()
    results=[]
    for _ in range(4):
        results.append(q.get())
    print(results)


if __name__=='__main__':
    multithreading()

输出:
[[1, 4, 9], [9, 16, 25], [16, 16, 16], [25, 25, 25]]

#不一定有效率GIL
import threading
from queue import Queue
import copy
import time

def job(l,q):
    res=sum(l)
    q.put(res)

def multithreading(l):
    q=Queue()
    threads=[]
    for i in range(4):
        t=threading.Thread(target=job,args=(copy.copy(l),q),name='T%i'%i)
        t.start()
        threads.append(t)
    [t.join() for t in threads]
    total=0
    for _ in range(4):
        total+=q.get()
    print(total)

def normal(l):
    total=sum(l)
    print(total)

if __name__=='__main__':
    l=list(range(1000000))
    s_t=time.time()
    normal(l*4)
    print('normal:',time.time()-s_t)
    s_t=time.time()
    multithreading(l)
    print('multithreading:',time.time()-s_t)

输出:
1999998000000
normal: 0.08807158470153809
1999998000000
multithreading: 0.09752082824707031

#多线程中的锁lock
#不加lock会打印的比较慢
import threading
def job1():
    global A,lock
    lock.acquire()
    for i in range(10):
        A+=1
        print('job1',A)
    lock.release()
def job2():
    global A,lock
    lock.acquire()
    for i in range(10):
        A+=10
        print('job2',A)
    lock.release()
if __name__=='__main__':
    lock=threading.Lock()
    A=0
    t1=threading.Thread(target=job1)
    t2=threading.Thread(target=job2)
    t1.start()
    t2.start()
    t1.join()
    t2.join()

输出:
job1 1
job1 2
job1 3
job1 4
job1 5
job1 6
job1 7
job1 8
job1 9
job1 10
job2 20
job2 30
job2 40
job2 50
job2 60
job2 70
job2 80
job2 90
job2 100
job2 110