项目中多线程的目的

具体原理我觉得这应该是可以跳到操作系统里面了一点点小小总结大家还可以找本操作系统的书看看，老规矩找不到的话找我主页，有一个关于资源的文章里面有资源当然也可以私信我。
我们再说说我们项目里面用多线程的目的：
1.线程之间共享内存非常容易。
2·使用多线程来实现多任务并发执行比使用多进程的效率高
3·有时候可以节省运行时间，这个一会在下面就会知道
4·当你一个文件要同时执行多个功能时就可以用到多线程

python语言内置了多线程功能支持，而不是单纯地作为底层操作系统的调度方式，从而简化了python的多线程编程。

实战操作

说这么多不如实际动手练练，首先导入线程
特别注意:大家在见建文件的时候名字千万别和导入的包threading一样不然会出错的。

小知识

import threading

让我们先看看自己程序现在有多少个进程

import threading
def main():
    print(threading.current_thread())

if __name__ == '__main__':
    main()

结果：1#我的就一个你的呢？

如果你的进程不为一的话还可以这样查看每一个进程名

import threading
def main():
    print(threading.active_count())
    print(threading.enumerate())
   

if __name__ == '__main__':
    main()

>>>[<_MainThread(MainThread, started 36004)>]#返回的是一个列表因为我的目前就一个所以就一个主进程

还可以查看正在运行的进程

import threading
def main():
    print(threading.active_count())
    print(threading.enumerate())
    print(threading.current_thread())

if __name__ == '__main__':
    main()

>1
[<_MainThread(MainThread, started 36004)>]
<_MainThread(MainThread, started 36004)>

创建一个简单的线程

首先我们先介绍一下threading.Thread（）里面的参数，大家学python每个模块的功能时最好还是看一下源文件内容，这样有助于提高你的编程能力：

需要注意的点我已经打上标记了

import threading
def first():
    print("frist active")
    print("frist finish")

def main():
    first_thread=threading.Thread(target=first,name="T1")
    first_thread.start()#开始的标志
    print("main")

if __name__ == '__main__':
    main()

结果：
第一次运行
frist active
main
frist finish
第二次运行
frist active
frist finish
main

每次的结果不一样就已经表明Frist和main是同时运行的了。
如果说效果不太明显的话，我们改进一下接下来我们引入

import time

import threading
import time
def first():
    print("frist active")
    time.sleep(3)
    print("frist finish")

def main():
    first_thread=threading.Thread(target=first,name="T1")
    first_thread.start()
    print("main")

if __name__ == '__main__':
    main()

结果：
frist active
main
frist finish

因为执行到Frist active的时候Frist线程要睡3秒这个时候main还在执行所以这样每次都是这个结果了。
特别强调target=first不是导入Frist函数从源文件我们就已经看出是通过run（）方法进行的，这里解释我引用一位大佬解释

当然如果你觉得这样不行的话你也可以重写threading.Thresd里的run方法来个自定义线程

    class MyThread(threading.Thread):
        def __init__(self,n):
            super(MyThread,self).__init__()   #重构run函数必须写
            self.n = n

        def run(self):
            print('task',self.n)
            time.sleep(1)
            print('2s')
            time.sleep(1)
            print('1s')
            time.sleep(1)
            print('0s')
            time.sleep(1)

    if __name__ == '__main__':
        t1 = MyThread('t1')
        t2 = MyThread('t2')
        t1.start()
        t2.start()

结果：
task t1
task t2
2s
2s
1s
1s
0s
0s

守护线程

所谓’线程守护’，就是主线程不管该线程的执行情况，只要是其他子线程结束且主线程执行完毕，主线程都会关闭。也就是说:主线程不等待该守护线程的执行完再去关闭。

不好理解的话来看看例子

import threading
import time
def first():
    print("frist active")
    time.sleep(3)
    print("frist finish")

def second():
    print("second active")
    print("second finish")

def main():
    first_thread=threading.Thread(target=first,name="T1")
    second_thresd=threading.Thread(target=second,name="T2")
    first_thread.setDaemon(True)#一定要在start（）前开始
    first_thread.start()
    second_thresd.start()
    print("main")

if __name__ == '__main__':
    main()
    

结果
frist active
second active
second finishjiemeijieshu
main

当主线程和其他子线程都结束不管守护线程first_thread 结没结束程序都结束
当设second_thresd为守护线程的时候情况是这样的

import threading
import time
def first():
    print("frist active")
    time.sleep(3)
    print("frist finish")

def second():
    print("second active")
    print("second finish")

def main():
    first_thread=threading.Thread(target=first,name="T1")
    second_thresd=threading.Thread(target=second,name="T2")
    second_thresd.setDaemon(True)#一定要在start（）前开始
    first_thread.start()
    second_thresd.start()
    print("main")

if __name__ == '__main__':
    main()
    

frist active
second active
second finish
main
frist finish #尽管输出这个要等三秒

主进程等待子进程结束

为了让守护线程执行结束之后，主线程再结束，我们可以使用join方法，让主线程等待子线程执行

import threading
import time
def first():
    print("frist active")
    time.sleep(3)
    print("frist finish")

def second():
    print("second active")
    print("second finish")

def main():
    first_thread=threading.Thread(target=first,name="T1")
    second_thresd=threading.Thread(target=second,name="T2")
    first_thread.start()
    second_thresd.start()
    first_thread.join()

    print("main")

if __name__ == '__main__':
    main()
    

结果：
frist active
second active
second finish
frist finish
main
不加join是这样的结果
frist active
second active
second finish
main
frist finish

共享全局变量的特性

这里定义一个全局变量A

import threading
import time
def first():
    global A
    print("frist active")
    time.sleep(3)
    A=A+3
    print("frist:%d"%A)
    print("frist finish")

def second():
    global A
    print("second active")
    A=A+6
    print("second:%d"%A)
    print("second finish")

def main():
    global A
    first_thread=threading.Thread(target=first,name="T1")
    second_thresd=threading.Thread(target=second,name="T2")
    first_thread.start()
    second_thresd.start()
    #first_thread.join()

    print("main")
    A=A+3
    print("mian:%d"%A)

if __name__ == '__main__':
    A=0
    main()

来看一下结果

frist active
second active
second:6
second finish
main
mian:9
frist:12
frist finish

锁

由上面的例子可以看出，输出A的值的时候不同进程之间的资源是共享的这就导致了变量A的值不固定造成了脏数据的情况，不理解的话我们就来个例子。

在没有互斥锁的情况下，假设账户有一万元钱，存钱和取钱同时进行可能账户余额会有一万一千元。这样我当然高兴只是银行不答应。为了避免这种情况我们引入锁的概念，下面我们简单的介绍几种编程里面常用的。

互斥锁

import threading
import time
def first():
    global A,lock
    lock.acquire()
    print("frist active")
    time.sleep(3)
    A=A+3
    print("frist:%d"%A)
    print("frist finish")
    lock.release()

def second():
    global A,lock
    lock.acquire()
    print("second active")
    A=A+6
    print("second:%d"%A)
    print("second finish")
    lock.release

def main():
    global A,lock
    lock=threading.Lock()
    first_thread=threading.Thread(target=first,name="T1")
    second_thresd=threading.Thread(target=second,name="T2")
    first_thread.start()
    second_thresd.start()
    #first_thread.join()

    print("main")
    A=A+3
    print("mian:%d"%A)

if __name__ == '__main__':
    A=0
    main()

结果

frist active
main
mian:3
frist:6
frist finish
second active
second:12
second finish

是不是这样看着就舒服多了，如果例子不够明显我们再来一个

import threading
import time
def first():
    global A,lock
    lock.acquire()
    print("frist active")
    time.sleep(3)
    A=A+3
    print("frist1:%d"%A)
    A = A + 3
    print("frist2:%d" % A)
    print("frist finish")
    lock.release()

def second():
    global A,lock
    lock.acquire()
    print("second active")
    A=A+6
    print("second1:%d"%A)
    A=A+6
    print("second2:%d"%A)

    print("second finish")
    lock.release()

def main():
    global A,lock
    lock=threading.Lock()
    first_thread=threading.Thread(target=first,name="T1")
    second_thresd=threading.Thread(target=second,name="T2")
    first_thread.start()
    second_thresd.start()
    #first_thread.join()

    print("main")
    A=A+3
    print("mian:%d"%A)

if __name__ == '__main__':
    A=0
    main()

结果

frist active
main
mian:3
frist1:6
frist2:9
frist finish
second active
second1:15
second2:21
second finish

去掉锁以后结果

frist active
second active
second1:6
second2:12
second finish
main
mian:15
frist1:18
frist2:21
frist finish

很明显去掉锁以后结果杂乱的很

信号量

我相信对操作系统有一定了解的肯定，在刚才提到锁的时候就想到了信号量毕竟考研题经常会出现，同步，互斥和信号量机制。我们就来说一说信号量锁，其实道理很简单假如你现在，在中国结婚了你只能娶一个老婆吧，尽管你可以去找别的女人但他们不能称为老婆她们会被称为小三，二奶啊等等，这里老婆这个信号量在中国就是==一==只能有一个，别的再来就不可以了。

import threading
import time

def run(n,semaphore):
    semaphore.acquire()   #加锁
    time.sleep(3)
    print('run the thread:%s\n' % n)
    semaphore.release()    #释放


if __name__== '__main__':
    num=0
    semaphore = threading.BoundedSemaphore(3)   #最多允许3个线程同时运行
    for i in range(10):
        t = threading.Thread(target=run,args=('t-%s' % i,semaphore))
        t.start()
    while threading.active_count() !=1:
        pass
    else:
        print('----------all threads done-----------')

结果

run the thread:t-2
run the thread:t-1


run the thread:t-0

run the thread:t-3
run the thread:t-5
run the thread:t-4



run the thread:t-6

run the thread:t-7

run the thread:t-8

run the thread:t-9

----------all threads done-----------