t = Thread(target=home,args=(f"tom{i}",se))

args里要传哪些参数？

#coding=utf-8
from socket import *
from threading import Thread

def recv_data():
    while True:
        recv_data = client_socket.recv(1024)  # 接收的最大字节数
        print(f"客户端的消息：{recv_data.decode('gbk')}")
        if recv_data == "end":
            break
def send_data():
    while True:
        msg = input("请输入消息：")
        client_socket.send(msg.encode('gbk'))

if __name__ == '__main__':
    server_socket = socket(AF_INET,SOCK_STREAM)#建立TCP套接字
    server_socket.bind(("127.0.0.1",8899))
    server_socket.listen(5)
    print("等待接收连接")
    client_socket,client_info = server_socket.accept()
    print('一个客户端建立连接成功')

    t1=Thread(target=recv_data())
    t2=Thread(target=send_data())

    t1.start()
    t2.start()

    t1.join()
    t2.join()

    client_socket.close()
    server_socket.close()

我的服务端只能接收 没法发送消息

老师，这个相当于全双工吗？能够两边同时收发？

代码及报错如上图，请老师协助解答

服务端：

socket *
threading Thread


():    :
        recv_data = s.recvfrom()  recv_content = recv_data[].decode()
        (recv_contentrecv_data[])
        recv_content == :
            ()
            ():    addr = (, )  :
        data = ()
        s.sendto(data.encode(), addr)  data == :
            ()
            __name__ == :  s = socket(AF_INET, SOCK_DGRAM)  addr = (, )  t1 = Thread(=recv_data)
    t2 = Thread(=send_data)
    t1.start()
    t2.start()
    t1.join()
    t2.join()

客户端：

socket *
threading Thread
():    :
        recv_data = s.recvfrom()  recv_content = recv_data[].decode()
        (recv_contentrecv_data[])
        recv_content == :
            ()
            ():    addr = (, )  :
        data = ()
        s.sendto(data.encode(), addr)  data == :
            ()
            __name__ == :  s = socket(AF_INET, SOCK_DGRAM)  addr = (, )  t1 = Thread(=recv_data)
    t2 = Thread(=send_data)
    t1.start()
    t2.start()
    t1.join()
    t2.join()

报错：

请输入：Exception in thread Thread-1 (recv_data):

Traceback (most recent call last):

  File "D:\Program Files\Python\Lib\threading.py", line 1038, in _bootstrap_inner

    self.run()

  File "D:\Program Files\Python\Lib\threading.py", line 975, in run

    self._target(*self._args, **self._kwargs)

  File "C:\Users\Beson\PycharmProjects\py1\python网络与并发编程\网络编程\UDP多线程实现客户端.py", line 6, in recv_data

    recv_data = s.recvfrom(1024)  # 接收数据，1024表示接收的最大字节数

                ^^^^^^^^^^^^^^^^

OSError: [WinError 10022] 提供了一个无效的参数。

请求老师帮助解答

from threading import Thread
from time import sleep
def func1(name):
    print(f"线程{name}，start")

    for i in range(3):
        print(f"thread:{name}:{i}")
        sleep(3)
    print(f"线程{name}，end")
if __name__=="__main__":
    print("主线程，start")
    t1= Thread(target=func1,args=("t1",))
    t2=Thread(target=func1,args=("t2",))
    t1.start()
    t2.start()
    print("主线程，end")

老师，你能给我讲一下代码执行的过程吗？ 线程之间会抢占输出吗？感觉还是有点懵。

不是讲的是导入模块的时候不要用*么，那是在那种情况下用*呢

t1 = Thread(target=func1,args=("t1",))

老师这个target和thread有什么关系，这个是哪里的

视频中用的模块导入补全是用的什么方法呢。

#encoding=utf-8

#方法方式创建线程

from threading import Thread

from time import sleep

def func1(name):

  for i in range(3):

    print(f"thread:{name} :{i}")

    sleep(1)

if __name__ == '__main__':

  print("主线程，start")

  #创建线程

  t1 = Thread(target=func1,args=("t1",))

  t2 = Thread(target=func1,args=("t2",))

  #启动线程

  t1.start()

  t2.start()

  print("主线程，end")

'''

运行结果可能会出现换行问题，是因为多个线程抢夺控制台输出的IO流。

比如，如下的输出换行就没有按照预想的显示：

主线程，start

thread:t1 :0

thread:t2 :0

主线程，end

thread:t2 :1thread:t1 :1

thread:t2 :2

thread:t1 :2

'''

老师 还有我不太理解这个逻辑顺序

老师我有点糊涂了 

if __name__=='__main__' 这个一般怎么用

# #coding=uft-8
from threading import Thread 
from time import sleep



def func1(name):
    print(f"线程{name},start")#format
    for i in range(3):
        print(f"线程：{name},{i}")
        sleep(3)#     print(f"线程{name},end")

if __name__ == '__main__':
     print("主线程,start")
    #创建线程
     t1 = Thread(target=func1,args=("t1"))
     t2 = Thread(target=func1,args=("t2"))
     #启动线程
     t1.start()
     t2.start()


     print("主线程,end")

显示这样的报错是什么意思啊

老师，请问为什么报这个错？我应该怎么改呢

from threading import Thread
import time

class MyThread(Thread):

    def __init__(self, name) -> None:
        Thread.__init__(self)
        self.name = name
   
    def run(self):
        print(f"线程{self.name} start")

        print(time.time())
        for i in range(100):
            print(f"线程{self.name}:",i)
        time.sleep(3)
        print(time.time())

        print(f"线程{self.name} end ")

if __name__ == "__main__":
    print("主线程 start")

    # 创建线程
    t1 = MyThread("t1")
    t2 = MyThread("t2")
    # 守护线程 daemon
    t1.daemon = True
    t2.daemon = True
    # 启动线程
    t1.start()
    t2.start()
    # join()方法 等待子线程结束后再结束主线程
    # t1.join()
    # t2.join()

    print("主线程 end")

老师，这个代码我有几个问题：

1、主线程执行完毕和主线程结束不是一回事儿的话，主线程怎么样才算结束，是执行完毕后会有一个缓冲时间，去告诉系统，我执行完毕了，可以结束了吗？

2、这里执行结束后有这个报错，是我的代码问题吗，我和课上代码对比了没有发现代码哪里有问题呀；

3、这段代码里，我用time.time()方法试了一下，sleep函数貌似失效了，没有等待时间，是直接输出的，但是我不写在线程里，单独写一个测试sleep的代码的话是能正常使用的，这是什么原因。

multiprocessing.current_process().pid

和os.getpid的作用是一样的吧