目录
import threading
import urllib.request
# 访问网站
def get_web(url): # 访问网站
user_agent = '在从自己的浏览器里找'
headers = {
"User-Agent": user_agent
}
# 构造Request对象，以便我们设置http请求中的header信息
req = urllib.request.Request(url, headers=headers)
resp = urllib.request.urlopen(req)
print(resp.read().decode()[:50])
if __name__ == '__main__':
t1=threading.Thread(target=get_web,args=('https://www.baidu.com/',)) # target是需要做的事情，利用args传参（元组形式）
t2=threading.Thread(target=get_web,args=('https://www.sohu.com/',))
t1.start() # 启动线程，就会执行target的内容
t2.start()
t1.join() # 等待子线程结束后，才执行主线程
t2.join()
print("程序运行结束！") # 主线程的代码
import threading
import urllib.request
# 新的线程类
class MyThread(threading.Thread): # 继承Thread
def __init__(self,name,url):
super().__init__() # 调用父类的初始化方法
self.name=name # 线程的名字
self.url=url
# 启动线程后，run会被自动调用
def run(self): # 重写父类的run方法，定义在新的线程类里面要完成的任务
print(f"我是{self.name}")
user_agent = '在从自己的浏览器里找'
headers = {
"User-Agent": user_agent
}
# 构造Request对象，以便我们设置http请求中的header信息
req = urllib.request.Request(self.url, headers=headers)
resp = urllib.request.urlopen(req)
print(resp.read().decode()[:50])
if __name__ == '__main__':
t1=MyThread("线程1","https://www.baidu.com/")
t2=MyThread("线程2","https://www.sohu.com/")
t1.start() # 启动线程
t2.start()
t1.join() # 等待子线程结束后，才执行主线程
t2.join()
print("程序运行结束！") # 主线程的代码
import threading
num=0
lock=threading.Lock() # 创建锁
def deposit():
for i in range(1000000):
lock.acquire() # 获取锁
global num
num+=1
lock.release() # 释放锁
def withdraw():
for i in range(1000000):
with lock: # 自动获取锁和释放锁
global num
num-=1
if __name__ == '__main__':
t1=threading.Thread(target=deposit)
t2=threading.Thread(target=withdraw)
t1.start()
t2.start()
t1.join()
t2.join()
print(num)from queue import Queue
q =Queue(maxsize=0) # 初始化，maxsize=0表示队列的消息个数不受限制；maxsize>0表示存放限制
q.get() # 提取消息，如果队列为空会阻塞程序，等待队列消息
q.get(timeout=1) # 阻塞程序，设置超时时间
q.put() # 发送消息，将消息放入队列from queue import Queue
import threading
import time
def product(q): # 生产者
kind = ('猪肉','白菜','豆沙')
for i in range(3):
print(threading.current_thread().name,"生产者开始生产包子")
time.sleep(1)
q.put(kind[i%3]) # 放入包子
print(threading.current_thread().name,"生产者的包子做完了")
def consumer(q): # 消费者
while True:
print(threading.current_thread().name,"消费者准备吃包子")
time.sleep(1)
t=q.get() # 拿出包子
print("消费者吃了一个{}包子".format(t))
if __name__=='__main__':
q=Queue(maxsize=1)
# 启动两个生产者线程
threading.Thread(target=product,args=(q, )).start()
threading.Thread(target=product,args=(q, )).start()
# 启动一个消费者线程
threading.Thread(target=consumer,args=(q, )).start()
import multiprocessing # 引入多进程模块
import urllib.request
# 访问网站
def get_web(url): # 访问网站
user_agent = '在自己的浏览器里找'
headers = {
"User-Agent": user_agent
}
# 构造Request对象，以便我们设置http请求中的header信息
req = urllib.request.Request(url, headers=headers)
resp = urllib.request.urlopen(req)
print(resp.read().decode()[:50])
if __name__ == '__main__':
p1=multiprocessing.Process(target=get_web,args=('https://www.baidu.com/',))
p2=multiprocessing.Process(target=get_web,args=('https://www.sohu.com/',))
p1.start() # 启动进程
p2.start()
p1.join() # 等待子进程结束后，才执行主进程
p2.join()
print("进程操作全部执行完毕！") # 主进程的代码
import multiprocessing
import urllib.request
import os # 拿到进程id
# 新的进程类
class MyProcess(multiprocessing.Process): # 继承Process
def __init__(self,name,url):
super().__init__() # 调用父类的初始化方法
self.name=name # 进程的名字
self.url=url
# 启动进程后，run会被自动调用
def run(self): # 重写父类的run方法，定义在新的进程类里面要完成的任务
print(f"我是{self.name}","当前进程ID为：",os.getpid(),"我的父进程ID为：",os.getppid())
user_agent = '在自己的浏览器里找'
headers = {
"User-Agent": user_agent
}
# 构造Request对象，以便我们设置http请求中的header信息
req = urllib.request.Request(self.url, headers=headers)
resp = urllib.request.urlopen(req)
print(resp.read().decode()[:50])
if __name__ == '__main__':
print("当前主进程的ID为：",os.getpid())
p1=MyProcess("子进程1","https://www.baidu.com/")
p2=MyProcess("子进程2","https://www.sohu.com/")
p1.start() # 启动进程
p2.start()
p1.join() # 等待子进程结束后，才执行主进程
p2.join()
print("进程操作全部执行完毕！") # 主进程的代码
import multiprocessing
import time
def product(q): # 生产者
kind = ('猪肉','白菜','豆沙')
for i in range(3):
print(multiprocessing.current_process().name,"生产者开始生产包子")
time.sleep(1)
q.put(kind[i%3]) # 放入包子
print(multiprocessing.current_process().name,"生产者的包子做完了")
def consumer(q): # 消费者
while True:
print(multiprocessing.current_process().name,"消费者准备吃包子")
time.sleep(1)
t=q.get() # 拿出包子
print("消费者吃了一个{}包子".format(t))
if __name__=='__main__':
q=multiprocessing.Queue(maxsize=1) # 创建多进程队列对象
# 启动两个生产者进程
p1=multiprocessing.Process(target=product,args=(q,))
p2=multiprocessing.Process(target=product,args=(q,))
p1.start()
p2.start()
# 启动一个消费者进程
p3=multiprocessing.Process(target=consumer,args=(q,))
p3.start()