最新消息:XAMPP默认安装之后是很不安全的,我们只需要点击左方菜单的 "安全"选项,按照向导操作即可完成安全设置。

python学习整理笔记十_多线程、多进程执行多任务

XAMPP案例 admin 663浏览 0评论

0Python

#多线程

# –多任务:在同一时间内执行多个任务,操作系统可以同时运行多个软件

#多任务的执行方式 :并发 ,并行

# 多线程、多进程执行多任务

 

#进程和线程

# 进程:运行的程序至少会有一个进程,是操作系统进行资源分配的基本单位

#进程是资源分配的最小单位,他是操作系统进行资源分配和调度运行的基本单位,例如:正在运行的QQ 微信等都是进程

# 一个进程默认有一个线程,进程里面可以创建多个线程,线程是依附在进程里面的

 

# 线程:进程中执行代码的一个分支, cpu调度的基本单位,线程的执行顺序是无序的

#线程是程序执行的最小单位,同属一个进程的多个线程共享进程所拥有的全部资源

# 程序启动默认会有一个主线程, 程序员自己创建的线程称为子线程, 多线程可以完成多任务

#举例:进程相当于一个公司,电脑 椅子是进程分配的资源,线程就是员工

 

#多线程– threading模块    Thread类

# 线程类Thread参数:

#     target: 执行的目标任务名

#     args: 以元组的形式是给执行任务传参

#     kwargs:以字典的形式是给执行任务传参

#自己定义的线程对象=threading.Thread(target=任务名)

 

 

# 方法:

#线程对象.start() 启动子线程

#     setDaemon(): 守护线程

#     join(): 阻塞线程

import time

import threading    # 导入多线程模块

 

#执行的任务

# def a():

#     print(“第一个任务”)

#     time.sleep(2)

#     print(“停顿后的任务”)

#

# def b():

#     print(“第二个任务”)

#     time.sleep(2)

#     print(“第二个停顿的任务”)

#

# if __name__ == ‘__main__’:   # 主程序入口, 规范写法

# # 3.创建子线程(实例化一个对象)  # target只需要函数名

#     t=threading.Thread(target=a)

#     t1=threading.Thread(target=b)

# # 启动子线程

#     t.start()

#     t1.start()

#结果为:第一个任务

#      第二个任务  #同时打印这两个

 

#      停顿后的任务

#      第二个停顿的任务  #在打印这两个

 

 

#带参数的多线程任务

# def a(n):

#     for i in range(n):

#         print(“第一个任务”)

#         time.sleep(2)

#

# def b(n):

#     for i in range(n):

#         print(“第二个任务”)

#         time.sleep(2)

# if __name__==”__main__”:

#     t=threading.Thread(target=a,args=(3,)) #args:以元组的方式给执行的任务传递参数  有多个参数一定要注意参数的顺序

#     t1=threading.Thread(target=b,kwargs={“n”:2}) #keargs:以字典的方式给执行的任务传递参数 字典中键名一定要和参数名一致

#     t.start()

#     t1.start()

#结果为:第一个任务

#      第二个任务  #同时打印这两个

 

#      第一个任务

#      第二个任务  #在打印这两个

 

#      第一个任务  #在打印这一个

 

 

#主线程和子线程的结束顺序

# def a():

#     for i in range(4):

#         print(“子线程”)

#         time.sleep(2)

# if __name__ ==”__main__”:

#     t=threading.Thread(target=a)

#     t.start()

#

#     time.sleep(2)

#     print(“主线程…..”)

#结果为:子线程

#           主线程…..

#           子线程

#           子线程

#           子线程

#主线程会等待所有的子线程执行结束在结束

 

 

# def a():

#     for i in range(4):

#         print(“子线程”)

#         time.sleep(2)

# if __name__ ==”__main__”:

#     #t=threading.Thread(target=a,daemon= True)   #daemon= True 方法一守护线程

#     t=threading.Thread(target=a)

#     t.setDaemon(True )      #第二种方法守护线程  守护线程 (必须放在start前面!!!)

#     t.start()

#

#     time.sleep(2)

#     print(“主线程…..”)

#结果为:子线程       #设置守护线程 主线程结束子线程也跟着结束

#      主线程…..

 

# def a():

#     for i in range(4):

#         print(“子线程”)

#         time.sleep(2)

# if __name__ ==”__main__”:

#     t = threading.Thread(target=a)

#     t.setDaemon(True )      #第二种方法守护线程  守护线程 (必须放在start前面!!!)

#     t.start()

#     t.join()  #join() 阻塞主线程有暂停的作用, 必须在start后面 等添加了join的这个子线程执行完,主线程才能继续执行

# # 调用了join方法,守护线程功能还在,只是没有体现

#     time.sleep(2)

#     print(“主线程…..”)

# #结果为:子线程

#              子线程

#              子线程

#              子线程

#              主线程…..

 

#多线程资源共享

from threading import Thread  #导入多线程模块中的Thread类

# li = []

# # 写数据

# def wdata():

#     for i in range(4):

#         li.append(i)

#         time.sleep(0.1)

#     print(‘写入的数据:’, li)

#

# # 读数据

# def rdata():

#     print(‘读取的数据:’, li)

#

# if __name__ == ‘__main__’:

#     # wd是线程对象

#     wd = Thread(target=wdata)

#     rd = Thread(target=rdata)

#     wd.start()

#     wd.join()  # 阻塞一下,等wd执行完再去执行rd

#     rd.start()

#结果为:写入的数据:[0, 1, 2, 3]

#      读取的数据:[0, 1, 2, 3]   #函数rdata共享了函数wdata的数据

 

#资源竞争

# a=0

# b=100000

# # # b的值比较小, 就没有资源竞争的问题,值比较大,计算机计算不过来, 延长时间更明显

# # 循环一次给全局变量a加1

# def jia():

#     for i in range(b):

#         global a  # 声明全局变量

#         a += 1

#     print(a)

#

# # 循环一次给全局变量a加1

# def jia2():

#     for i in range(b):

#         global a  # 声明全局变量

#         a += 1

#

#     print( a)

#

# if __name__ == ‘__main__’:

#     f1 = Thread(target=jia)

#     f2 = Thread(target=jia2)

#     f1.start()

#     f2.start()

#结果会因为b的值太大导致结果错乱可以用线程等待(join)和互斥锁

 

 

#互斥锁: 能够保证多个线程访问共享数据不能出现数据错误问题,对数据进行锁定

# 保证同一时刻只能有一个线程去操作

# 互斥锁是多个线程一起去抢,抢到锁的线程先执行,没有抢到锁的线程需要等待

# 使用互斥锁会影响代码的执行效率, 多任务变成了单任务执行

 

# 互斥锁用法

#1.创建全局互斥锁    定义互斥锁对象=Look()

#2.上锁       定义互斥锁对象.acquire()

#3.解锁      定义互斥锁对象.release() b

 

from threading import Thread,Lock

# a=0

# b=1000000

# lock=Lock() #创建全局互斥锁

# # # b的值比较小, 就没有资源竞争的问题,值比较大,计算机计算不过来, 延长时间更明显

# # 循环一次给全局变量a加1

# def jia():

#     lock.acquire()  #上锁

#     for i in range(b):

#         global a  # 声明全局变量

#         a += 1

#     print(a)

#     lock.release() #解锁

# # 循环一次给全局变量a加1

# def jia2():

#     lock.acquire()  # 上锁

#     for i in range(b):

#         global a  # 声明全局变量

#         a += 1

#

#     print( a)

#     lock.release()  # 解锁

# if __name__ == ‘__main__’:

#     f1 = Thread(target=jia)

#     f2 = Thread(target=jia2)

#     f1.start()

#     f2.start()

#结果为:1000000

#           2000000

 

 

# 总结:

# 1.threading模块定义了Lock变量,通过调用这个函数可以获取一把互斥锁

# 2.acquire()和release()方法之间的代码同一时刻只能有一个线程去操作

# 3.acquire(加锁)和release(解锁)方法必须成对出现, 加锁的后面必须先解锁再加锁,否则会造成死锁

# 互斥锁如果没有使用好容易出现死锁的情况

# 4.死锁:一直等待对方释放锁的情况,会造成程序的停止响应,不能再处理其他任务了

# 5.同步:

# 有两个线程A和B, 线程A用来写入, 线程B读取A写入的数据。

# 线程A要先写,线程B才能读,线程A和线程B之间就是一种同步关系

# 线程同步:主线程和创建的线程之间各自执行自己的代码知道结束

转载请注明:XAMPP中文组官网 » python学习整理笔记十_多线程、多进程执行多任务

您必须 登录 才能发表评论!