python 多线程

线程是进程中执行代码的一个分支，每个执行分支（线程）要想工作执行代码需要cpu进行调度 ，也就是说线程是cpu调度的基本单位，每个进程至少都有一个线程，而这个线程就是我们通常说的主线程。
1.进程之间不共享全局变量
2.线程之间共享全局变量，但是要注意资源竞争的问题，解决办法: 互斥锁或者线程同步
3.创建进程的资源开销要比创建线程的资源开销要大
4.进程是操作系统资源分配的基本单位，线程是CPU调度的基本单位
5.线程不能够独立执行，必须依存在进程中
6.多进程开发比单进程多线程开发稳定性要强
进程优缺点:
优点：可以用多核
缺点：资源开销大
线程优缺点:
优点：资源开销小
缺点：不能使用多核
小结
进程和线程都是完成多任务的一种方式
多进程要比多线程消耗的资源多，但是多进程开发比单进程多线程开发稳定性要强，某个进程挂掉不会影响其它进程。
多进程可以使用cpu的多核运行，多线程可以共享全局变量。
线程不能单独执行必须依附在进程里面

python多线程threading https://blog.csdn.net/zhujuntangxiaojuan/article/details/118027810

复制代码
"""
Thread([group [, target [, name [, args [, kwargs]]]]])

group: 线程组，目前只能使用None
target: 执行的目标任务名
args: 以元组的方式给执行任务传参
kwargs: 以字典方式给执行任务传参
name: 线程名，一般不用设置
"""
import threading
import time


def sing():
    for i in range(5):
        print("唱歌中", i)
        time.sleep(1)


def dance():
    for i in range(5):
        print("跳舞中", i)
        time.sleep(1)


if __name__ == '__main__':
    # 创建线程 target： 线程执行的函数名
    sing_thread = threading.Thread(target=sing)
    dance_thread = threading.Thread(target=dance)

    # 开启线程
    sing_thread.start()
    dance_thread.start()
View Code
复制代码

python使用threading实现最简单的多任务（多线程一） https://blog.csdn.net/zhujuntangxiaojuan/article/details/99175381

复制代码
import time
import threading
 
 
def sing():
    """唱歌五秒"""
    for i in range(5):
        print("-----正在唱歌：东风破----")
        time.sleep(1)
 
 
def dance():
    """跳舞五秒"""
    for i in range(5):
        print("-----正在跳舞-----")
        time.sleep(1)
 
 
def main():
    """用threading实现多任务"""
    t1 = threading.Thread(target=sing)  # 注意这里的函数是没有括号的
    t2 = threading.Thread(target=dance)
    t1.start()
    t2.start()
 
 
if __name__ == '__main__':
    main()
View Code
复制代码

python threading.enumerate()查看线程数量（多线程二） https://blog.csdn.net/zhujuntangxiaojuan/article/details/99182036

复制代码
"""
# 拆包enumerate返回值是一个元组
names = ["aa", "bb", "cc"]
for i, name in enumerate(names):
    print(i, name)
"""
import threading
import time
 
 
def test1():
    for i in range(5):
        print("-----test1-----%s" % i)
        time.sleep(1)
    # 如果创建Thread时执行的函数，函数运行结束意味着 这个子线程结束...
 
 
def test2():
    for i in range(5):
        print("-----test2-----%s" % i)
        time.sleep(1)
 
 
def main():
    # 在调用thread之前打印当前线程信息
    print(threading.enumerate())
    # 创建线程
    t1 = threading.Thread(target=test1)
    t2 = threading.Thread(target=test2)
 
    t1.start()
    t2.start()
 
    # 查看线程数量
    while True:
        thread_num = len(threading.enumerate())
        print("线程数量是%d" % thread_num)
        if thread_num <= 1:
            break
        time.sleep(1)
 
 
if __name__ == '__main__':
    main()
View Code
复制代码

 python Thread 多线程共享全局变量会出现资源竞争(多线程三) https://blog.csdn.net/zhujuntangxiaojuan/article/details/99681936

复制代码
# 多线程共享全局变量会出现资源竞争
import threading
import time
g_num = 0
 
 
def test1(num):
    global g_num
    for i in range(num):
        g_num += 1
    print("-----test1-----g_num=%d" % g_num)
    # 如果创建Thread时执行的函数，函数运行结束意味着 这个子线程结束...
 
 
def test2(num):
    global g_num
    for i in range(num):
        g_num += 1
    print("-----test2-----g_num=%d" % g_num)
 
 
def main():
    # 在调用thread之前打印当前线程信息
    print(threading.enumerate())
    # 创建线程
    t1 = threading.Thread(target=test1, args=(1000000,))
    t2 = threading.Thread(target=test2, args=(1000000,))
 
    t1.start()
    t2.start()
 
    # 等待上面两个线程结束
    time.sleep(5)
 
    print("-----in main Thread g_num=%d" % g_num)
 
 
if __name__ == '__main__':
    main()
View Code
复制代码

python threading.Lock() 互斥锁解决资源竞争问题（多线程四）https://blog.csdn.net/zhujuntangxiaojuan/article/details/99682371

复制代码
# 多线程共享全局变量会出现资源竞争
# 互斥锁解决资源竞争
"""
threading模块中定义了Lock类，可以方便的处理锁定：
 
# 创建锁
mutex = threading.Lock()
 
# 锁定
mutex.acquire()
 
# 释放
mutex.release()
"""
import threading
import time
g_num = 0
 
# 创建一个互斥锁，默认是没有上锁的
mutex = threading.Lock()
 
 
def test1(num):
    global g_num
    # 上锁，如果之前没有被上锁，那么此时上锁成功
    # 如果上锁之前 已经被锁上了，那么此时会阻塞在这里，知道这个锁被解开
    mutex.acquire()
    for i in range(num):
        g_num += 1
    # 解锁
    mutex.release()
    print("-----test1-----g_num=%d" % g_num)
 
 
def test2(num):
    global g_num
    # 上锁
    mutex.acquire()
    for i in range(num):
        g_num += 1
    # 解锁
    mutex.release()
    print("-----test2-----g_num=%d" % g_num)
 
 
def main():
    # 在调用thread之前打印当前线程信息
    print(threading.enumerate())
    # 创建线程
    t1 = threading.Thread(target=test1, args=(1000000,))
    t2 = threading.Thread(target=test2, args=(1000000,))
 
    t1.start()
    t2.start()
 
    # 等待上面两个线程结束
    time.sleep(2)
 
    print("-----in main Thread g_num=%d" % g_num)
 
 
if __name__ == '__main__':
    main()
View Code
复制代码

python threading socket 多线程版udp聊天器（多线程五）https://blog.csdn.net/zhujuntangxiaojuan/article/details/99683544

复制代码
import socket
import threading
 
 
def recv_msg(udp_socket):
    """接收数据并显示"""
    # 接收数据
    while True:
        recv_data = udp_socket.recvfrom(1024)
        # 解析出收到的数据
        # recv_data这个变量接收的是一个元组（接收到的数据（发送方ip, port））
        recv_msg = recv_data[0]  # 存储接收到的数据
        send_addr = recv_data[1]  # 存储发送方ip和端口
 
        # 3.打印接收到的数据
        print("收到的信息是:%s \n收到的地址:%s" % (recv_msg.decode("gbk"), str(send_addr)))
 
 
def send_msg(udp_socket, dest_ip, dest_port):
    """发送数据"""
    # 发送数据
    while True:
        send_data = input("请输入要发送的数据：")
        udp_socket.sendto(send_data.encode("gbk"), (dest_ip, dest_port))
 
 
def main():
    """完成udp聊天器的整体控制"""
    # 1.创建套接字
    udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    
    # 2.绑定本地信息
    udp_socket.bind(("", 7788))
 
    # 3.获取对方ip
    dest_ip = input("请输入对方ip:")
    dest_port = int(input("请输入对方端口："))
 
    # 4.创建2个线程，去执行相应的功能
    t_recv = threading.Thread(target=recv_msg, args=(udp_socket,))
    t_send = threading.Thread(target=send_msg, args=(udp_socket, dest_ip, dest_port))
 
    t_recv.start()
    t_send.start()
    
 
if __name__ == '__main__':
    main()
View Code
复制代码

python 使用gevent实现协程（多线程六）https://blog.csdn.net/zhujuntangxiaojuan/article/details/99708681

复制代码
from gevent import monkey
import gevent
import time

# 有耗时操作时需要
# 将程序中用到的耗时操作的代码，换为gevent中自己实现的模块
monkey.patch_all()


def f1(n):
    for i in range(n):
        print(gevent.getcurrent(), i)
        # gevent.sleep(0.5)
        time.sleep(0.5)


def f2(n):
    for i in range(n):
        print(gevent.getcurrent(), i)
        # gevent.sleep(0.5)
        time.sleep(0.5)


def f3(n):
    for i in range(n):
        print(gevent.getcurrent(), i)
        # gevent.sleep(0.5)
        time.sleep(0.5)


# g1 = gevent.spawn(f1, 5)
# g2 = gevent.spawn(f2, 5)
# g3 = gevent.spawn(f3, 5)
# g1.join()
# g2.join()
# g3.join()

gevent.joinall([
    gevent.spawn(f1, 5),
    gevent.spawn(f2, 5),
    gevent.spawn(f3, 5)
])
View Code
复制代码

 

posted @   simadi  阅读(53)  评论(0)  编辑  收藏  举报
相关博文：
· Python ui程序开发 pyside 资料
· 第 11 节 Python程序调试和异常处理技巧
· Python threading实现多线程 基础篇
· python-thread多线程通俗理解
· python多线程与多进程
阅读排行：
· 分享4款.NET开源、免费、实用的商城系统
· 全程不用写代码，我用AI程序员写了一个飞机大战
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· 白话解读 Dapr 1.15：你的「微服务管家」又秀新绝活了
· 上周热点回顾（2.24-3.2）
历史上的今天：
2021-10-19 Snmp get获取oid值返回No-Such-Instance
2017-10-19 react-native 相关问题
2015-10-19 Shuttle ESB 实践
点击右上角即可分享
微信分享提示