Python_oldboy_自动化运维之路_线程，进程，协程（十一）

# -*- coding: UTF-8 -*-
#blog:http://www.cnblogs.com/linux-chenyang/
import threading
import time

def task(arg):                                      #隔1s后执行这三十个线程，是并发的，同时工作
    time.sleep(1)
    print(‘aaaaaaa‘,arg)


for i in range(30):                                 #这个是创建出30个线程来
    t = threading.Thread(target=task,args=[i,])
#    t.setDaemon(True)     #主程序结束，不等待子线程
#    t.setDaemon(False)   #默认

    t.start()

#    t.join()    #等一个线程执行完在执行下一个线程
#    t.join(1)  #等待最大时间，最多等1秒

print(‘end‘)    #这个就相当于主线程

#end是主线程，等主线程创建好后会隔1s并发执行30个函数
end
aaaaaaa 0
aaaaaaa 1
aaaaaaa 2
aaaaaaa 4
aaaaaaa 5
aaaaaaa 3
aaaaaaa 6
aaaaaaa 7
aaaaaaa 9
aaaaaaa 8
aaaaaaa 11
aaaaaaa 10
aaaaaaa 13
aaaaaaa 12
aaaaaaa 14
aaaaaaa 17
aaaaaaa 15
aaaaaaa 16
aaaaaaa 19
aaaaaaa 18
aaaaaaa 20
aaaaaaa 21
aaaaaaa 22
aaaaaaa 23
aaaaaaa 25
aaaaaaa 26
aaaaaaa 24
aaaaaaa 27
aaaaaaa 28
aaaaaaa 29

#线程执行的过程，自定义线程，我们的函数是被run方法调用的
import threading
import time

class MyThread(threading.Thread):
    def __init__(self,func,*args,**kwargs):
        super(MyThread,self).__init__(*args,**kwargs)
        self.func = func

    def run(self):
        self.func()
        print(‘-------首先执行的是run方法-----‘)

def task():
    print(‘task函数。。。。‘)


obj=MyThread(func=task)
obj.start()

task函数。。。。
-------首先执行的是run方法-----

#用处：这样的话变量v就是来一个减一个，不会出现假如其中有线程没有执行完，在去减就会出错

import threading
import time

#创建锁
lock = threading.Lock()
#lock = threading.RLock()   #使用这种方法可以锁多次，但是解锁也要解锁多次，带递归的锁

v=10

def task(arg):
    time.sleep(2)

    #申请使用锁，其他人等
    lock.acquire()
    #lock.acquire()

    global v
    v -= 1
    print(v)

    #释放
    lock.release()
    #lock.release()

for i in range(10):
    t = threading.Thread(target=task,args=(i,))  #元组的方式最好加逗号，（后续）怕误以为是个函数
    t.start()

9
8
7
6
5
4
3
2
1
0

import threading
import time

#创建锁
lock = threading.BoundedSemaphore(3)      #同时锁三个线程

v=10

def task(arg):

    lock.acquire()

    time.sleep(1)                        #当进来锁后等1秒，这时显示打印会三条三条的显示。
    global v
    v -= 1
    print(v)

    lock.release()


for i in range(10):
    t = threading.Thread(target=task,args=(i,))  #元组的方式最好加逗号，（后续）怕误以为是个函数
    t.start()

#三个三个显示，等1秒
9
8
7
6
5
4
3
2
1
0

#3.事件锁,当触发某个条件，我生成的子线程才工作
import threading
import time

#创建锁
lock = threading.Event()

def task(arg):

    time.sleep(1)
    #锁住所有的线程
    lock.wait()
    print(arg)

for i in range(10):
    t = threading.Thread(target=task,args=(i,))
    t.start()

while True:
    value = input(‘>>‘)
    if value == ‘1‘:
        lock.set()
#        lock.clear()   默认

>>1
>>0
2
4
6
8
1
3
5
7
9

#4.条件，Condition的用法,输入几就释放几个线程
import threading
import time

#创建锁
lock = threading.Condition()

def task(arg):

    time.sleep(1)
    #锁住所有的线程
    lock.acquire()
    lock.wait()
    print(‘线程‘,arg)
    lock.release()

for i in range(10):
    t = threading.Thread(target=task,args=(i,))
    t.start()

while True:
    value = input(‘>>‘)
    lock.acquire()
    lock.notify(int(value))
    lock.release()

C:\Python35\python3.exe D:/pycharm/s16/day9/2.锁.py
>>2
>>线程 0
线程 2
3
>>线程 1
线程 4
线程 3