多线程编程
（1）什么是线程?
线程（英语：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。
每个进程至少有一个线程，即进程本身。进程可以启动多个线程。操作系统像并行“进程”一样执行这些线程。
（2）线程和进程各自有什么区别和优劣呢？
1.进程是资源分配的最小单位，线程是程序执行的最小单位。
2.进程有自己的独立地址空间。线程是共享进程中的数据的，使用相同的地址空间.
3.进程之间的通信需要以通信的方式（IPC)进行。线程之间的通信更方便，同一进程下的线程共享全局变量、静态变量等数据，难点:处理好同步与互斥。
（3）线程分类
有两种不同的线程：1 内核线程
2 用户空间线程或用户线程
内核线程是操作系统的一部分，而内核中没有实现用户空间线程。
多线程编程方法一:实例化对象
python的thread模块是⽐较底层的模块，python的threading 模块是对thread做了⼀些包装的，可以更加⽅便的被使⽤
import time
import threading
def task():
"""当前要执行的任务"""
print("听音乐........")
time.sleep(1)
if __name__ == '__main__':
start_time = time.time()
threads = []
for count in range(5):
t = threading.Thread(target=task)
# 让线程开始执行任务
t.start()
threads.append(t)
# 等待所有的子线程执行结束， 再执行主线程;
[thread.join() for thread in threads]
end_time = time.time()
print(end_time-start_time)
运行结果如下：
多线程程序的执⾏顺序是不确定的。 当执⾏到sleep语句时，线程将被阻塞（Blocked），到sleep结束后，线程进⼊就绪（Runnable）状态，等待调度。⽽线程调度将⾃⾏选择⼀个线程执⾏。 代码中只能保证每个线程都运⾏完整个run函数，但是线程的启动顺序、 run函数中每次循环的执⾏顺序都不能确定。
线程的⼏种状态
项目案例: IP地址归属地批量查询任务
运行代码如下：
import requests
import json
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from threading import Thread
def task(ip):
"""获取指定IP的所在城市和国家并存储到数据库中"""
# 获取网址的返回内容
url = 'http://ip-api.com/json/%s' % (ip)
try:
response = requests.get(url)
except Exception as e:
print("网页获取错误:", e)
else:
# 默认返回的是字符串
"""
{"as":"AS174 Cogent Communications","city":"Beijing","country":"China","countryCode":"CN","isp":"China Unicom Shandong Province network","lat":39.9042,"lon":116.407,"org":"NanJing XinFeng Information Technologies, Inc.","query":"114.114.114.114","region":"BJ","regionName":"Beijing","status":"success","timezone":"Asia/Shanghai","zip":""}
"""
contentPage = response.text
# 将页面的json字符串转换成便于处理的字典;
data_dict = json.loads(contentPage)
# 获取对应的城市和国家
city = data_dict.get('city', 'null') # None
country = data_dict.get('country', 'null')
print(ip, city, country)
# 存储到数据库表中ips
ipObj = IP(ip=ip, city=city, country=country)
session.add(ipObj)
session.commit()
if __name__ == '__main__':
engine = create_engine("mysql+pymysql://root:westos@172.25.254.123/pymysql",
encoding='utf8',
# echo=True
)
# 创建缓存对象
Session = sessionmaker(bind=engine)
session = Session()
# 声明基类
Base = declarative_base()
class IP(Base):
__tablename__ = 'ips'
id = Column(Integer, primary_key=True, autoincrement=True)
ip = Column(String(20), nullable=False)
city = Column(String(30))
country = Column(String(30))
def __repr__(self):
return self.ip
# 创建数据表
Base.metadata.create_all(engine)
# 1.1.1.1 -- 1.1.1.10
threads = []
for item in range(10):
ip = '1.1.1.' + str(item + 1) # 1.1.1.1 -1.1.1.10
# task(ip)
# 多线程执行任务
thread = Thread(target=task, args=(ip,))
# 启动线程并执行任务
thread.start()
# 存储创建的所有线程对象;
threads.append(thread)
[thread.join() for thread in threads]
print("任务执行结束.........")
print(session.query(IP).all())多线程编程方法二
项目案例: 基于多线程的批量主机存活探测
项目描述: 如果要在本地网络中确定哪些地址处于活动状态或哪些计算机处于活动状态，则可以使用此脚本。我们将依次ping地址, 每次都要等几秒钟才能返回值。这可以在Python中编程，在IP地址的地址范围内有一个for循环和一个os.popen（“ping -q -c2”+ ip）。
运行代码如下：
"""
创建子类
"""
from threading import Thread
class GetHostAliveThread(Thread):
"""
创建子线程， 执行的任务：判断指定的IP是否存活
"""
def __init__(self, ip):
super(GetHostAliveThread, self).__init__()
self.ip = ip
def run(self):
# # 重写run方法: 判断指定的IP是否存活
# """
# >>> # os.system() 返回值如果为0， 代表命令正确执行，没有报错; 如果不为0， 执行报错;
# ...
# >>> os.system('ping -c1 -w1 172.25.254.49 &> /dev/null')
# 0
# >>> os.system('ping -c1 -w1 172.25.254.1 &> /dev/null')
# 256
# """
import os
# 需要执行的shell命令
cmd = 'ping -c1 -w1 %s &> /dev/null' %(self.ip)
result = os.system(cmd)
# 返回值如果为0， 代表命令正确执行，没有报错; 如果不为0， 执行报错;
if result != 0:
print("%s主机没有ping通" %(self.ip))
if __name__ == '__main__':
print("打印172.25.254.0网段没有使用的IP地址".center(50, '*'))
for i in range(1, 255):
ip = '172.25.254.' + str(i)
thread = GetHostAliveThread(ip)
thread.start()运行结果如下：
共享全局变量
优点: 在⼀个进程内的所有线程共享全局变量，能够在不使⽤其他⽅式的前提 下完成多线程之间的数据共享（这点要⽐多进程要好）
缺点: 线程是对全局变量随意遂改可能造成多线程之间对全局变量 的混乱（即线程⾮安全）
共享全局变量：如何解决线程不安全问题?
GIL(global interpreter lock): python解释器中任意时刻都只有一个线程在执行;
Python代码的执行由Python 虚拟机(也叫解释器主循环，CPython版本)来控制，Python 在设计之初就考虑到要在解释器的主循环中，同时只有一个线程在执行，即在任意时刻，只有一个线程在解释器中运行。对Python 虚拟机的访问由全局解释器锁（GIL）来控制，正是这个锁能保证同一时刻只有一个线程在运行。
线程同步
线程同步：即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作， 其他线程才能对该内存地址进行操作.
同步就是协同步调，按预定的先后次序进⾏运⾏。如:你说完，我再说。
"同"字从字⾯上容易理解为⼀起动作 其实不是，
"同"字应是指协同、协助、互相配合。
如果要实现线程同步，那么就要用到线程锁
线程同步运行代码如下：
money = 0
def add():
for i in range(1000000):
global money
lock.acquire()
money += 1
lock.release()
def reduce():
for i in range(1000000):
global money
lock.acquire()
money -= 1
lock.release()
if __name__ == '__main__':
from threading import Thread, Lock
# 创建线程锁
lock = Lock()
t1 = Thread(target=add)
t2 = Thread(target=reduce)
t1.start()
t2.start()
t1.join()
t2.join()
print(money)运行结果如下：
死锁
在线程间共享多个资源的时候，如果两个线程分别占有⼀部分资源并且同时 等待对⽅的资源，就会造成死锁。
死锁问题运行代码如下：
"""
在线程间共享多个资源的时候，如果两个线程分别占有⼀部分资源并且同时 等待对⽅的资源，就会造成死锁。
"""
import time
import threading
class Account(object):
def __init__(self, id, money, lock):
self.id = id
self.money = money
self.lock = lock
def reduce(self, money):
self.money -= money
def add(self, money):
self.money += money
def transfer(_from, to, money):
if _from.lock.acquire():
_from.reduce(money)
time.sleep(1)
if to.lock.acquire():
to.add(money)
to.lock.release()
_from.lock.release()
if __name__ == '__main__':
a = Account('a', 1000, threading.Lock()) # 900
b = Account('b', 1000, threading.Lock()) # 1100
t1 = threading.Thread(target=transfer, args=(a, b, 200))
t2 = threading.Thread(target=transfer, args=(b, a, 100))
t1.start()
t2.start()
print(a.money)
print(b.money)代码运行结果如下：
800
900
1317
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
