（三）多线程（银行家算法，udp多线程聊天）

https://blog.csdn.net/wingzhezhe/article/details/79201902（多线程参考）

并行和并发区别：
并发：表示同时发生了多件事情，通过时间片切换，哪怕只有单一的核心，也可以实现“同时做多件事情”这个效果
并行：的意思是真的同时执行
举例（我们说资源请求并发数达到了1万。这里的意思是有1万个请求同时过来了。但是这里很明显不可能真正的同时去处理这1万个请求的吧！如果这台机器的处理器有4个核心，不考虑超线程，那么我们认为同时会有4个线程在跑。也就是说，并发访问数是1万，而底层真实的并行处理的请求数是4。如果并发数小一些只有4的话，又或者你的机器牛逼有1万个核心，那并发在这里和并行一个效果。也就是说，并发可以是虚拟的同时执行，也可以是真的同时执行。而并行的意思是真的同时执行。）
例子：

import threading
import time

def run1():
    for i in range(5):
        print('正在执行run1')
        time.sleep(1)
def run2():
    for i in range(5):
        print('正在执行run2')
        time.sleep(1)
def main():
    t1=threading.Thread(target=run1)
    t2=threading.Thread(target=run2)

    t1.start()                #start开始才建立分线程
    print(threading.enumerate()) #打印线程个数
    t2.start()
    print(threading.enumerate())

if __name__ == '__main__':
    print(threading.enumerate())  #开始有一个主线程
    main()

执行结果：
[<_MainThread(MainThread, started 14772)>]
正在执行run1
[<_MainThread(MainThread, started 14772)>, <Thread(Thread-1, started 18472)>]
正在执行run2
[<_MainThread(MainThread, started 14772)>, <Thread(Thread-1, started 18472)>, <Thread(Thread-2, started 18976)>]
正在执行run1
正在执行run2
正在执行run1
正在执行run2
正在执行run1
正在执行run2
正在执行run1
正在执行run2

查看线程

threading.enumerate()

import  threading
import time

def t1():
    for i in range(3):
        print('t1')
        time.sleep(1)


def run():
    thread1=threading.Thread(target=t1)
    thread1.start()

    num=threading.enumerate()
    print(num)

if __name__ == '__main__':
    run()

线程的开始是从start（）开始的 ，当调用Thread（）的时候不会创建线程，当调用实例对象的start方法的时候才会创建
如果创建Thread时执行的函数，运行结束，那么意味着，这个子线程结束了

线程的同步概念以及互斥锁解决资源竞争问题

同步的概念

就是指同步骤：按指定的先后次序进行运行，如：你说完，我再说。
‘同’从字面上容易理解为一起动作，其实不是，同是指协同，相互配合
如进程，线程同步，可理解为A和·B一起配合，A进行到一定程度依靠B的某个结果，于是停下，B开始进行运行。再将结果给A，A在继续操作

互斥锁

当多个线程几乎同时修改某一个共享数据的时候，需要进行同步控制。
当某个线程更改共享数据时，先将其锁定，此时资源的状态为锁定，其他的线程不能更改，直到该线程释放资源，将资源的状态变为非锁定，其他的线程才能再次修改，互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程先数据的正确性
例子：没有互斥锁时：

# -*- coding: UTF-8 -*-
import threading 
import time
num=0
def text1(number):
	global num
	for i in range(number):
		num+=1
	print('text1:',num)

def text2(number):
	global num
	for i in range(number):
		num+=1
	print('text2:',num)

def main():
	t1=threading.Thread(target=text1,args=(100000,))
	t2=threading.Thread(target=text2,args=(20000,))
	t1.start()
	t2.start()
	print('main：',num)

if __name__=='__main__':
	main()
出现错误的结果

创建互斥锁的过程：
1，#创建锁：mutex=threading.Lock()
2,#锁定：mutex.acquire()
3,#释放：mutex.release()
注意：- 如果这个锁之前没有上多，那么acquire不会堵塞
- 如果调用acquire对这个锁上锁之前，它已经被其他线程上锁，那么此时acquire锁被解锁为止

# -*- coding: UTF-8 -*-
import threading 
import time
num=0
#创建一个锁
mutex=threading.Lock()
def text1(number):
	global num

	for i in range(number):
		mutex.acquire()  #上锁  中间的代码越少越好
		num+=1
		mutex.release() #释放锁
	print('text1:',num)


def text2(number):
	global num

	for i in range(number):
		mutex.acquire()
		num+=1
		mutex.release()
	print('text2:',num)


def main():
	t1=threading.Thread(target=text1,args=(100000,))
	t2=threading.Thread(target=text2,args=(20000,))
	t1.start()
	t2.start()
	time.sleep(1)
	print('main：',num)

if __name__=='__main__':
	main()

死锁和银行家算法

死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。

解决的方法：

银行家算法主要分为两部分，安全检测和资源请求部分。该算法主要有四大数据结构：

下面简要介绍一下：

Resource：系统中的资源总量

Available：系统中尚未分配的，可以使用的资源量

Need：每个进程对每种资源的最大需求量。（一行代表某个进程，一列代表某种资源）

Allocation：目前已经分配的情况

安全检测

若在资源请求的时候，本次的请求超过了它最初的资源要求总量，那么该进程就会因为总资源数不足而挂起。如果满足那么继续判断： 如果申请的资源数，大于可以使用的资源数，那么该进程就会因为可用资源数不足而挂起。否则继续分配。

资源分配算法

下面用一个实例来说明银行家算法的实现：

如图，系统中有三种资源R1,R2,R3，总量分别是9，3，6。当前已经将他们分配给了4个进程，问是否存在一个安全序列P，使得这组进程在执行期间处于安全状态？

由前面的两个矩阵和总资源数，很容易算出可供分配的资源数为（0,1,1）.

于是我们就可以分析一下该算法的过程了：

1. 首先我们先按顺序，将所有的可分配资源分配给P1，得出此时P1的资源数（左边），和P1的最大资源需求数（右边的need）。发现此时p1的资源不足以让运行，于是不分配给p1，让它暂时挂起，继续判断：

2. 接着我们按顺序，把所有的资源分配给P2，这个时候分配的资源数已经足够满足need矩阵了，程序顺利运行，然后退出的时候将所占有的资源全部释放，此时Available（可用资源数）增加，增加的量就是原P2所占有的量，从解题步骤来看，Available的数值就是我们之前假设的把所有资源都加在P2那时候的状态。

3. 此时因为资源增加了，可以将之前的P1再分配资源看看够不够，或者直接向下给P3分配。都可以，不过推荐第一种方式，因为怕遗漏。

4. 然后重复上面的操作，如果始终有某个进程不能满足，那么就不存在安全状态，否则全部程序能按此顺序完成，这就是安全状态。

我们发现，按照刚刚执行的顺序， <P2 ->P1->P3 ->P4>,那么这组进程一定不会发生死锁，也就是我们说的安全序列。

当然上面的P3和P1的顺序调换，也是安全序列。所以，安全序列有可能不止一个。 到了最后的进程退出的时候，注意到Available的值一定等于总资源数。

死锁的解除

那么如果死锁一旦发生了呢？那就得解除这个状态。我们一般有一下方式：

1. 撤销死锁进程

2. 剥夺死锁进程的资源，直到不存在死锁

3. 鸵鸟算法（即直接忽略，当做什么都没发生，说出来可能不信，绝大多数的操作系统选择这个方法）。

利用多线程实现udp聊天器

import socket
import threading
'''原理开启两个线程一个用来发送消息一个用来接受消息'''
def rec_msg(udp_socket):
    while True:
        rec_data = udp_socket.recvfrom(1024)
        print('接受的数据', rec_data)


def send_msg(udp_socket):
    while True:
        send_data = input('输入发送的数据：')
        udp_socket.sendto(send_data.encode('gbk'), ('127.0.0.1', 8080))



def main():
    udp_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
    udp_socket.bind(('127.0.0.1',7900))
    t1=threading.Thread(target=rec_msg,args=(udp_socket,))
    t2 = threading.Thread(target=send_msg, args=(udp_socket,))
    t1.start()
    t2.start()
    # while True:
    #     data=udp_socket.recvfrom(1024)
    #     print(data)


if __name__ == '__main__':
    main()