多线程，进程，协程

标签：字典   形式   互斥   行锁   控制台   进程   默认   写入   size   

# 1.多任务：在同一时间内执行多个任务
# 操作系统可以同时运行多个软件

# 2.多任务的执行方式（了解）
# 2.1 并发
# 2.2 并行

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

# 3. 进程和线程
# 进程：运行的一个程序至少会有一个进程，是操作系统进行资源分配的基本单位
# 一个进程默认有一个线程，进程里面可以创建多个线程，线程是依附在进程里面的

# 线程：进程中执行代码的一个分支, cpu调度的基本单位

# sixstar公司 -- 进程
# 电脑、桌椅 -- 进程分配的资源
# 员工 -- 线程

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

# 4.单线程
import time

# print(123)
# time.sleep(1.5) # 睡眠，小括号中是单位
# print(456)

# def study():
# print(‘晴天不天晴‘)
# time.sleep(2) # 等待1秒后执行下一句代码
# print(‘在敲代码...‘)
#
#
# def listen():
# print(‘玖號‘)
# time.sleep(2)
# print(‘在听歌曲...‘)

# study()
# listen()

# 5.多线程
# threading模块 Thread类

# 线程类Thread参数：
# target: 执行的目标任务名
# args: 以元组的形式是给执行任务传参
# kwargs:以字典的形式是给执行任务传参

# 方法：
# start(): 启动子线程
# setDaemon(): 守护线程
# join(): 阻塞线程

# 5.1 举例：
# 控制台打印出现在同一行,资源竞争导致

# 1.导入模块
# import threading
#
# # 2.执行的任务
# def study():
# print(‘晴天不天晴‘)
# time.sleep(2) # 等待1秒后执行下一句代码
# print(‘在敲代码...‘)
#
#
# def listen():
# print(‘玖號‘)
# time.sleep(2)
# print(‘在听歌曲...‘)
#
#
# if __name__ == ‘__main__‘: # 主程序入口, 规范写法
#
# # 3.创建子线程(实例化一个对象)
# # target只需要函数名
# t1 = threading.Thread(target=study)
# t2 = threading.Thread(target=listen)
#
# # 4.启动子线程
# t1.start()
# t2.start()

# 5.2
from threading import Thread
def study(**kwargs):
print(f‘第{kwargs}位同学：晴天不天晴‘)
time.sleep(2)
print(‘在敲代码...‘)

def listen(*args):
print(f‘第{args}位同学：玖號‘)
time.sleep(2)
print(‘在听歌曲...‘)

if __name__ == ‘__main__‘:
# 1.创建子线程
f1 = Thread(target=study, kwargs={‘name‘: ‘zs‘}) # 元组中只有一个元素时，记得加逗号
f2 = Thread(target=listen, args=(6,))

# 3.setDaemon() 守护线程 (必须放在start前面！！！)
# 守护线程：主线程执行完了，子线程也跟着结束
f1.setDaemon(True)
f2.setDaemon(True)

# 2.开启子线程
f1.start()
f2.start()

# 4.join() 阻塞主线程
# 有暂停的作用, 必须在start后面
# 等添加了join的这个子线程执行完，主线程才能继续执行
# 调用了join方法,守护线程功能还在，只是没有体现
f1.join()
f2.join()

# 6.修改名字
f1.setName(‘周凯‘)
f2.setName(‘深巷‘)

# 5.获取名字
# print(f1.getName()) # Thread-1
# print(f2.getName()) # Thread-1

print(‘哈哈哈哈, 这是主线程....‘)

# 1.线程执行代码的封装

from threading import Thread

# 线程类
# class Mythread(Thread): # 需要继承Thread类
#
# # 重构run方法，规定是这个名字，表示线程活动的方法
# def run(self):
# print(123)
#
#
# if __name__ == ‘__main__‘:
# # 创建一下线程实例
# my = Mythread()
# # 启动线程
# my.start()

# 2. 线程之间执行是无序的
# import threading
# import time
#
# def funa():
# time.sleep(1)
# # name: 查看线程名的属性
# print(‘当前线程是：‘, threading.current_thread().name) # 查看当前运行的线程名
#
#
# if __name__ == ‘__main__‘:
# for i in range(5):
# f1 = threading.Thread(target=funa)
# f1.start()

# 1.多线程资源共享
# from threading import Thread
import time

# 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执行完再去执行rd
# wd.join()
# rd.start()

# 2. 资源竞争

# a = 0
# b = 1000000
# # 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()

# 3.线程同步
# 线程等待（join）
# 互斥锁: 能够保证多个线程访问共享数据不能出现数据错误问题，对数据进行锁定
# 保证同一时刻只能有一个线程去操作

# 互斥锁是多个线程一起去抢，抢到锁的线程先执行，没有抢到锁的线程需要等待
# 使用互斥锁会影响代码的执行效率, 多任务变成了单任务执行

from threading import Thread, Lock
a = 0
b = 1000000

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

# 循环一次给全局变量a加1
def jia():
# 2.加锁
# 运行到这里的时候，我用的时候你不能用
lock.acquire()
for i in range(b):
global a
a += 1
print(‘第一次：‘, a)
# 3.解锁
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()
# f1.join()
f2.start()

多线程，进程，协程

标签：字典   形式   互斥   行锁   控制台   进程   默认   写入   size   

原文地址：https://www.cnblogs.com/Daveb/p/14532559.html