import time
from threading import Thread
def func(args):time.sleep(1)print(args)t = Thread(target=func,args=(10,))
# 传入的参数也必须以元组的形式传
t.start()# 创建线程的另一种方式（使用面向对象创建线程）
import time
from threading import Thread
class MyTread(Thread):def __init__(self,arg):super().__init__()    # 调用父类的__init__self.arg = argdef run(self):        # 方法名必须是runtime.sleep(1)print(self.arg)t = MyTread(10)
t.start()

import time
from threading import Thread
from multiprocessing import Process
def func(n):n + 1if __name__ == '__main__':start1 = time.time()t_lst1 = []for i in range(100):t = Thread(target=func,args=(i,))t.start()t_lst1.append(t)for t in t_lst1:t.join()t1 = time.time() - start1start2 = time.time()t_lst2 = []for i in range(100):t = Process(target=func, args=(i,))t.start()t_lst2.append(t)for t in t_lst2: t.join()t2 = time.time() - start2print(t1,t2)输出的结果为:
0.02698826789855957 10.160863876342773# 可见开启一个线程所需要的时间要远远小于开启一个进程

多进程修改全局变量
import os,time
from multiprocessing import Process
from threading import Threaddef func():global gg -= 10print(g,os.getpid())g = 100   # 全局变量g
t_lst = []
if __name__ == "__main__":for i in range(5):t = Process(target=func)t.start()t_lst.append(t)for t in t_lst: t.join()print(g)
"""输出结果为：
90 143648
90 160300
90 143316
90 160804
90 159348
100
"""多线程修改全局变量
import os,time
from multiprocessing import Process
from threading import Threadfor i in range(5):t = Thread(target=func)t.start()t_lst.append(t)
for t in t_lst : t.join()
print(g)
"""输出的结果为;
90 161716
80 161716
70 161716
60 161716
50 161716
50
"""

例子：
import time
import threadingdef func(n):time.sleep(0.5)print(n,t.getName(),threading.get_ident(),t.isAlive())
# 打印线程名，线程号，判断线程是否在活动# 当一个线程执行完成func之后就结束了，t.isAlive()查看为Falsefor i in  range(5):t = threading.Thread(target=func,args=(i,))t.start()t.join()print(threading.active_count())    # 查看程序中存在多少个活着的线程
print(threading.current_thread())   # 查看当前线程的线程名和线程号
print(threading.enumerate())        # 查看程序中的所有线程的线程名和线程号（列表的形式列出每个线程）"""执行结果为：
0 Thread-1 33164 True
1 Thread-2 57836 True
2 Thread-3 165280 True
3 Thread-4 171196 True
4 Thread-5 119008 True
1
<_MainThread(MainThread, started 165276)>
[<_MainThread(MainThread, started 165276)>]
"

View Code

from threading import Thread
import timedef func():print('我是守护线程')time.sleep(0.5)print('守护线程结束了')def func2():print('我是线程2，非守护线程')time.sleep(2)print('func2执行完了')t = Thread(target=func)
t.daemon = True        # 仍是加在start()前
t.start()
t2 = Thread(target=func2)
t2.start()print('我是主线程')
t2.join()
print('主线程结束了。')"""执行结果为：
我是守护线程
我是线程2，非守护线程
我是主线程
守护线程结束了
func2执行完了
主线程结束了。
"""# 主进程在执行完自己的代码之后不会立即结束 而是等待子进程结束之后 再结束。然后回收子进程的资源

实例

from threading import Thread
import time
def func():global ntime.sleep(0.5)n-=1n = 10
t_list = []
for i in range(10):t = Thread(target=func)t.start()t_list.append(t)[t.join() for i in t_list]
print(n)
# 输出结果n为9
# 创建线程非常快，创建的10个线程都拿到了global的n,此时n为10，然后各线程都做-1操作，得到的结都为9

不加锁

from threading import Thread
from threading import Lockdef func(lock):global nlock.acquire()n-=1lock.release()lock = Lock()
n = 10
t_list = []
for i in range(10):t = Thread(target=func,args=(lock,))t.start()t_list.append(t)[t.join() for i in t_list]
print(n)
# 输出的结果为0
通过加锁后保证了多线程数据安全，但损失了效率

加锁

多人吃面事例:
# 有多个人在一个桌子上吃面，只有一份面和一个叉子，当一个人同时拿到了这两样才能完成一次吃面的动作。
from threading import Thread,Lock
import timedef eat1(name):noodle_lock.acquire()print('%s拿到面条了'%name)fork_lock.acquire()print('%s拿到叉子了'%name)print('%s吃面'%name)noodle_lock.release()fork_lock.release()def eat2(name):fork_lock.acquire()print('%s拿到叉子了'%name)time.sleep(1)noodle_lock.acquire()print('%s拿到面条啦'%name)print('%s吃面'%name)noodle_lock.release()fork_lock.release()# 实例化2个锁，给面条和叉子加上锁
noodle_lock = Lock()
fork_lock = Lock()Thread(target=eat1,args=('peo1',)).start()
Thread(target=eat2,args=('peo2',)).start()
Thread(target=eat1,args=('peo3',)).start()
Thread(target=eat2,args=('peo4',)).start()
"""执行结果为：
peo1拿到面条了
peo1拿到叉子了
peo1吃面
peo2拿到叉子了
peo3拿到面条了
“陷入阻塞”…………
"""

多人吃面事例（使用互斥锁）:

# 加递归锁
from threading import Thread,RLock
import timedef eat1(name):noodle_lock.acquire()       # 一把钥匙print('%s拿到面条啦'%name)fork_lock.acquire()print('%s拿到叉子了'%name)print('%s吃面'%name)fork_lock.release()noodle_lock.release()def eat2(name):fork_lock.acquire()print('%s拿到叉子了'%name)time.sleep(1)noodle_lock.acquire()print('%s拿到面条啦'%name)print('%s吃面'%name)noodle_lock.release()fork_lock.release()fork_lock = noodle_lock  = RLock()Thread(target=eat1,args=('peo1',)).start()
Thread(target=eat2,args=('peo2',)).start()
Thread(target=eat1,args=('peo3',)).start()
Thread(target=eat2,args=('peo4',)).start()# 通过加递归锁实现了数据安全
# 递归锁一般用于有多个数据需要加锁的时候，不会出现数据安全问题

多人吃面事例（使用递归锁）

# 线程信号量
# 相当于加一个锁，但此锁可以根据自己需要设置有多个钥匙，此时可以允许有多个线程同时去做操作
from threading import Thread,Semaphore
import timedef func(sem,n):sem.acquire()time.sleep(0.5)print(n,end=' ')sem.release()sem = Semaphore(4)
for i in range(10):t = Thread(target=func,args=(sem,i))t.start()"""输出的结果为：
2 3 1 0 5 4 7 6 8 9     # (4个一组基本同时输出)
"""

# 事件被创建的时候
# False状态# wait() 阻塞
# True状态# wait() 非阻塞
# clear 设置状态为False
# set  设置状态为True

#  起两个线程
#  第一个线程 : 连接数据库# 等待一个信号 告诉我我们之间的网络是通的# 连接数据库
#  第二个线程 : 检测与数据库之间的网络是否连通# time.sleep(0,2) 2# 将事件的状态设置为True
from threading import Thread,Event
import time,randomdef connect_db(e):count = 0while count < 3:e.wait(0.5) # 状态为False的时候，只等待0.5秒就结束if e.is_set() == True:print('连接数据库')breakelse:count += 1print('第%s次连接失败' %count)else:raise TimeoutError('数据库连接超时')def check_web(e):time.sleep(random.randint(0, 3))e.set()e = Event()
t1 = Thread(target=connect_db, args=(e,))
t2 = Thread(target=check_web, args=(e,))
t1.start()
t2.start()

# notify(int数据类型)  造钥匙from threading import Thread
from threading import Condition
def func(con,i):con.acquire()con.wait() # 等钥匙print('在第%s个循环里'%i)con.release()
con = Condition()
for i in range(10):Thread(target=func,args = (con,i)).start()
while True:num = int(input('>>>'))con.acquire()con.notify(num)  # 造钥匙con.release()

定时器，即指定n秒后执行某操作import time
from threading import Timer
def func():print('时间同步')   #1-3while True:time.sleep(1)t = Timer(5,func).start()   # 非阻塞的# 定时等待5秒之后就调用func# time.sleep(5)

# 自动更新验证码
from threading import Thread,Timer
import randomclass Check_number:def __init__(self):self.cash_code() # 程序一开始便实例化一个验证码def make_code(self,n=4):res = ''for i in range(n):s1 = str(random.randint(0,9)) # 0到9间的任意自然数s2 = chr(random.randint(65,90)) # 24个小写字母res += random.choice([s1,s2]) # 字符和数字的任意组合return resdef cash_code(self,interval=3):self.code = self.make_code()  # 实例化一个验证码print(self.code) # 打印验证码self.t = Timer(interval,self.make_code) # 定时器，等待指定时间再运行
        self.t.start()def check(self):while True:mes = input('输入验证码>>>：').strip()if self.code == mes.upper():print('输入正确！')self.t.cancel() # 关闭定时器breakobj = Check_number()
obj.check()

自动更新验证码

import queue
q1 = queue.Queue()  # 队列 先进先出
q2 = queue.LifoQueue()  # 栈 先进后出
q3 = queue.PriorityQueue()  # 优先级队列

q.put()     # 往队列中放入值，当队列满的时候陷入等待状态，直到队列可以放入值的时候放值
q.get()     # 从队列取值，当队列为空的时候陷入等待状态，直到队列中有值的时候取值
q.put_nowait()  # 往队列中放入值，当队列满的时候，直接报错
q.get_nowait()  # 从队列取值，当队列为空的时候，直接报错

优先级队列事例：
q = queue.PriorityQueue()  # 优先级队列
q.put((20,'a'))
q.put((10,'b'))
q.put((-5,'d'))
q.put((1,'e'))
q.put((1,'f'))
print(q.get())
print(q.get())
print(q.get())
print(q.get())"""执行结果为：
(-5, 'd')
(1, 'e')
(1, 'f')
(10, 'b')
"""# 此队列按照值的优先级的顺序来取值，优先级数越小越先取值，
# 当优先级一样的时候，就比较值的ASCII值的大小，小的先取

import time
from concurrent.futures import ThreadPoolExecutor
def func(n):time.sleep(1)print(n,end=" ")return 2*ndef call_back(m):   # m接收的为func中return的值print('结果是 %s'%m.result())  # 从对象中获取值的方法.result(),进程池中是.get()

tpool = ThreadPoolExecutor(max_workers=5)   #  默认 不要超过cpu个数*5for i in  range(10):tpool.submit(func,i).add_done_callback(call_back)"""执行结果为：
4 结果是 8
2 结果是 4
3 结果是 6
1 结果是 2
0 结果是 0
9 结果是 18
8 结果是 16
6 结果是 12
5 结果是 10
7 结果是 14
"""# tpool.map(func,range(10))  # 拿不到返回值
t_lst = []
for i in  range(10):t = tpool.submit(func,i)t_lst.append(t)
tpool.shutdown()  # shutdown相当于close+join
print('主线程')
for t in t_lst:print('*',t.result(),end=' ')"""执行结果为：
4 2 3 1 0 9 8 7 6 5 主线程
* 0 * 2 * 4 * 6 * 8 * 10 * 12 * 14 * 16 * 18
"""

import socket
from threading import Threaddef chat(sk):conn, addr = sk.accept()conn.send("hello，我是服务端".encode('utf-8'))msg = conn.recv(1024).decode('utf-8')print(msg)conn.close()sk = socket.socket()
sk.bind(('127.0.0.1',8080))
sk.listen()
while True:t = Thread(target=chat,args=(sk,))t.start()
sk.close

server端

# client端
import socket
sk = socket.socket()
sk.connect(('127.0.0.1',8080))msg = sk.recv(1024).decode('utf-8')
print(msg)
info = input('>>>').encode('utf-8')
sk.send(info)
sk.close()

client端