#incoding=UTF-8
#方法包装-启动多线程
from threading import Thread
from time import time,sleep


def func1(name):
    print("Threading:{}start".format(name))
    sleep(3)
    print("Threading:{}end".format(name))

if __name__ == '__main__':
    #开始时间
    start = time()
    #创建线程列表
    t_list = []
    #循环创建线程
    for i in range(10):
        t = Thread(target=func1,args=('t{}'.format(i),))
        t.start
        t_list.append(t)
    #等待线程结束
    for t in t_list:
        t.join()
    #计算使用时间
    end=time()-start
    print(end)

根据PDF敲的，这是什么情况呢？

#coding=utf-8

import threading
from socket import *
import time

def ReceiveData():
    r = socket(AF_INET,SOCK_DGRAM)
    r.bind(("192.168.0.104",7890))
    if a.acquire():
        while True:
            rec_data = r.recvfrom(1204)
            print(rec_data[0].decode())
            time.sleep(1)
            b.release()


def SendData():
    s = socket(AF_INET, SOCK_DGRAM)
    if b.acquire():
        while True:
            data = input("请输入：")
            s.sendto(data.encode(), ("192.168.0.104",7890))
            time.sleep(1)
            a.release()




if __name__ == "__main__":
    a = threading.Lock()
    b = threading.Lock()
    b.acquire()
    t1 = threading.Thread(target=ReceiveData)
    t2 = threading.Thread(target=SendData)
    t1.start()
    t2.start()

老师，我写的聊天室的程序，达不到效果，麻烦看一下哪里出错了

老师，我的网络接收器收到的消息为什么是十六进制的？

一、代码

#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()<100:
                for i in range(10):
                    count = 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()>10:
                for i in range(3):
                    msg = self.name + "消费了" + q.get()
                    print(msg)
            time.sleep(1)


if __name__ == "__main__":
    q = Queue()
    for i in range(50):
        q.put("初始产品"+str(i))
        print("初始产品"+str(i))
    for i in range(2):
        p = Pro()
        p.start()
    for i in range(5):
        c = Con()
        c.start()

二、运行结果

生成产品1

生成产品2

生成产品3

生成产品4

生成产品5

生成产品6

生成产品7

生成产品8

生成产品9

生成产品10

Thread-3消费了初始产品0

Thread-3消费了初始产品1

Thread-3消费了初始产品2

Thread-4消费了初始产品3

Thread-4消费了初始产品4

Thread-4消费了初始产品5

Thread-5消费了初始产品6

Thread-5消费了初始产品7

Thread-5消费了初始产品8

Thread-6消费了初始产品9

Thread-6消费了初始产品10

Thread-6消费了初始产品11

Thread-7消费了初始产品12

Thread-7消费了初始产品13

Thread-7消费了初始产品14

Thread-4消费了初始产品15

Thread-4消费了初始产品16

Thread-4消费了初始产品17

生成产品11

生成产品12

生成产品13

生成产品14

生成产品15

生成产品16

Thread-3消费了初始产品18

Thread-3消费了初始产品19

Thread-3消费了初始产品20

生成产品11

生成产品12

生成产品13

生成产品14

生成产品17

生成产品18

生成产品19

生成产品20

生成产品15

生成产品16

生成产品17

Thread-7消费了初始产品21

Thread-6消费了初始产品22

Thread-6消费了初始产品23

Thread-6消费了初始产品24

Thread-7消费了初始产品25

生成产品18

生成产品19

Thread-7消费了初始产品26

Thread-5消费了初始产品27

Thread-5消费了初始产品28

Thread-5消费了初始产品29

生成产品20

Thread-4消费了初始产品30

Thread-4消费了初始产品31

Thread-4消费了初始产品32

Thread-3消费了初始产品33

Thread-3消费了初始产品34

Thread-3消费了初始产品35

Thread-5消费了初始产品36

Thread-5消费了初始产品37

Thread-5消费了初始产品38

Thread-6消费了初始产品39

Thread-6消费了初始产品40

Thread-6消费了初始产品41

生成产品21

生成产品22

生成产品23

生成产品24

生成产品25

生成产品26

生成产品27

生成产品28

生成产品21

生成产品22

生成产品23

生成产品24

生成产品25

生成产品26

生成产品27

Thread-7消费了初始产品42

Thread-7消费了初始产品43

Thread-7消费了初始产品44

生成产品29

生成产品30

三、问题

上述程序创造了2个产生数据的线程p1、p2，和五个输出数据的线程c1/2/3/4/5，产生数据的线程是一个循环，产生10个数据，消费数据的线程是输出3个线程，我知道线程之间是交替执行的，但是从结果中看出，一个线程的循环都没有结束都跳去了另一个线程里呢，而且还没有规律，请问老师这样是为什么？线程交替运行这么不可控，他存在的意思是啥，都不能用来计算？

一、代码

#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 = 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(3):
                    msg = self.name + "消费了" + q.get()
                    print(msg)
            time.sleep(1)


if __name__ == "__main__":
    q = Queue()
    for i in range(500):
        q.put("初始产品"+str(i))
    for i in range(2):
        p = Pro()
        p.start()
    for i in range(5):
        c = Con()
        c.start()

二、问题

1、

上述产生数据的两个进程是同时运行的还是一个运行完再运行下一个？

如其同时运行，当第一个进程已经往池中写入“生成产品1”，第二个进程还可以往里面写入“生成产品1”吗？

老师，上面这条语句的作用是什么，刚开始使锁处于False状态，怎样会变成True呢？

老师，线程之间是共享资源的，num公用同一个内存地址，为什么主线程等所有子线程跑完，num内存里的值不应该是2000000吗？

#coding=utf-8
import threading

num=0

def test1():
    global num
    if mutex.acquire():
        for i in range(100000):
            num += 1
    mutex.release()

def test2():
    global num
    if mutex.acquire():
        for i in range(100000):
            num += 1
    mutex.release()


mutex = threading.Lock()
p1 =threading.Thread(target=test1)
p2 =threading.Thread(target=test2)
p1.start()
p2.start()
print(num)

老师，为什么我的代码不能起到互斥锁的作用呢？

老师，前面视频里讲过，一个进程中的线程共享相同的内存单元，也就意味着上图中三个num都是同一个地址，为什么还会存在运算了num+1，但没有赋值，就切换到下一个线程的情况呢，运算和赋值不就是在一个地址上加1，不存在变量引用的情况，为什么还不是同时进行的？

老师，当一个程序的主进程启动一个 主线程，主线程再去启动其他主线程，主线程和其他子线程都是在一个CPU里面进行的吗?

老师，当多个线程进入可运行状态后，能否像多个进程那行多个线程同时运行，还是像上述 PPT里讲的那样，只能一个一个线程单独运行？

老师，自建类MyThread继承了Thread类，但其中name属性应该是Thread类的初始化函数中的参数，子类继承父类但不继承初始化函数，但上述程序中自建类为什么能访问name属性呢？

老师，您在之前解答中：

但我的程序，全局变量却发生了改变，这是为啥？

视频中，老师讲到上图程序，p1和p2是同时进行的，但前面视频中不是讲到，

麻烦老师讲解一下？上述程序是跑完p1再跑p2，还是有其他运行方式？

老师，还是不太明白为什么上述程序，先输出的process1，再输出“子程序运行中”，python程序不是按顺序执行的吗？

看了您之前的解释

那为什么，不加print（p.name）这条语句也应该先输出process-1啊？

还有下面的程序

#coding=utf-8

from multiprocessing import Process

def run():
    print("子进程运行中")
if __name__ == "__main__":
    print("父进程启动")
    p = Process(target=run)
    p.start()
    p.join()
    print(p.name)

输出结果却是：

麻烦老师解释一下，怎么Process-1又在后面执行了？

最后麻烦老师讲解一下，这一张讲解多线程的目的是什么，有点蒙，为什么从讲python程序调到了多线程课程？