from multiprocessing import Process, current_process, Pipe
import os

def func(name, con):
    print('进程ID {} 获取了数据：\n{}'.format(os.getpid(), con.recv()))
    con.send("朝如青丝暮成雪。")
if __name__ == '__main__':
    print('进程ID:{}'.format(current_process().pid))
    
    con1 = Pipe()
    con2 = Pipe()
    p1 = Process(target=func, args=('p1', con1))
    p1.start()
    con2.send("高堂明镜悲白发，")
    p1.join()

    print(con2.recv())

老师为什么这样，会报错？这种和视频的，应该道理一样的吧！

老师可以讲解一下这个 self.account.money吗

老师，下载greenlet的时候，出现这个，之前下载pygame也还没下载到

老师你好，为什么要调用Thread的初始化方法啊？作用是什么?

它和super()的作用有什么区别吗？

from threading import Thread,Event
from time import sleep
'''
几分钟一辆车
人上车和车辆可以上人是要同时进行的，车辆不在站内和人等待车也是同时进行的
'''

def car():
    num=0
    #global count,有event就不用count了
    while True:
        if event.is_set():      #count%5!=0:
            print('车已到站，可以上车')
            sleep(1)
            #count+=1   #就是上了四个人后开走了
            num+=1
            if num%5==0:
                event.clear()       #上了五个人开走了
        else:
            print("车开走了....")
            sleep(6)
            #count=1        
            #过了六秒后又开来了
            event.set()     #重新变成真的
def person():
    while True:
        #if count%5!=0:
        if event.is_set():
            print('上车！！')
            sleep(1)
        else:
            print('等待车！！！') #用count的时候，等待一直在刷，程序没有停下来
            event.wait()        #阻塞线程
            #sleep(1)
if __name__=="__main__":
    event=Event()
    count=1
    t1=Thread(target=car)
    t2=Thread(target=person)
    t1.start()
    t2.start()

老师，这个event是在车方法里面变成True的，怎么在人方法里面也是True了，两个方法不是一个栈帧里面的，他们的调用event方法也能共用？

threading Thread
time sleep


(name):
    (name)  i ():
        (namei)
        sleep()
    (name)

__name__ == :
    ()
    t1 = Thread(=func1,=(,))
    t2 = Thread(=func1, =(,))
    t1.start()
    t2.start()
    ()

线程t2,1为什么在线程t1,1前面

一、代码

from threading import Thread
from time import sleep
# 线程的实现
#方法包装
# coding=gbk
#创建普通方法
def func1(name):
    print(f"Threading:{name} start")

#创建线程
t1=Thread(target=func1,args=('t1',))    #args传入的必须为元组
t2=Thread(target=func1,args=('t2',))

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

二、结果

三、问题

老师，百度以后添加了#coding=gbk 发现还是没用，请问怎么解决这个问题

老师，什么原因

聊天室1

#tcp服务器
from threading import Thread
from socket import*

#  创建sock对象
udpSock = socket(AF_INET, SOCK_DGRAM)
#绑定ip地址端口
addr = (("",8080))
#发送数据
def fasong():
    while True:
        date = input("输入：")
        udpSock.sendto(date.encode('gb2312'),fasong[1])
#接收数据
def jieshou():
    while True:
        jieshus = udpSock.recvfrom(1024)
        print(jieshus[0].decode())

#创建线程
t1 = Thread(target = fasong())
t2 = Thread(target = jieshou())
#启动线程
t1.start()
t2.start()
udpSock.close()

聊天室2

from threading import Thread
from socket import*
#创建sock对象
udpSock = socket(AF_INET,SOCK_DGRAM)
#绑定ip 地址端口
udpSock.bind(("",8080))
#接收数据
def jieshou():
    while True:
        jieshou = udpSock.recvfrom(1024)
        print(jieshou[0].decode('gb2312'))
#发送数据
def fasong():
    while True:
        date =  input("输入：")
        udpSock.sendto(date.encode('gb2312'),fasong[1])
#创建线程

t1 = Thread(target= fasong())
t2 = Thread(target= jieshou())
    #启动线程
t1.start()
t2.start()

threading Thread
time sleep


MyThread(Thread):
    (name):
        Thread.()
        .name = name

    ():
        i ():
            (.namei)
            sleep()


__name__ == :
    ()
    t1 = MyThread()
      t2 = MyThread()
    t1.start()
      t2.start()

t1 = MyThread()
t2 = MyThread()

这块不用传递参数吗，给参数t1就报错

什么是io流                    

import time
from threading import Thread


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

    def run(self):
        print(f'线程{self.name}启动')
        for i in range(5):
            time.sleep(1.0)
            print(f'线程{self.name}:{i}')
        print(f'线程{self.name}结束')
if __name__ == '__main__':
    print('主线程启动了！')
    #创建线程
    t1 = myThread('t1')
    t2 = myThread('t2')
    t1.daemon = True
    t1.start()
    t2.start()

    print('主线程结束了！')

老师，为啥我创建t1和t2两个子线程，其中t1设置为守护线程，主线程结束后t1没有立马结束啊

from multiprocessing import Process, Semaphore, Lock, Queue
import time

empty = Semaphore(2)
full = Semaphore(0)
lock = Lock()


class Consumer(Process):
    def __init__(self, buffer):
        Process.__init__(self)
        self.buffer = buffer

    def run(self):
        while True:
            full.acquire()
            lock.acquire()
            info = self.buffer.get()
            print('Consumer pop an element',info)
            time.sleep(1)
            lock.release()
            empty.release()


class Producer(Process):
    def __init__(self, buffer):
        Process.__init__(self)
        self.buffer = buffer

    def run(self):
        while True:
            empty.acquire()
            lock.acquire()
            self.buffer.put('bmt')
            print('Producer append an element')
            time.sleep(1)
            lock.release()

            full.release()


if __name__ == '__main__':
    buffer = Queue(10)
    p = Producer(buffer)
    c = Consumer(buffer)
    p.daemon = True
    c.daemon = True
    p.start()
    c.start()
    p.join() 
    c.join()
   

    print('Ended!')

老师，这个代码只输出两个

Producer append an element

Producer append an element

就卡住不执行了，老师帮我分析下，谢谢！

老师 帮忙看看 哪里不对了  一直都是文件不存在   换了好多个路径

from socket import *
import struct
filename="微信图片_20200114223139"
server_ip="192.168.1.7"
send_data=struct.pack("!H%dsb5sb"%len(filename),1,filename.encode(),0,"octet".encode(),0)
s= socket(AF_INET,SOCK_DGRAM)
s.sendto(send_data,(server_ip,69))
f= open(filename,"ab")
while True:
    recv_data = s.recvfrom(1024)
    caozuoma,ack_num = struct.unpack("!HH",recv_data[0][:4])
    rand_port=recv_data[1][1]
    if int(caozuoma)==5:
        print("文件不存在...")
        break
    print("操作码：%d,ACK:%d,服务器随机端口：%d，数据长度：%d"%(caozuoma, ack_num,rand_port,len(recv_data[0])))
    f.write(recv_data[0][4:])#将数据写入
    if len(recv_data[0])<516:
        break
    ack_data=struct.pack("!H",4, ack_num)
    s.sendto(ack_data,(server_ip,rand_port))#回复ACK确认包

老师，按照视频的操作，但为啥这个电脑查不了啊？