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")

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

老师这个右下角什么意思，为什么运行不了。

请问同步执行和异步执行是什么？有什么区别？

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

#coding=utf-8
from socket import *
s=socket(AF_INET,SOCK_STREAM)
s.bind(("127.0.0.1",8899))  #本机监听8899端口
s.listen(5)
print("等待接收连接！")
client_socket,client_info=s.accept()
#client_socket表示新的客户端,client_socket表示新的客户端的ip及port
print("一个客户端建立连接成功！")
while True:
    #读取客户端消息
    redata = client_socket.recv(1024)
    recontent=redata.decode('gbk')
    print(f"客户端说：{recontent}")
    if redata=="end":
        break
        #获取控制台信息
        msg=input(">")
client_socket.send(msg.encode("gbk"))
client_socket.close()
s.close()

老师，为什么我这个从服务端给客户端发消息但是客户端那边没有显示

#coding=utf-8
from socket import *
s=socket(AF_INET,SOCK_STREAM)
s.connect(("127.0.0.1",8899))   #连接服务器端
while True:
    msg=input(">")       #向服务器发送数据
    s.send(msg.encode("gbk"))
    if msg=="end":
        break
    #接收服务器端数据
    redata=s.recv(1024)
    print("服务器端说：",redata.decode("gbk"))
s.close()

'''
验证运行速度，用循环增加多个线程
'''
#调用创建线程模块
from threading import Thread
from time import sleep
from threading import Lock
#定义方法
def f1(self):
    print(f'threading:{self}start',)
    sleep(3)
    #获取锁
    lock.acquire()
    global count
    for i in range(1000000):
        count+=1
    sleep(10)
    lock.release()
    print(f'threading:{self}end',)
#创建线程
if __name__=='__main__':
    lock=Lock()
    count=0
    t_list=[]
    for i in range(3):
        t=Thread(target=f1,args=(f't{i+1}',))
        t.setDaemon(True)
        t_list.append(t)
        t.start()

    for t in t_list:
        t.join()
    print(count)

为什么这个代码end可以输出来，我不是先守护线程，怎么还要运行join()呢

老师我这个哪里错了，搞不明白了，代码都是一样的，

老师我这个代码里的 i变量出问题说没被定义

from threading import Thread
from threading import Lock
   

def func1(name):
    # #锁
    # lock.acquire()
    #with 使用锁
    with lock:
        #全局变量
        global count
        
        for i in range(100000):
            count += 1
    # lock.release()



if __name__ == '__main__':
    count = 0
    t_list = []
    lock=Lock()
    for i in range(10):
        t= Thread(target=func1,args=(f't{i+1}',))
        t.start()
        t_list.append(t)
    for t in t_list:
        t.join()
    print(count)

老师，请问，我们之前学的位置参数和命名参数，x,y传给m,n按照位置，这里的t为什么刚好是传入的task呢

struct
socket *
filename = server_ip = send_data = struct.pack(% (filename), , filename.encode(), , .encode(), )
s = socket(AF_INET, SOCK_DGRAM)
s.sendto(send_data, (server_ip, ))  f = (filename, )  :
    recv_data = s.recvfrom()  caozuoma, ack_num = struct.unpack(, recv_data[][:])  rand_port = recv_data[][]  (caozuoma) == :
        ()
        (%(caozuoma, ack_num, rand_port, (recv_data[])))
    f.write(recv_data[][:])(recv_data[]) < :
        ack_data = struct.pack(, , ack_num)
    s.sendto(ack_data, (server_ip, rand_port))

from multiprocessing import Process
from time import sleep

class Myprocess(Process):
    def __init__(self,name):#这个name就是类里面的参数
        Process.__init__(self)
        self.name=name
    def run(self):#这个self就不需要再写个namae了 因为上面有了
        print(f"Process:{self.name}start")
        
p1=Myprocess('pcl')

p1.start()

    老师 请问报错里 为什么会出现几百行的错误 我的代码都没有那么多行

C:\Users\pcl\venv\Scripts\python.exe "C:/Users/pcl/.1aPython all exercise/线程与进程/进程实现/进程类包装.py"

Traceback (most recent call last):

  File "<string>", line 1, in <module>

  File "C:\Users\pcl\lib\multiprocessing\spawn.py", line 116, in spawn_main

    exitcode = _main(fd, parent_sentinel)

  File "C:\Users\pcl\lib\multiprocessing\spawn.py", line 125, in _main

    prepare(preparation_data)

  File "C:\Users\pcl\lib\multiprocessing\spawn.py", line 236, in prepare

    _fixup_main_from_path(data['init_main_from_path'])

  File "C:\Users\pcl\lib\multiprocessing\spawn.py", line 287, in _fixup_main_from_path

    main_content = runpy.run_path(main_path,

  File "C:\Users\pcl\lib\runpy.py", line 268, in run_path

    return _run_module_code(code, init_globals, run_name,

  File "C:\Users\pcl\lib\runpy.py", line 97, in _run_module_code

    _run_code(code, mod_globals, init_globals,

  File "C:\Users\pcl\lib\runpy.py", line 87, in _run_code

    exec(code, run_globals)

  File "C:\Users\pcl\.1aPython all exercise\线程与进程\进程实现\进程类包装.py", line 13, in <module>

    p1.start()

  File "C:\Users\pcl\lib\multiprocessing\process.py", line 121, in start

    self._popen = self._Popen(self)

  File "C:\Users\pcl\lib\multiprocessing\context.py", line 224, in _Popen

    return _default_context.get_context().Process._Popen(process_obj)

  File "C:\Users\pcl\lib\multiprocessing\context.py", line 327, in _Popen

    return Popen(process_obj)

  File "C:\Users\pcl\lib\multiprocessing\popen_spawn_win32.py", line 45, in __init__

    prep_data = spawn.get_preparation_data(process_obj._name)

  File "C:\Users\pcl\lib\multiprocessing\spawn.py", line 154, in get_preparation_data

    _check_not_importing_main()

  File "C:\Users\pcl\lib\multiprocessing\spawn.py", line 134, in _check_not_importing_main

    raise RuntimeError('''

RuntimeError: 

        An attempt has been made to start a new process before the

        current process has finished its bootstrapping phase.

        This probably means that you are not using fork to start your

        child processes and you have forgotten to use the proper idiom

        in the main module:

            if __name__ == '__main__':

                freeze_support()

                ...

        The "freeze_support()" line can be omitted if the program

        is not going to be frozen to produce an executable.

Process finished with exit code 0

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')

这个是并行还是并发

# #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")

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

def producer():
    num = 1
    if num < 10:
        if queue.qsize() < 10:
            print(f'生产:{num}号，大馒头')
            queue.put(f'大馒头：{num}号')
            num += 1
    else:
        print('馒头框满了,等待来人消费啊！')
    sleep(1)

def consumer():
    if queue.qsize() > 0:
        print(f'获取馒头：{queue.get()}')
        sleep(1)
    else:
        print('没有馒头了！')


if __name__ == '__main__':
    queue = Queue()
    t = Thread(target=producer)
    t.start()
    c = Thread(target=consumer)
    c.start()

老师，我自己写的代码，但是始终都只能生产一个馒头并获取一个馒头。请问问题出在哪里？谢谢！

老师，多线程之间的切换需要用到多核的CPU吗?，我看笔记上写的“真正地同时执行多线程需要多核CPU 才可能实现。”，但是又说了“协程的本质是个单线程,它不能同时将单个CPU 的多个核用上,协程需要和进程配合才能运行在多CPU上”。如果多线程之间的切换要用到多核的CPU，那为什么不能让协程和线程配合？