python 多线程

简单的线程

# -*- coding: utf-8 -*-

'''
线程是操作系统能够进行运算调度的最小单位

进程是资源的集合
线程是操作系统指令集合

进程与线程的区别:
    1.线程共享内存空间，进程内存空间是独立的
    2. 同一个 进程之间的线程可以进行交流，进程是相互独立的，想要交互需要一个中间代理来做交互
    3.创建新线程很简单，创建新进程需要对父进程进行一次clone
    4.一个线程可以控制和操作同一个进程中的其他线程， 进程只能操作子进程
    5.改变一个线程会影响其他线程， 改变进程不会影响其他进程
    
'''


'''
最简单的多线程
'''
import threading,time

#这个方法可以是任意名字
def run(n):
    print("is :",n)
    time.sleep(2)
start_time = time.time()
for i in range(10):
    t1= threading.Thread(target=run,args=(i,))
    #把当前线程设置为守护线程
    t1.setDaemon(True)
    t1.start()
#     t1.join() #在t1执行完之后在往下执行 ， 这使得t1 ,t2变成串行
 
print(time.time()-start_time)

print("main thread....")

 

 

用类的方式实现多线程：

# -*- coding: utf-8 -*-

import threading,time


'''
通过继承threading.Thread 来实现多线程
'''
class myThread(threading.Thread):
    def __init__(self,n):
        super(myThread,self).__init__()
        self.n=n
    
    #一定要重新run 方法
    def run(self):
        print('is :',self.n)
        time.sleep(2000)
        
        


t1=myThread('t1')
t2=myThread('t2')
t1.start()
t2.start()

 

线程锁：

# -*- coding: utf-8 -*-
import threading
import time

'''
当多个线程访问修改同一资源 ， 可以加锁， 加锁会让操作问价你的时候串行

'''

lock = threading.Lock()
#RLock 是递归锁，可以防止死锁 ，连续使用多个锁的时候要用递归锁
# lock = threading.RLock()
num = 0
obj =[]
def run(n):
    #修改数据前获取一把锁 
    lock.acquire()
    global num
#     time.sleep(1)
    num=num+1
    #修改完成后释放锁
    lock.release()
    
for i in range(50):
    t1= threading.Thread(target=run,args=(i,))
    t1.start()
    obj.append(t1)
 
for t in obj:
    t.join()
    
print('num :',num)

 

 

信号量：

# -*- coding: utf-8 -*-
import threading
import time

'''
信号量 ： 允许同一时间多少个线程可以一起运行 , 连接池就是这个原理
'''

#声明最多有5个线程同时运行
semaphore = threading.BoundedSemaphore(5)
 
num = 0
def run(n):
    #修改数据前获取一把锁 
    semaphore.acquire()
    global num
#     time.sleep(1)
    num=num+1
    print(num)
    time.sleep(1)
    #修改完成后释放锁
    semaphore.release()
    
for i in range(50):
    t1= threading.Thread(target=run,args=(i,))
    t1.start()
 

    

 

 

多线程实现红绿灯：

# -*- coding: utf-8 -*-

'''
使用线程中的事件实现 红绿灯

当event 没有值的时候线程就会等待
 event.clear() 清空event 的值
 event.set() 设置event 的值
 event.is_set() 判断是否设置了标志位
 event.wait() 等待标志位设定，线程就会运行
 
'''
import threading
import time
event = threading.Event()

def lightrt():
    count = 0
    event.set()
    while True:
       
         #count 大于10 改成红灯
        if count>5and  count<10:
            #把标志位清空 ， 线程就会等待 ,相当于红灯
            event.clear()
            print("红灯了")
            
        elif count>10:
            event.set()
            count=0
#             print()
        else:
            print("绿灯了",count)
        time.sleep(1)
        count +=1
        
def car(name):
    while True:
        
        #判断标志位是否有值
        if event.is_set():
            print("%s 绿灯，通过------------->>>"%name)
            time.sleep(1)
        else:
            print("%s 红灯，等待"%name)
            #让车等红灯 
            event.wait()
            print("红灯结束，开始通过 %s"%name)
        


light = threading.Thread(target=lightrt,)
light.start()

        
car1 = threading.Thread(target=car, args=("宝马",))
car1.start()
car2 = threading.Thread(target=car, args=("奔驰",))
car2.start()