一、操作系统、应用程序

1.硬件：硬盘、cpu、主板、显卡........

2.装系统(本身也是一个软件)：

系统就是一个由程序员写出来的软件，该软件用于控制计算机得硬盘，让他们之间进行互相配合。

3.安装软件：各种应用程序

二、并发和并行

并发：伪，由于执行速度特别快，人感觉不到停顿

并行：真，创建多个对象同时操作

三、线程、进程

1.单进程、单线程的应用程序

print("asd")

2.到底什么是线程、进程

python中没有这两个，是python调用的操作系统的线程和进程

3.单进程、多线程的应用程序

importthreading　　　　#两个进程print("start")deffunc(arg):print(arg)

t= threading.Thread(target=func,args=("......",))

t.start()print("end")#start#......#end

一个应用程序(软件)，可以有多个进程(默认只有一个)，一个进程中可以创建多个线程(默认一个)

总结：

1.操作系统帮助开发者操作硬件

2.程序员写好代码在操作系统上运行(依赖解释器)

1.线程的基本使用

importthreadingdeffunc(arg):print(arg)

t= threading.Thread(target=func,args=(11,))

t.start()print(22)#11#22

View Code

2.主线程默认等子线程执行完毕

importtimedeffunc(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.主线程不再等待子线程，主线程终止所有的子线程也终止

deffunc(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.开发者可以控制主线程等待子线程的(最多等待时间)

deffunc(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)deffunc(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.线程名称

deffunc(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？

deffunc(arg):print(arg)

t1= threading.Thread(target=func,args=(11,))

t1.start()#start 是开始运行线程吗？不是#start 告诉cpu，我已经准备就绪，你可以调度我了。

print("end")

View Code

7.面向对象版本的多线程

importthreadingclassMyThread(threading.Thread):defrun(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指令(过期时间)

importsys

v1=sys.getcheckinterval()print(v1)#100

importtimeimportthreading

lock= threading.RLock() #实例化一个锁的对象

n = 10

deffunc(i):print("这段代码不加锁",i)

lock.acquire()#加锁次区域的代码同一时刻只能有一个线程执行

globalnprint("当前线程",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