并发编程在平时的项目开发中会经常用到吗?一般什么时候要用到

老师我电脑的处理器中是四核的这个没太大关系把

from threading import Thread
from time import sleep
# 线程的实现
# 方法包装

# 创建普通方法
def func1(name):
    print(f"Threading:{name} start")
    sleep(3)


if __name__ == "__main__":
    
    # 创建线程
    t1 = Thread(target=func1,args=('t1',))
    t2 = Thread(target=func1,args=('t2',))

    # 开始线程
    t1.start()
    t2.start()
    # func1('t1')
    # func1('t2')

21,22行是多线程执行任务吗？相当于是调用函数吗？

#encoding=gbk
#echo服务器（回声服务器：将接收到的消息原样发回去）
#实现聊天室功能
from threading import Thread
from socket import *
from time import sleep
def jieShou():
    while True:
        #接收消息
        redate = udpSock.recvfrom(1024)
        #打印接收到的消息
        print(redate[0].decode())
def faSong():
    global redate
    while True:
        #输入发送的信息
        data = input("请输入：")
        #发送消息
        udpSock.sendto(data.encode(),("192.168.1.9",8785))
        sleep(2)

if __name__ == "__main__":
    # 创建套接字对象
    udpSock = socket(AF_INET, SOCK_DGRAM)
    # 绑定端口
    udpSock.bind(("192.168.1.9", 8685))
    t2 = Thread(target=faSong())
    t1 = Thread(target=jieShou())
    t2.start()
    t1.start()
    udpSock.close()

#encoding=gbk
#echo服务器（回声服务器：将接收到的消息原样发回去）
#实现聊天室功能
from threading import Thread
from socket import *
from time import sleep
def jieShou():
    while True:
        #接收消息
        redate = udpSock.recvfrom(1024)
        #打印接收到的消息
        print(redate[0].decode())
def faSong():
    global redate
    while True:
        #输入发送的信息
        data = input("请输入：")
        #发送消息
        udpSock.sendto(data.encode(),("192.168.1.9",8685))
        sleep(1)

if __name__ == "__main__":
    # 创建套接字对象
    udpSock = socket(AF_INET, SOCK_DGRAM)
    # 绑定端口
    udpSock.bind(("192.168.1.9", 8785))
    t2 = Thread(target=faSong())
    t1 = Thread(target=jieShou())
    t2.start()
    t1.start()
    udpSock.close()

这两个程序相互发送消息为什么接收不到呢

#  coding=utf-8
# 死锁

from threading import Lock

def func1():
    lock.acquire()
    print('func1拿到锁')
    func2()
    lock.release
    print('func1释放锁')

def func2():
    lock.acquire
    print('func2拿到锁')
    lock.release
    print('func2释放锁')

def func3():
    func1()
    func2()

if __name__=='__main__':
    lock = Lock()
    func3()

老师，我在测试锁死的情况时，并未出现锁死现象，func1和func2都拿到了锁，这是为什么？

import asyncio
import functools


async def compute(x, y):
    print(f'compute:{x}+{y}...')
    await asyncio.sleep(1)
    return x+y


async def print_sum(x, y):        # python3.5以上
    # 创建task
    task = asyncio.create_task(compute(x, y))
    # task绑定回调函数
    task.add_done_callback(functools.partial(end, x, y))
    # 释放下cpu的使用
    await asyncio.sleep(1)


def end(n, m, t):
    print(f'{n}+{m}={t.result()}')


if __name__ == '__main__':
    # 创建事件循环
    loop = asyncio.get_event_loop()
    # 监听事件循环
    loop.run_until_complete(print_sum(1, 2))
    # 关闭事件循环
    loop.close()

老师，这边我还是不懂执行的过程，有几个问题问一下      1、这边开始运行之后先是执行print_sum函数，然后到了print_sum函数中的await时释放cpu去执行compute（）函数，然后到了compute（）函数中的await时又会回到print_sum函数中是吗？是这样的话那print_sum中的tast = asyncio.create_tast(compute())和tast.add_done_callback(functools.partial(end,x,y)不是已经运行过了吗，从compute（）函数返回时是再执行一边print_sum函数的内容吗？     2、这里end函数中的t为什么就是tast

#incoding=UTF-8
#线程的基本使用-------守护线程
from time import sleep,time
from threading import Thread


class MyThread(Thread):
    def __init__(self,name):
        Thread.__init__(self)
        self.name = name

    def run(self):
        print(f"Threading:{self.name }start")
        sleep(3)
        print(f"Threading:{self.name}end")


if __name__ == '__main__':
    # 创建线程
    for i in range(20):
        t = Thread(f't{i+1}')
        #设置当前进程为守护线程
        t.setDaemon(True)
        t.start()
    print("主进程结束了！！！")

请问这个报错的原因是什么呢？

from threading import Thread
from time import sleep


def  security_check(n):
    print(f'第{n}个人完成安检')
    sleep(2)


if __name__ == '__main__':
    for i in range(10):
        t= Thread(target=security_check ,args=(f"{i+1}"))
        t.start()

老师这里在

(f"{i+1}")后为啥不加，就是错的
，是什么意思呢

具体服务器编程在哪个章节的哪个部分

from socket import *

s = socket(AF_INET,SOCK_DGRAM)
addr = ('10.192.1.23',8080)
data = input("请输入")
s.sendto(data.encode('gb2312'),addr)
s.close()

老师，我这里接收到的怎么是这样的？

子进程会导入父进程的代码，那子进程和父进程还是拥有不同的资源吗？

已解决，助手哪里设置成16进制了。取消掉就好了。

老师那个飞秋软件也是在本章资料里面下载吗

为什么线程运行之后会返回可执行状态？不会死掉吗？

为什么sleep之后会回到可执行状态？不应该继续执行进程代码然后死掉吗？