python中线程和进程的简单了解

一、操作系统、应用程序

　　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

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

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

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)

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

6.线程的本质

#先打印：11？end？
def func(arg):
    print(arg)

t1 = threading.Thread(target=func,args=(11,))
t1.start()
# start 是开始运行线程吗？不是
# start 告诉cpu，我已经准备就绪，你可以调度我了。
print("end")

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

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