本文主要是阐述了线程同步python的完成及线程同步有序化，线程同步多用于与此同时启用好几个函数公式，cpu时间片轮着分给好几个每日任务
序言
线程同步多用于与此同时启用好几个函数公式，cpu时间片轮着分给好几个每日任务。特点是提升cpu的利用率，使电子计算机降低解决好几个任务总时长；主要缺点若是有静态变量，启用好几个函数公式会让静态变量被好几个函数公式改动，导致计算误差，这使得必须使用join方法或是设定静态变量去解决问题。python使用threading模块来达到线程同步，threading.join()方法是什么确保调用join的子线程结束后，才能分派cpu给其它的子线程，充分保证进程运转的有序化。
一、线程同步运作混乱难题
我们首先要建立3个案例，t1,t2,t3t1案例调用function1函数公式，t2和t3调用函数function11函数公式，她们都是对静态变量l1来操作
代码如下：
import threading,time
l1=[]
#创建RLock锁，acquire几次，release几次
lock=threading.RLock()
def function1(x,y):
for i in range(x):
l1.append(i)
if i==0:
time.sleep(1)
end_time=time.time()
print("t{}is finished in{}s".format(y,end_time-time1))
def function11(x,y):
for i in range(x):
l1.append(i)
end_time=time.time()
print("t{}is finished in{}s".format(y,end_time-time1))
#2.创建子线程：thread类
if __name__=='__main__':
t1=threading.Thread(target=function1,args=(100,1))
t2=threading.Thread(target=function11,args=(100,2))
t3=threading.Thread(target=function11,args=(100,3))
time1=time.time()
print("time starts in{}".format(time1))
t1.start()
t2.start()
t3.start()
print(l1)结果如下：
runfile('E:/桌面/temp.py',wdir='E:/桌面')
time starts in 1656474963.9487
t2 is finished in 0.0s
t3 is finished in 0.0s
[0,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99]
t1 is finished in 1.0152690410614014s
我们可以看到，全局变量中开头有两个0，而不是按着0，1，2，3的方式按序填充，所以可以得知全局变量在多线程中是被多个函数无序调用的。为了保证多线程有序调用全局变量，我们可以利用threading.join()的方法。
二、“join方法”解决多线程运行无序问题
我们重写了function1函数，并命名为function2，t1调用function2函数。t2,t3不变。
代码如下：
import threading,time
l1=[]
#创建RLock锁，acquire几次，release几次
lock=threading.RLock()
def function1(x,y):
for i in range(x):
l1.append(i)
if i==0:
time.sleep(1)
end_time=time.time()
print("t{}is finished in{}s".format(y,end_time-time1))
def function11(x,y):
for i in range(x):
l1.append(i)
end_time=time.time()
print("t{}is finished in{}s".format(y,end_time-time1))
def function2(x,y):
for i in range(x):
l1.append(i)
if i==0:
time.sleep(1)
end_time=time.time()
print("t{}is finished in{}s".format(y,end_time-time1))
#2.创建子线程：thread类
if __name__=='__main__':
t1=threading.Thread(target=function2,args=(100,1))
t2=threading.Thread(target=function11,args=(100,2))
t3=threading.Thread(target=function11,args=(100,3))
time1=time.time()
print("time starts in{}".format(time1))
t1.start()
t1.join()
t2.start()
t3.start()
print(l1)结果如下:
runfile('E:/桌面/temp.py',wdir='E:/桌面')
time starts in 1656476057.441827
t1 is finished in 1.0155227184295654s
t2 is finished in 1.0155227184295654s
t3 is finished in 1.0155227184295654s
[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99]
由此可见，threading.join()方法可以解决多线程无序问题
三、threading.Thread()的常见主要参数
1.group：初始值None，要实现ThreadGroup类而保存
2.target：在start方法中启用可启用目标，即必须打开进程可启用目标，例如函数公式、方式
3.name：默认“Thread-N”，字符数组方式的进程名字
4.args：默认空数组，主要参数target中传到可启用对象主要参数数组
5.kwargs：默认空词典{}，主要参数target中传到可启用对象关键字参数词典
6.daemon：默认None
汇总
到这里这一篇有关线程同步python的完成及线程同步井然有序类文章就分享到这了
文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。
转载请注明本文地址：https://www.ucloud.cn/yun/128716.html
摘要：的锁是非公平锁，默认情况下也是非公平锁，但可以通过带布尔值的构造函数要求使用公平锁。有序性，是保证线程内串行语义，避免指令重排等。公平性是减少线程饥饿个别线程长期等待锁，但始终无法获取情况发生的一个办法。 目录介绍 1.Synchronize和ReentrantLock区别 1.1 相似点 1.2 区别 1.3 什么是线程安全问题？如何理解 1.4 线程安全需要保证几个基本特性 ...
摘要：内存之间的交互关于主内存和工作内存之间的具体交互协议，内存模型定义了中操作来完成，虚拟机实现的时候必须保证每个操作都是原子的，不可分割的对于和有例外锁定作用于主内存变量，代表一个变量是一条线程独占。 并发不一定依赖多线程，但是在java里面谈论并发，大多与线程脱不开关系。 线程是大多是面试都会问到的问题。我们都知道，线程是比进程更轻量级的调度单位，线程之间可以共享内存。之前面试的时候，...
摘要：目的是解决由于多线程通过共享内存进行通信时，存在的原子性可见性缓存一致性以及有序性问题。最多只有一个线程能持有锁。线程加入规则对象的结束先行发生于方法返回。 前言 学习情况记录 时间：week 1 SMART子目标 ：Java 多线程 学习Java多线程，要了解多线程可能出现的并发现象，了解Java内存模型的知识是必不可少的。 对学习到的重要知识点进行的记录。 注：这里提到的是Ja...
摘要：内存模型对内存模型的介绍对内存模型的结构图的线程之间的通信是通过共享内存的方式进行隐式通信，即线程把某状态写入主内存中的共享变量，线程读取的值，这样就完成了通信。 Java内存模型（JMM） 1.对内存模型的介绍 ①对Java内存模型的结构图 java的线程之间的通信是通过共享内存的方式进行隐式通信，即线程A把某状态写入主内存中的共享变量X，线程B读取X的值，这样就完成了通信。是一种...
摘要：文章简介分析的作用以及底层实现原理，这也是大公司喜欢问的问题内容导航的作用什么是可见性源码分析的作用在多线程中，和都起到非常重要的作用，是通过加锁来实现线程的安全性。而的主要作用是在多处理器开发中保证共享变量对于多线程的可见性。 文章简介 分析volatile的作用以及底层实现原理，这也是大公司喜欢问的问题 内容导航 volatile的作用 什么是可见性 volatile源码分析 ...
阅读 889·2023-01-14 11:38
阅读 833·2023-01-14 11:04
阅读 684·2023-01-14 10:48
阅读 1887·2023-01-14 10:34
阅读 891·2023-01-14 10:24
阅读 750·2023-01-14 10:18
阅读 479·2023-01-14 10:09
阅读 519·2023-01-14 10:02
