线程,进程基础

操作系统/应用程序

a硬件:

  　硬盘,CPU,主板,显卡,内存,电源

b系统:

系统是一个有程序员写出来的,用来操控调用硬件的一个软件,如:windows操作系统

c安装应用程序:

 

操作系统中的"并发与并行":

并发:　　　　　　　　　　　　　　　　并行:

是伪的,因为执行速度特别快,感觉不到停顿　　　　　　　　　　　　是真的,系统同时创建多个工作单元进行操作

进程与线程:

1什么是线程?什么是进程?

单进程多线程

单进程/两线程:
import threading
def  func(arg):
    print(arg)
t=threading.Thread(target=func,args=(11,)
t.start()
print(666)

 

多进程多线程:

 

总结:一个应用程序可以有多个进程(默认是一个)也可以有多个线程(默认也是一个)

全局解释器锁(GIL):python中应用于在一个进程中同一时刻只有一个线程被调用.默认是100CPU指令

如何查看?

import sys

v1 = sys.getcheckinterval()
print(v1)

　　

线程的应用:包含setDaemon(优先执行完主线程就over)    jion(int):控制子程序可以运行的时间  线程名称:t = threading.current_thread()   name=t.getName()      t.setName(命名)

=======单线程单进程=======
import threading
def func():
        print(666)
t=threading.Thread(target=func,)

t.start()


=======单进程两线程=======
主程序默认等子程序执行完毕
import threading

def func():

    print(123)
t=threading.Thread(target=func,)
t.start()

print(666)

#结果为 123 666

========主程序不再等待,运行完则终止子程序=====
import threading
import time

def func():
    time.sleep(2)
    print(123)
t=threading.Thread(target=func,)
t.setDaemon(True)
t.start()

print(666)

#结果为  666

========开发者可以控制子线程序运行(t.join)====
import threading
import time

def func():
    time.sleep(2)
    print(123)
t=threading.Thread(target=func,)
t.start()
t.join(3)

print(666)

#结果为等待3秒后打印123 666

join()括号里面无参数,就等待子线程执行完毕后继续往下走,有参数的话就等待指定参数的后继续向下走(无论子线程有没有执行完毕)

=========线程名称======

# def func(arg):
#     # 获取当前执行该函数的线程的对象
#     t = threading.current_thread()
#     # 根据当前线程对象获取当前线程名称
#     name = t.getName()
#     print(name,arg)  #冯提莫 11
#
# t1 = threading.Thread(target=func,args=(11,))
# t1.setName('冯提莫')  #定义t1名字
# t1.start()

==========线程本质=======
t.start()是开始运行线程吗?答案是No,它只是告诉CPU我已经准备就绪,你可以调用我了,具体执行时间,看CPU的安排

面向对象版多线程:

class MyThread(threading.Thread):

    def run(self):
        print(11111,self._args,self._kwargs)

t1 = MyThread(args=(13,))
t1.start()  #自动执行run函数

t2 = MyThread(args=(22,))
t2.start()
print("end")

执行结果为:
11111 (13,) {}
11111 (22,) {}
end

 

总结:在多线程情况下:  java计算密集型操作和I/O操作效率高   而python 计算密集型操作效率低(GIL锁)  I/O操作效率高

　　在多进程情况下:JAVA使用多线程就解决了,一般不使用多进程.而python在这种情况下 计算密集型操作和I/O操作效率高,但是会浪费内存空间.

相关面试题:

总结：
		1. 应用程序/进程/线程的关系？ *****（面试题：进程/线程/协程的区别？）
		
		2. 为什么要创建线程？
			由于线程是cpu工作的最小单元，创建线程可以利用多核优势实现并行操作（Java/C#）。
			注意：线程是为了工作。
			
		3. 为什么要创建进程？
			进程和进程之间做数据隔离（Java/C#）。
			
			注意：进程是为了提供环境让线程工作。
			
		4. Python
			a. Python中存在一个GIL锁。 *****
				- 造成：多线程无法利用多核优势。
				- 解决：开多进程处理（浪费资源）
				总结：
					IO密集型：多线程 
					计算密集型：多进程

　　

线程加锁(lock):为了一次只执行一个线程,防止出现混乱的情况(如:改变全局变量)

import time
import threading

lock = threading.RLock()  #创建锁
n = 10

def task(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=task,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