# 每个程序默认都有一个线程，这个线程叫主线程；其他线程都是子线程
import time
from datetime import datetime
import threading # 专门提供和线程相关的操作
def download(file_name):
print('开始下载：%s' % file_name, datetime.now())
time.sleep(3)
print('%s 下载完成！' % file_name, datetime.now())
# 1.单线程下载两个电影
# 在一个线程中下载连个电影：时间是连个电影下载的总和
"""
download('村口的二狗子')
print('+++++++++++++++++')
download('招魂1')
"""
# 2.多线程模块
# 1.current_thread() - 获取当前线程
# print(threading.current_thread())
# 2.Thread类
"""
Thread类的对象就是线程，所以需要子线程就创建这个类的对象
Thread(target,args,kwargs)
target - 函数，需要在当前创建的子线程中去调用的函数
args/kwargs - 调用target中的函数需要的实际参数
"""
# a.创建线程对象
t1 = threading.Thread(target=download, args=('村口的二狗子',))
t2 = threading.Thread(target=download, args=('招魂1',))
# b.开始执行子线程中的任务：线程对象.start()
# 通过start()方法，在子线程中去调用target对应的函数
t1.start()
t2.start()
from threading import *
import time
from datetime import datetime
# 1.创建自己的线程类
"""
a. 声明一个类继承Thread
b. 实现run方法，这个方法的任务就是需要在子线程中执行的任务
注意：一个进程如果有多个线程，程序会在所有额线程都结束的时候才结束
发生异常崩溃其实崩溃的是线程
"""
class DownloadThread(Thread):
def __init__(self, file_name):
super().__init__()
self.file_name = file_name
def run(self):
# print(current_thread())
# print('在子线程中执行的代码')
print('开始下载：%s' % self.file_name, datetime.now())
time.sleep(5)
print('%s 下载完成！' % self.file_name, datetime.now())
# 3.用子类直接创建线程对象
t1 = DownloadThread('村口的二狗子')
t2 = DownloadThread('村口的小奶猫')
# 4.通过start 去执行子线程中的任务
t1.start()
t2.start()
# t1.run() # 不能直接调用run方法，因为这样调用不会再子线程中执行
from socket import *
from threading import *
class Chat(Thread):
def __init__(self, connect, address):
super().__init__()
self.connect = connect
self.address = address
def run(self):
while True:
connect.send('你好，我是管理员'.encode())
massage = connect.recv(102400)
print('%s:%s' % (address[0], massage.decode()))
connect.close()
server = socket()
server.bind(('10.7.185.77', 8080))
server.listen(512)
while True:
connect, address = server.accept()
t = Chat(connect, address)
t.start()
from socket import socket
client = socket()
client.connect(('10.7.185.77', 8080))
while True:
massage = client.recv(1024)
print(massage.decode(encoding='utf-8'))
send_massage = input('>>>')
client.send(send_massage.encode())
from threading import Thread
import time
class DownLoad(Thread):
def __init__(self, name, time):
super().__init__()
self.name = name
self.time = time
def run(self):
print('开始下载：%s' % self.name)
time.sleep(self.time)
print('下载结束：%s' % self.name)
t1 = DownLoad('电锯惊魂', 5)
t2 = DownLoad('粉红色高跟鞋', 7)
t1.start()
t2.start()
# 1.join
# 希望某个任务是在某个线程结束后才执行，那就将这个任务放在对应线程对象调用join方法的后面
t1.join()
t2.join()
print('下载完成')
print('================================')
t3 = DownLoad('女高怪谈', 5)
t4 = DownLoad('笔仙', 7)
t3.start()
t3.join()
t4.start()
import time
from threading import Thread, Lock
"""
锁的使用：
1.问题：当多个线程同时对一个数据进行读写操作，可能会出现一个线程刚把数据读出来
还没来得及把数据写进去，另外一个线程进行读操作而出现的数据安全问题
2.解决 - 加锁
a. 保证每个数据对应一个锁对象
b. 操作数据前加锁，数据操作完成后释放锁
"""
class Account:
def __init__(self, name, tel, banlance=50):
self.name = name
self.tel = tel
self.banlance = banlance
# 关联一个锁对象
self.lock = Lock()
def save_money(self, money):
print('开始存钱')
# 加锁
self.lock.acquire()
value = self.banlance
time.sleep(3)
self.banlance = value + money
print('存钱成功! 当前余额为：%.2f' % self.banlance)
# 释放锁
self.lock.release()
def draw_money(self, money):
print('开始取钱')
# 加锁
self.lock.acquire()
value = self.banlance
time.sleep(4)
if value < money:
print('取钱失败余额不足')
return
self.banlance = value - money
print('取钱成功! 剩下余额为：%.2f' % self.banlance)
# 释放锁
self.lock.release()
account1 = Account('张三', '18200482453', 10000)
t1 = Thread(target=account1.save_money, args=(10000,))
t2 = Thread(target=account1.draw_money, args=(2000,))
t1.start()
t2.start()
