一、操作系统、应用程序
1.硬件:硬盘、cpu、主板、显卡........
2.装系统(本身也是一个软件):
系统就是一个由程序员写出来的软件,该软件用于控制计算机得硬盘,让他们之间进行互相配合。
3.安装软件:各种应用程序
二、并发和并行
并发:伪,由于执行速度特别快,人感觉不到停顿
并行:真,创建多个对象同时操作
三、线程、进程
1.单进程、单线程的应用程序
print("asd")
2.到底什么是线程、进程
python中没有这两个,是python调用的操作系统的线程和进程
3.单进程、多线程的应用程序
import threading #两个进程
print("start")
def func(arg):
print(arg)
t = threading.Thread(target=func,args=("......",))
t.start()
print("end")
# start
# ......
# end
一个应用程序(软件),可以有多个进程(默认只有一个),一个进程中可以创建多个线程(默认一个)
总结:
1.操作系统帮助开发者操作硬件
2.程序员写好代码在操作系统上运行(依赖解释器)
1.线程的基本使用
import threading
def func(arg):
print(arg)
t = threading.Thread(target=func,args=(11,))
t.start()
print(22)
# 11
# 22
View Code
2.主线程默认等子线程执行完毕
import time
def func(arg):
time.sleep(arg)
print(arg)
t1 = threading.Thread(target=func,args=(2,))
t1.start()
t2 = threading.Thread(target=func,args=(4,))
t2.start()
print("end")
# end
# 2
# 4
View Code
3.主线程不再等待子线程,主线程终止所有的子线程也终止
def func(arg):
time.sleep(arg)
print(arg)
t1 = threading.Thread(target=func,args=(2,))
t1.setDaemon(True)
t1.start()
t2 = threading.Thread(target=func,args=(4,))
t2.setDaemon(True)
t2.start()
print("end")
# end
View Code
4.开发者可以控制主线程等待子线程的(最多等待时间)
def func(arg):
time.sleep(0.01)
print(arg)
print('创建子线程t1')
t1 = threading.Thread(target=func,args=(3,))
t1.start()
# 无参数,让主线程在这里等着,等到子线程t1执行完毕,才可以继续往下走。
# 有参数,让主线程在这里最多等待n秒,无论是否执行完毕,会继续往下走。
t1.join(2)
print('创建子线程t2')
t2 = threading.Thread(target=func,args=(9,))
t2.start()
t2.join(2) # 让主线程在这里等着,等到子线程t2执行完毕,才可以继续往下走。
print(123)
def func(arg):
time.sleep(0.01)
print(arg)
print('创建子线程t1')
t1 = threading.Thread(target=func,args=(3,))
t1.start()
# 无参数,让主线程在这里等着,等到子线程t1执行完毕,才可以继续往下走。
# 有参数,让主线程在这里最多等待n秒,无论是否执行完毕,会继续往下走。
t1.join(2)
print('创建子线程t2')
t2 = threading.Thread(target=func,args=(9,))
t2.start()
t2.join(2) # 让主线程在这里等着,等到子线程t2执行完毕,才可以继续往下走。
print(123)
View Code
5.线程名称
def func(arg):
t = threading.current_thread() #获取到执行当前函数的线程对象
name = t.getName()
print(name,arg)
t1 = threading.Thread(target=func,args=(1,))
t1.setName("t1") #为线程创建名称
t1.start()
t2 = threading.Thread(target=func,args=(2,))
t2.setName("t2")
t2.start()
print("end")
# t1 1
# t2 2
# end
View Code
6.线程的本质
#先打印:11?end?
def func(arg):
print(arg)
t1 = threading.Thread(target=func,args=(11,))
t1.start()
# start 是开始运行线程吗?不是
# start 告诉cpu,我已经准备就绪,你可以调度我了。
print("end")
View Code
7.面向对象版本的多线程
import threading
class MyThread(threading.Thread):
def run(self):
print(11111,self._args,self._kwargs) #********
t1 = MyThread(args=(11,))
t1.start()
print("end")
# 11111 (11,) {}
# end
View Code
python多线程情况下:
计算密集型操作:效率低(GIL锁)
IO操作:效率高
python多进程的情况下:
计算密集型:效率高(浪费资源)
IO操作:效率高(浪费资源)
在使用时:
IO密集型用多线程:文件、输入、输出、socket网络通信
计算密集型用多进程
四、python中线程和进程(GIL锁)
GIL锁,全局解释器锁,用于限制一个进程中同一时刻只有一个线程被cpu调度。
扩展:默认GIL锁在执行100个cup指令(过期时间)
import sys
v1 = sys.getcheckinterval()
print(v1)
# 100
import time
import threading
lock = threading.RLock() #实例化一个锁的对象
n = 10
def func(i):
print("这段代码不加锁",i)
lock.acquire()#加锁次区域的代码同一时刻只能有一个线程执行
global n
print("当前线程",i,"读取到的n值",n)
n = i
time.sleep(1)
print("当前线程",i,"修改n值为",n)
lock.release() #释放锁
for i in range(10):
t = threading.Thread(target=func,args=(i,))
t.start()
# 这段代码不加锁 0
# 当前线程 0 读取到的n值 10
# 这段代码不加锁 1
# 这段代码不加锁 2
# 这段代码不加锁 3
# 这段代码不加锁 4
# 这段代码不加锁 5
# 这段代码不加锁 6
# 这段代码不加锁 7
# 这段代码不加锁 8
# 这段代码不加锁 9
# 当前线程 0 修改n值为 0
# 当前线程 1 读取到的n值 0
# 当前线程 1 修改n值为 1
# 当前线程 2 读取到的n值 1
# 当前线程 2 修改n值为 2
# 当前线程 3 读取到的n值 2
# 当前线程 3 修改n值为 3
# 当前线程 4 读取到的n值 3
# 当前线程 4 修改n值为 4
# 当前线程 5 读取到的n值 4
# 当前线程 5 修改n值为 5
# 当前线程 6 读取到的n值 5
# 当前线程 6 修改n值为 6
# 当前线程 7 读取到的n值 6
# 当前线程 7 修改n值为 7
# 当前线程 8 读取到的n值 7
# 当前线程 8 修改n值为 8
# 当前线程 9 读取到的n值 8
# 当前线程 9 修改n值为 9
View Code