# coding=utf-8

import threading
import time
from queue import Queue

class Pro(threading.Thread):
    def run(self):
        global q
        count = 0
        while True:
            if q.qsize()<1000:
                for i in range(100):
                    count += 1
                    msg = "生产"+str(count)
                    q.put(msg) # 往队列中添加新产品
                    print(msg)
            time.sleep(1)


class Con(threading.Thread):
    def run(self):
        global q
        while True:
            if q.qsize() > 100:
                for i in range(150):
                    msg = self.name+"消费"+q.get()
                    print(msg)
            time.sleep(1)


if __name__ == '__main__':
    q = Queue() # 创建队列，线程中能使用
    for i in range(500): # 放500个初始产品
        q.put("初始产品"+str(i))
    for i in range(2): # 两个生产者
        p = Pro()
        p.start()
    for i in range(5):  # 五个消费者
        c = Con()
        c.start()

老师，我给生产者设置的遍历区间是range(100)，给消费者设置的是range(150)，为什么消费者不能消耗完队列里面的产品，程序一会在执行。还有就是为什么要放入初始500个产品。

老师我想问一下，服务器每次能能发512B的数据，那么我们平时下载东西，比如说用迅雷下载电影，网速好的话，每秒都能达到十几M，为什么丝毫没感到慢呢，而且下载速度和带宽也有关系，麻烦解释一下！

# coding=utf-8
# 通过进程池创建进程
from multiprocessing import Pool
import random
import time

def test(num):
    print(random.random() * num)
    time.sleep(3)


if __name__ == '__main__':
    po = Pool(3)
    print("进程池创建...")
    for i in range(10):
        po.apply_async(test, (i,))  # 非阻塞方式
    po.close()
    po.join()

老师，我想问下为什么我把函数命名为test就会报错

但定义为work就能运行

老师，为什么要给整个循环上锁，有问题的是 num+=1这一句代码，不能给这一句前后加锁和解锁吗？

如果是课堂讲的那种加锁，那跟程序先启动一个线程然后调用join方法等待它执行完毕，再启动另一个线程有什么区别？

好像没有区别，如果没有区别，那干嘛要加锁多次一举呢？

import struct,socket
filename="11.jpg"
serIp="192.168.31.242"
send_data=struct.pack("!H%dsb5sb"%len(filename),1,filename.encode(),0,b'octet',0)
udpSocket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
udpSocket.sendto(send_data,(serIp,69))
f=open(filename,"ab")
while True:
    recv_data=udpSocket.recvfrom(1024)
    # print(recv_data)
    caozuoma,ack_num=struct.unpack("!HH",recv_data[0][:4])

    if int(caozuoma)==5:
        print("文件不存在")
        break
    print("操作码：%d,ACK:%d,服务器随机端口：%d，数据长度：%d"%(caozuoma,ack_num,recv_data[1][1],len(recv_data[0])))
    f.write(recv_data[0][4:])
    if len(recv_data)<516:
        break
    ack_data=struct.pack('!HH',4,ack_num)
    udpSocket.sendto(ack_data,(serIp,recv_data[1][1]))

老师这个是什么问题？

import threading,time
num = 0
def sum(x) :
    if mutex.acquire():
        for i in range(x):
            global num
            num += 1
    print(num)
    mutex.release()

def sum1(y) :
    if mutex.acquire():
        for i in range(y):
            global  num
            num +=1
    print(num)
    mutex.release()

if __name__ == "__main__" :
    mutex = threading.Lock()
    t = threading.Thread(target=sum,args=(1000000,))
    t1 = threading.Thread(target=sum1,args=(1000000,))
    t.start()
    t1.start()
    print(num)

80232

1000000

2000000

老师  这个是我这边的结果  为什么第一个print打印出来的不是1000000 而是80232

from multiprocessing import Queue,Pool,Process
import random,time
def write(q):
    for i in ['a','b','c'] :
        print('写入{0}'.format(i))
        q.put(i)
        time.sleep(2)
    print(q.qsize())
def read(q):
    while True :
        if not q.empty() :
            print('获得消息{0}'.format(q.get()))
        else:
            break
    for i in ['a', 'b', 'c']:
        print('写入{0}'.format(i))
        q.put(i)
        time.sleep(2)
def get(q):
    while True :
        if not q.empty() :
            print('获得消息{0}'.format(q.get()))
        else:
            break
if __name__ == "__main__" :
    q = Queue()
    qw = Process(target=write,args=(q,))
    qr = Process(target=read,args=(q,))
    qg = Process(target=get, args=(q,))
    qw.start()
    qw.join()
    qr.start()
    qr.join()
    qg.start()
    qg.join()
    老师如果用进程池生成进程的话，进程间通信可否操作？进程间通信指的是子进程之间的通信，如果父进程与子进程通信？

老师，你说queue中的消息是无序的，那我第一次取出来的消息我再put进去你怎么保证我二次执行for循环的时候取出来的不是同样的消息呢？

老师，一个类继续另外一个类不应该是在初始化中显式调用吗？

老师，这为什么会请求超时啊，都设置好的的，我ping了一下一网段的pc1和二网段的pc5通不通，结果请求超时

全英文版。。。那个中文包不知道放哪去，没有那个lib文件夹

老师，我这个将程序作为广播方，将网络调试助手作为接收方，为什么网络调试助手没收到消息啊

# udp广播
import socket
addr = ('<broadcast>', 8888)
s =socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST,1)
s.sendto(b'nihao', addr)

老师，有个问题，一个端口无法同时接受多个请求，那比如双十一，全国那么多人对淘宝的端口进行数据请求，然后淘宝端口进行对每个请求进行操作，出现卡的原因或者崩溃的原因是不是服务器只能对一个人进行操作，后面的人排队

老师，

第一个问题，使用循环创建多线程的话，是不是所有的线程的对象的地址都给了一个变量，之前创建线程是分t1,t2,t3的

第二个问题，这里用了两个线程去生产，如果两个线程各生产一个，是不是这两个产品都叫同一个名字，就比如这节的count给编号一样，他俩的产品编号是不是一样的

第三个问题，代码和老师一样，控制台打印为什么会乱，代码如下，截图如下

# 生产模式与消费模式
import threading, time
from queue import Queue
class product(threading.Thread):
    def run(self):
        global qu
        count = 0
        while True:
            if qu.qsize()<1000:
                for i in range(100):
                    count += 1
                    msg = '生成产品' + str(count)
                    qu.put(msg)
                    print(msg)
            time.sleep(1)

class custome(threading.Thread):
    def run(self):
        global qu
        while True:
            if qu.qsize()>100:
                for i in range(5):
                    msg = self.name+'取出的产品'+qu.get()
                    print(msg)
            time.sleep(2)

if __name__ == '__main__':
    qu = Queue()
    for i in range(500):
        num = '初始产品'+ str(i)
        qu.put(num)

    for i in range(2):
        pro = product()
        pro.start()

    for i in range(5):
        cus = custome()
        cus.start()

老师，请问全局变量global的声明在函数里声明，和在函数的循环里声明有什么区别