#encoding=utf-8
from socket import *

server_socket = socket(AF_INET,SOCK_DGRAM)#创建TCP套接字
server_socket.bind(("127.0.0.1",8899))#本机监听8899端口
server_socket.listen(5)
print("等待接受连接！")
client_socket,client_info = server_socket.accept()
recv_data = client_socket.recv(1024)#最大接受1024字节
print(f"收到信息:{recv_data.decode('gbk')},来自:{client_info})")
client_socket.close()
server_socket.close()

老师帮我看下哪里错了

请问本节课的代码，为什么输出的count应该是10的倍数？

function中运行后不应该是1+2+..+10000 吗?

然后20行：

for i in range(10)：

是表示function中count的结果继续加吗？谢谢

老师，这个父进程的关系我没看懂诶，为什么是这样继承的呢

老师，vscode怎么多窗口运行终端呢，运行服务端之后就无法打开新窗口运行服务端，应该有哪个设置没找到吧（在pycharm里就可以）

# 未使用线程同步和互斥锁的情况
from threading import Thread
from time import sleep


class Account:
    def __init__(self,money,name):
        self.money = money
        self.name = name

# 模拟提款操作
class Drawing(Thread):
    def __init__(self,drawingNum,account):
        Thread.__init__(self)
        self.drawingNum = drawingNum
        self.account = account
        self.expenseTotal = 0
    def run(self):
        if self.account.money<self.drawingNum:
            return
        sleep(2)  # 判断完可以取钱，则阻塞。就是为了测试发生冲突问题
        self.account.money -= self.drawingNum
        self.expenseTotal += self.drawingNum
        print(f"账户：{self.account.name},余额是:{self.account.money}")
        print(f"账户：{self.account.name},总共取了:{self.expenseTotal}")

if __name__ == '__main__':
    a1 = Account(100,"高淇")
    draw1 = Drawing(80,a1)   # 定义一个取钱的线程
    draw2 = Drawing(80,a1)   # 定义一个取钱的线程
    draw1.start()
    draw2.start()

老师，这里Account中的2个属性是如何能被Drawing类所使用，没有调用也没有继承，是如何传递过去的？

from threading import Thread
from time import sleep

# 类实现-多线程
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 = MyThread(f"t{i+1}")
        # 设置当前进程为 守护线程（必须在start前） 守护线程概念；当前主进程结束后，剩下子进程也结束，不造成资源浪费
        t.setDaemon(True)
        t.start()

print("主进程结束了！！！")
# 整个代码运行起来就是主线程 由主线程创建的thread对象 for循环就是子线程

老师 我线程搞明白了 但是进程没太弄明白 就是主进程和子进程

asyncio
functools
(xy):
    (xy)
    asyncio.sleep()
    x+y

(xy):
    task = asyncio.create_task(compute(xy))
    task.add_done_callback(functools.partial(endxy))
    asyncio.sleep()
    i ():
        i%== :
            (i)
            asyncio.sleep()

(nmt):
    (nmt.result())

__name__ == :
    loop = asyncio.get_event_loop()
    loop.run_until_complete(print_sum())
    loop.close()

老师我运行之后报这个错误：

Traceback (most recent call last):

  File "E:/pythonStation/Thread/30_协程的基本使用-asyncio的task的用法.py", line 25, in <module>

    loop.run_until_complete(print_sum(1,2))

  File "D:\python\lib\asyncio\base_events.py", line 468, in run_until_complete

    return future.result()

  File "E:/pythonStation/Thread/30_协程的基本使用-asyncio的task的用法.py", line 10, in print_sum

    task = asyncio.create_task(compute(x,y))

AttributeError: module 'asyncio' has no attribute 'create_task'

 这是为什么呢？

老师，放在main里定义的变量是全局变量？

您好，老师，这个为啥报错？内容和老师讲的一样敲的。

3到13号不是11个嘛？，但是设置最大生产是10个啊

from socket import *
import time

host = 'localhost'
port = 8080
addr =(host,port)
bufferSize = 10
fullData = b''
tcpServerSocket = socket(AF_INET,SOCK_STREAM)
tcpServerSocket.bind(addr)
print('********服务器正在监听********')
tcpServerSocket.listen(5)
tcpClientSocket,addr = tcpServerSocket.accept()
while True:
    data = tcpClientSocket.recv(bufferSize)
    fullData += data
    if len(data) < bufferSize :
        break
print(time.ctime()+'\n'+fullData.decode(encoding='utf-8'))
print('********给客户端发送确认消息********')
tcpClientSocket.send(time.ctime().encode(encoding='utf-8')+b'\n'+'已收到客户端请求'.encode('utf-8'))
tcpClientSocket.close()
tcpServerSocket.close()

老师好！ 我设置的bufferSize =10     我从客户端输入10个字节的字符 比如helloworld 服务器端都不会有响应，其他情况都可以。我知道是因为data长度为10的时候，进程正好读完，进程并没有读下一次使break执行，但是改怎么改呢？请老师指教

主进程下子进程，子进程下子线程，    

主进程下主线程，主线程下子线程，

进程池涵盖多进程。

子进程可以调用外部一个模块实现互相通信

在一个主进程下，import该怎么调用模块，因为他们互相之间是互通的，写代码第一行就应该用import把他们都罗列出来么？

我下面写的不是程序，只是想表达的意思，他们同时存在？如何同时调用？因为有时候需要通信，我就懵了

而且如果罗列到一起后，程序写完，主进程下的，我应该叫他    子进程？还是主线程？

这些叫法我听着有点绕呢，但是实际摆在眼前的就是一个程序，我理解就是一个主程序，下面有两个子进程，子进程里有两个子线程，从上到下实现。但是课程讲的是这三个进程是各干各的？还没有规律？懵了，老师帮我缕缕吧。。。

from multiprocessing import Process
from multiprocessing import Pool
from multiprocessing import Queue
import threading

老师，您看一下，我写的，我收不到消息

from socket import *
# 发信息

s = socket(AF_INET,SOCK_DGRAM)
s.bind(('', 8788))
s.sendto(b"aaabbbccc", ("112.10.81.85", 8099))
redate = s.recvfrom(1024)
print(redate[0].decode()) 

"""收信息程序"""
from socket import *

udpSock = socket(AF_INET, SOCK_DGRAM)
udpSock.bind(("", 8099))
while True:
    recvDate = udpSock.recvfrom(1024)
    print(recvDate[0].decode())
    udpSock.sendto(recvDate[0], recvDate[1])

udpSock.close()

老师，您看一下，我的IP地址，是我百度搜索的

同样是函数，为什么func()函数括号里面可以写name,run()函数括号里不能写name？

import asyncio


async def compute(x, y):
    print(f'正在计算 {x}+{y} 的结果，请稍后...')
    await asyncio.sleep(1)
    return x+y


async def print_sum(x, y):
    result = await compute(x, y)
    print(f'计算结果是：{x}+{y}={result}')


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

问题：

老师，执行 result = await compute(x,y) 这句后，会等待计算任务执行完返回 x+y 的值赋给 result 再继续往下执行，这里是异步阻塞执行对吗？