1.多线程
import threading
import datetime
import time
def download(file):
print('开始下载：'+file, datetime.datetime.now())
time.sleep(10)
print(file+'下载结束', datetime.datetime.now())
if __name__ == '__main__':
print('主线程中的代码')
print(threading.currentThread())
# download('终结者2')
# download('沉默的羔羊')
print('==============')
#2.在两个子线程中去下载两个电影
"""
Thread(target,args)
target:需要在子线程中调用的函数的函数名
args：函数的实参
返回值：创建好的线程对象
download以外的代码全在主线程执行
"""
t1 = threading.Thread(target=download, args=('终结者2', ))
# 开始执行t1对应的线程中的任务
t1.start()
t2 = threading.Thread(target=download, args=('沉默的羔羊',))
t2.start()
# 想要在子线程中执行任务，必须通过线程对象调用start方法才行
print('=======')
2.面向对象的多线程技术
from threading import Thread
import datetime
import time
from random import randint
面向对象实现多线程技术
1.声明一个类继承自Thread类
2.将需要在子线程中执行的任务放在run方法中
3.在需要子线程的位置去创建这个类的对象，然后用对象调用start方法去执行run中的任务
class DownloadThread(Thread):
def __init__(self, file):
super().__init__()
self.file = file
def run(self):
print(self.file+'开始下载：', datetime.datetime.now())
time.sleep(randint(5, 10))
print(self.file+'下载结束:', datetime.datetime.now())
if __name__ == '__main__':
print('=======')
t1 = DownloadThread('苍老师')
t1.start()
3.join方法使用
from threading import Thread
from datetime import datetime
import time
from random import randint
# 在两个子线程中下载两个电影，去主线程中去统计两个电影下载的总时间
# 如果希望某个线程结束后才执行某个操作，就用那个线程调用join方法
class DownloadThread(Thread):
def __init__(self, file):
super().__init__()
self.file = file
def run(self):
print(self.file+'开始下载',datetime.now())
time.sleep(randint(5, 15))
print(self.file+'下载结束',datetime.now())
if __name__ == '__main__':
start = time.time
t1 = DownloadThread('美丽人生')
t2 = DownloadThread('肖恩克的救赎')
tim1 = t1.start()
tim2 = t2.start()
# 系统t1和t2中的代码都结束才执行下面的代码
t1.join() # 这句代码后面的代码在t1对应的线程结束后才执行
t2.join()
end = time.time()
4.线程间的数据共享
from threading import Thread,Lock
import time
class Account:
"""账号类"""
def __init__(self, balance):
"""余额"""
self.balance = balance
# 创建锁对象
self.lock = Lock()
def save_money(self, amount):
# 存钱过程：读出原来余额，确定钱的操作
self.lock.acquire() # 加锁
old_amount = self.balance # 获取原来的余额
time.sleep(5)
# 存钱
self.balance = old_amount + amount
print('当前余额为：', self.balance)
self.lock.release() # 减锁
def get_money(self, amount): #取钱
old_amount = self.balance
if old_amount < amount:
print('余额不足!')
return
time.sleep(5)
self.balance = old_amount - amount
print('当前余额为：', self.balance)
def show_balance(self):
print('当前余额为：', self.balance)
if __name__ == '__main__':
account = Account(1000)
# account.save_money(200)
# account.get_money(100)
# 当多个线程同时对一个数据进行操作的时候，可能会出现数据混乱的问题
t1 = Thread(target=account.save_money, args=(200,))
t2 = Thread(target=account.save_money, args=(300,))
t1.start()
t2.start()
str4 = 'good good study,day day up'
print(str4[3::-1])
print(str4[::-1])
5.内存管理机制
掌握：1.数字，字符串（简单的字符串），布尔值的缓存
2.垃圾回收中的引用计数机制
python中所有的数据都是对象，所有的变量都是对象的引用
python对数字、字符串和布尔对象进行了缓存。让不同的变量赋同样值的
这些对象的时候，给的地址是缓存的对象的地址。
总结：1.给一个变量赋值的时候，赋的是数字、字符串、布尔的时候，会先看缓存区是否有这个值
如果有直接将值对应地址赋给变量。没有就在缓存中开辟空间存储数据，然后返回地址、
2.给一个变量赋值的时候，赋的是除了数字、字符串、布尔以外的值，就直接在内存中开辟空间存储数据，然后返回地址
一个变量存了一个对象的地址，那么这个变量就是这个对象的引用
2.python中的内存管理：
c的内存管理机制：手动
java\oc\python等：拥有一套属于自己的内存管理机制
a.python通过垃圾回收机制来对内存进行管理的。不定时对程序中的对象进行检测，查看是否需要回收
将对应的内存释放。看是否需要回收就看对象引用计数是否为0。
b.引用计数：
python中的每个对象在创建的时候就会有一个属性叫引用计数，其对应的值是0
当对象被引用一次，其引用计数就会加1.当对象的引用减少一个，其引用计数就会减1
3.垃圾回收机制
垃圾回收机制并不是一旦产生引用计数为0的对象就马上回收。而是不定时的对整个程序中
所有的对象进行检测，检测的时候引用计数为0才回收。
当当前程序所有的对象引用计数变化的次数达到它的阈值的时候，才会
对对象尽心检测。
4.循环引用（python中的垃圾回收能够自动解决因为循环引用二导致的内存泄漏问题）
检测的时候如果对象（object_i）的引用计数不是0，就备份引用计数值(count_i)，去找到引用这个当前对象的对象，然后将
object_j的引用计数count_j-1,如果count_j-1后的值是0，那么count_i的值就-1.如果减完后count_j的值是0，那么count_i的值就见1.
"""
from sys import getrefcount
if __name__ == '__main__':
object1 = [1, 2]
# 注意：getrefcount函数本身会对查看的对象进行一次引用
print(getrefcount(object1))
