多线程编程

#直接调用
import time
import threading
def run(n): #定义每个线程要运行的函数
    print(‘task‘,n)
    time.sleep(1)

# r1=run(‘t1‘)
# r2=run(‘t2‘)

t1=threading.Thread(target=run,args=(‘t1‘,))#生成一个线程实例
t2=threading.Thread(target=run,args=(‘t2‘,))
t1.start() #启动线程
t2.start()


#继承调用
class MyThread(threading.Thread):
    def __init__(self,name):
        super(MyThread,self).__init__()
        self.name=name
    def run(self): #定义每个线程要运行的函数
        print("Hello %s"%self.name)
        time.sleep(1)
        
h1=MyThread(‘h1‘)
h2=MyThread(‘h2‘)
h1.start()
h2.start()

import time
import threading
def run(n):
    print(‘task‘,n)
    time.sleep(1)

#主线程和它启动的子线程是并行的
start_time=time.time()
for i in range(50):
    t=threading.Thread(target=run,args=(‘t%s‘%i,)) #子线程  而整个程序下来本身是一个主线程
    t.start()

print(‘cost:‘,time.time()-start_time)# 无法测出整个程序运行的时间   因为主线程和它启动的子线程是并行的    主线程启动后不会等它的子线程执行完毕再往下走 


#想要测出整个程序的运行时间
start_time=time.time()
t_objs=[]#存线程实例
for i in range(50):
    t=threading.Thread(target=run,args=(‘t%s‘%i,)) #子线程  而整个程序下来本身是一个主线程
    t.start()
    t_objs.append(t)
for i in t_objs: #循环线程实例列表，等待所有线程执行完毕
    i.join()#t1等待t1线程执行完后才往下走
#t1.join(5)#等待子线程执行5s后再执行主线程，主线程结束后继续执行子线程

print(‘all the threads has finish！‘,threading.current_thread())
print(‘cost:‘,time.time()-start_time)

import threading
def run(n):
    print(‘task‘,n)
    time.sleep(1)

t1=threading.Thread(target=run,args=(‘t1‘,))
t2=threading.Thread(target=run,args=(‘t2‘,))
t1.start()
#t1.join() #t1等待t1线程执行完后才往下走
#t1.join(5)#等待子线程执行5s后再执行主线程，主线程结束后继续执行子线程

t2.start()
print(‘done‘)

join

import time
import threading
def run(n):
    print(‘task‘,n)
    time.sleep(1)

#主线程和它启动的子线程是并行的
start_time=time.time()
for i in range(50):
    t=threading.Thread(target=run,args=(‘t%s‘%i,)) #子线程  而整个程序下来本身是一个主线程
    t.setDaemon(True)#将当前线程设置为Daemon线程    在线程启动前设置
    t.start()

print(‘all the threads has finish！‘,threading.current_thread())

import threading
import time

event=threading.Event()#创建一个事件

def lighter():
    count=0
    event.set()#设置标志位
    while True:
        if count>=5 and count<10:#改成红灯
            event.clear()#把标志位清空
            print("\033[41;1m red light is on...\033[0m")
        elif count>10: #变绿灯
            event.set()
            count=0
        else:
            print("\033[42;1mgreen light is on...\033[0m")
        count+=1
        time.sleep(1)

def car(name):
    while True:
        if event.is_set():
            print(‘%s is running...‘ %name)
            event.wait()
        else:
            print(‘%s is waiting...‘%name)
            event.wait()
        time.sleep(1)

light=threading.Thread(target=lighter,)
car1=threading.Thread(target=car,args=(‘car1‘,))
light.start()
car1.start()

import time
import threading

def addNum():
    global num  # 在每个线程中都获取这个全局变量
    print(‘--get num:‘, num)
    time.sleep(1)
    num += 1 # 对此公共变量进行-1操作

num =0  # 设定一个共享变量
thread_list = []
for i in range(100):
    t = threading.Thread(target=addNum)
    t.start()
    thread_list.append(t)

for t in thread_list:  # 等待所有线程执行完毕
    t.join()

print(‘final num:‘, num)

#按正常来说，输出应该是100，但事实上会出现少于100的可能(一般出现在Python2，Python3并没有出错，有可能是Python3自动加了锁)，假设你有A,B两个线程，此时都 要对num 进行加1操作， 由于2个线程是并发同时运行的，所以2个线程很有可能同时拿走了num=0这个初始变量交给cpu去运算，当A线程去处完的结果是1，但此时B线程运算完的结果也是1，两个线程同时CPU运算的结果再赋值给num变量后，结果就都是1。那应该怎样避免这种情况呢？其实很简单，每个线程在要修改公共数据时，为了避免自己在还没改完的时候别人也来修改此数据，可以给这个数据加一把锁， 这样其它线程想修改此数据时就必须等待你修改完毕并把锁释放掉后才能再访问此数据。

import time
import threading
 
def addNum():
    global num #在每个线程中都获取这个全局变量
    print(‘--get num:‘,num )
    time.sleep(1)
    lock.acquire() #修改数据前加锁
    num  +=1 #对此公共变量进行-1操作
    lock.release() #修改后释放
 
num = 0  #设定一个共享变量
thread_list = []
lock = threading.Lock() #生成全局锁
for i in range(100):
    t = threading.Thread(target=addNum)
    t.start()
    thread_list.append(t)
 
for t in thread_list: #等待所有线程执行完毕
    t.join()
 
print(‘final num:‘, num )

import threading,time
 
def run1():
    print("grab the first part data")
    lock.acquire()
    global num
    num +=1
    lock.release()
    return num
def run2():
    print("grab the second part data")
    lock.acquire()
    global  num2
    num2+=1
    lock.release()
    return num2
def run3():
    lock.acquire()
    res = run1()
    print(‘--------between run1 and run2-----‘)
    res2 = run2()
    lock.release()
    print(res,res2)
 
 
if __name__ == ‘__main__‘:
 
    num,num2 = 0,0
    lock = threading.RLock()
    for i in range(10):
        t = threading.Thread(target=run3)
        t.start()
 
while threading.active_count() != 1:
    print(threading.active_count())
else:
    print(‘----all threads done---‘)
    print(num,num2)

import threading,time
 
def run(n):
    semaphore.acquire()
    time.sleep(1)
    print("run the thread: %s\n" %n)
    semaphore.release()
 
if __name__ == ‘__main__‘:
 
    num= 0
    semaphore  = threading.BoundedSemaphore(5) #最多允许5个线程同时运行
    for i in range(20):
        t = threading.Thread(target=run,args=(i,))
        t.start()
 
while threading.active_count() != 1:
    pass #print threading.active_count()
else:
    print(‘----all threads done---‘)
    print(num)

import threading
def hello():
    print("hello, world")


t =threading.Timer(5.0, hello)
t.start()  # after 5.0 seconds, "hello, world" will be printed

from threading import  Thread
from queue import Queue

class Producer(Thread):
    def run(self):
        Thread.run(self)

class Comsumer(Thread):
    def run(self):
        Thread.run(self)

que = Queue(maxsize=100)
for i in range(100):
    que.put(i)

print(‘empty:‘,que.empty())
print(que.qsize())
print(‘get:‘,que.get())
print(‘get:‘,que.get())
print(‘empty:‘,que.empty())

from threading import Thread
from queue import Queue
import  time

class Producer(Thread):
    def __init__(self,name,queue):
        ‘‘‘
        :param name:生产者的名称
        :param queue: 容器
        ‘‘‘
        self.__Name=name
        self.__Queue=queue
        super(Producer,self).__init__()#继承，执行一下父类的构造函数

    def run(self):
        while True:
            if self.__Queue.full():
                time.sleep(1)
            else:
                self.__Queue.put(‘baozi‘)
                time.sleep(1)
                print(‘%s 生产了一个包子‘ %(self.__Name,))
        #hread.run(self)

class Comsumer(Thread):
    def __init__(self,name,queue):
        ‘‘‘
        :param name:生产者的名称
        :param queue: 容器
        ‘‘‘
        self.__Name=name
        self.__Queue=queue
        super(Comsumer,self).__init__()#继承，执行一下父类的构造函数

    def run(self):
        while True:
            if self.__Queue.empty():
                time.sleep(1)
            else:
                self.__Queue.get(‘baozi‘)
                time.sleep(1)
                print(‘%s 消费了一个包子‘ %(self.__Name,))

que=Queue(maxsize=100)

baogou1=Producer(‘cooker1‘,que)
baogou1.start()
baogou2=Producer(‘cooker2‘,que)
baogou2.start()
baogou3=Producer(‘cooker3‘,que)
baogou3.start()

for item in range(20):
    name = ‘customer%d‘ %(item,)
    temp = Comsumer(name,que)
    temp.start()