其他分享
首页 > 其他分享> > 多线程

多线程

作者:互联网

>多线程

>>多任务

简单来说就是操作系统可以同时运行多个任务

并发:任务数大于CPU核数,通过操作系统的各种任务调度算法,实现多个任务‘一起’执行,比如在单核CPU下需要同时处理3个任务,这就是并发,单核CPU在开启任务一会立马开启任务二,任务三也同理,这段时间内交替执行任务的方式就是并发。此外单核CPU只会存在并发的情况,不存在并行的情况。

并行:就是在同一时刻一起执行多个任务,比如你有8核的CPU,每个CPU执行一个任务,其中任务数<=CPU核数,就可以进行并行的多任务执行

同步:同步是指完成事务的逻辑顺序执行的,即先执行第一个事务,如果阻塞了,会一直等待,直到这个事务完成以后在执行第二个事务。

异步:异步和同步是相对的,异步是指在调用这个事务以后,不会等待这个事务的处理结果,直接处理第二个事务去,通过状态,通知,回调来通知调用者处理结果

>>_thread模块

# _thread 实现多线程
'''
_thread 常用模块
def start_new_thread(function,args,kwargs=None) 启动一个新的线程  function 线程处理函数  args 传递给线程的参数 元组类型 kwargs 可选参数
def allocate_lock() 分配锁对象
def exit() 线程退出
def get_ident() 获取线程表示符
def interrupt_main() 终止主线程 会产生 KeyboardInterrupt异常
'''

# 利用_thread 模块创建多线程
import _thread
import time


def work(thread_name):
    print('哟西 这是第%s个线程' % thread_name)
    time.sleep(1)

def main():
    for i in range(1,5):
        _thread.start_new_thread(work,('--%s'% i,))
    time.sleep(30)  # 主进程添加延迟  保证子线程执行完成
if __name__ == '__main__':
    main()

>>Treading模块

# threading实现多线程
'''
常用方法
def init(self,group=None,target=None,name=None,args=(),kwargs=None,*,daemon=None)
def start(self) 线程启动
def run(self) 线程操作主体 若没设置target 处理函数 则执行方法
def join(self,timeout=None)
def name(self) 获取线程名称
def ident(self) 获取线程标识
def is_alive()  判断线程存活状态
'''

# threading 创建多线程
import threading
import time


def work(thread_name):
    print('哟西 这是第%s个线程' % thread_name)
    time.sleep(1)

def main():

        thraeds=[threading.Thread(target=work,args=('---%s'%i,))for i in range(1,5)]
        for thraed in thraeds:
            thraed.start()
        time.sleep(3)  # 主进程添加延迟  保证子线程执行完成
if __name__ == '__main__':
    main()
    
# 获取线程信息
import threading
import time


def work(thread_name):
    print('哟西 这是第%s个线程' % thread_name)
    print(threading.current_thread().ident, threading.current_thread().name)
    print('')
    time.sleep(1)

def main():

        thraeds=[threading.Thread(target=work,args=('---%s'%i,))for i in range(20)]
        for thraed in thraeds:
            thraed.start()

if __name__ == '__main__':
    main()
# 将线程设置成类  设置守护进程
import threading
import time
class myThread(threading.Thread):
    def __init__(self, threadname, delay, count):
        super().__init__(name=threadname)
        self._delay = delay
        self._count = count

    def run(self):
        for num in range(self._count):
            time.sleep(1)
            print('线程id:%s,线程名称:%s - %s'
                  % (threading.current_thread().ident, threading.current_thread().getName(), num))

def main():
    thr1=myThread('用户进程', 1, 10)
    thr1.start()
    thr2= myThread('守护进程', 1, 999)
    thr2.setDaemon(True)  # 将线程2 设置成守护进程
    thr2.start()

if __name__ == '__main__':
    main()

>>线程同步

# 线程同步&互斥锁
# Semaphore 实现资源并发控制
import threading
import time
def work_handle(sem):
    if sem.acquire():
        print('请%s前往窗口,办理个人业务 '% threading.current_thread().getName())
        time.sleep(3)  # 模拟银行办理业务时间
        sem.release()  # 释放资源
def main():
    sem = threading.Semaphore(2)
    threading_list=[threading.Thread(target=work_handle,args=(sem,),name='客户%s'% num) for num in range(10)]
    for thr in threading_list:
        thr.start()
if __name__ == '__main__':
    main()

>>多线程共享全局变量

# 共享全局变量
import threading
num =0
def thr1():
    global num
    for i in range(0,1000000):
        num = num+1

def thr2():
    global num
    for i in range(0,1000000):
        num = num+1

if __name__ == '__main__':
    for i in range(5):
        num = 0
        t1 = threading.Thread(target=thr1)
        t2 = threading.Thread(target=thr2)
        t1.start()
        t2.start()
        t1.join()
        t2.join()
        print('计算结果为%s' % num)
        
》》》计算结果为1647829
	计算结果为2000000
	计算结果为2000000
	计算结果为1000000
	计算结果为1645209
    # 创建两个线程 各自加了100000次 累计输出应该是200000 调用了5次应该每次的输出应该一样的 为什么不一样呢,应为像个线程同时运行,不知到谁先谁后,累加1时,线程1 刚累加等于1  想赋值给 num 结果 线程2 提前赋值给了num 结果就是1了  累计次数越多 误差越大 

&互斥锁解决资源问题(lock()和Rlock())

# 互斥锁

import threading
num =0

def thr1(lock):
    lock.acquire()
    global num
    for i in range(0,1000000):
        num = num+1
    lock.release()

def thr2(lock):
    lock.acquire()
    global num
    for i in range(0,1000000):
        num = num+1
    lock.release()
if __name__ == '__main__':
    lock = threading.Lock()
    for i in range(5):
        num = 0
        t1 = threading.Thread(target=thr1,args=(lock,))
        t2 = threading.Thread(target=thr2,args=(lock,))
        t1.start()
        t2.start()
        t1.join()
        t2.join()
        print('计算结果为%s' % num)
import threading
num =0

def thr1(lock):
    lock.acquire()
    global num
    for i in range(0,1000000):
        num = num+1
    lock.release()

def thr2(lock):
    lock.acquire()
    global num
    for i in range(0,1000000):
        num = num+1
    lock.release()
if __name__ == '__main__':
    lock = threading.RLock()
    for i in range(5):
        num = 0
        t1 = threading.Thread(target=thr1,args=(lock,))
        t2 = threading.Thread(target=thr2,args=(lock,))
        t1.start()
        t2.start()
        t1.join()
        t2.join()
        print('计算结果为%s' % num)

>>死锁

一直等待对方释放锁的情况就是死锁
# 死锁

import threading

def get_value(index,lock,list1):
    lock.acquire()

    if index >= len(list1):
        print('超出索引范围')

        return
    data = list1[index]
    print(data)
    lock.release()

def main():
    lock = threading.Lock()
    for i in range(10):
        t =threading.Thread(target=get_value,args=(3,lock,[1,2]))
        t.start()

if __name__ == '__main__':
    main()
# 解决死锁问题 可以在acquire()里面添加超时时间 超过时间自动解锁 

# 死锁

import threading

def get_value(index,lock,list1):
    lock.acquire(timeout=2)

    if index >= len(list1):
        print('超出索引范围')

        return
    data = list1[index]
    print(data)
    lock.release()

def main():
    lock = threading.Lock()
    for i in range(10):
        t =threading.Thread(target=get_value,args=(3,lock,[1,2]))
        t.start()

if __name__ == '__main__':
    main()

>>定时调度

# 定时调度是一种基于线程任务的操作管理 可以实现在末段时间的任务的重复执行

# 通过sched模块实现定时调度操作
'''
delay=0 调度任务启动的延迟时间 如果是0 表示立即启动
priority=0 多个调度任务的启动优先级 
action=func 设置任务的调度处理函数
argument = (参数,) 调度函数的参数 必须填可迭代对象  
'''
import sched


def work_1():
    print('我是第一个任务')

def work_2():
    print('我是第二个任务')

def work_3():
    print('我是第三个任务')

def main():
    sch =sched.scheduler()
    s1=sch.enter(delay=2,priority=1,action=work_1,)
    s2= sch.enter(delay=6, priority=3, action=work_2)
    s3 = sch.enter(delay=4, priority=2, action=work_3)
    sch.run()
if __name__ == '__main__':

    main()

标签:__,main,lock,threading,num,多线程,def
来源: https://www.cnblogs.com/chendakeng/p/16133159.html