线程

线程与进程

进程，资源单位，是资源分配的最小单位，可以同时运行多个任务

线程，执行单位，是CPU调度的最小单位，允许单个任务可以分成几部分运行

每一个进程中至少有一个线程，线程才是真正的执行单位，进程只是在线程运行过程中提供代码运行所需要的资源。

线程是能独立运行的基本单位，也是独立调度和分派的基本单位。由于线程很'轻'，故线程的切换非常迅速且开销小（在同一进程中的）

同一进程中的线程：

1. 可共享进程资源
2. 可并发执行

为什么要有线程？

​ 开进程：

​ 1、申请内存空间 耗资源

​ 2、’拷贝代码‘ 耗资源

​ 开线程：

​ 一个进程里面可以起多个线程，并且线程共享进程内的资源

开启线程的开销远远低于开启进程的开销

线程创建的两种方式

1、实例化Thread

from threading import Thread
import time

def task(name):
    print('{} is running'.format(name))
    time.sleep(2)
    print('{} is over'.format(name))

t = Thread(target=task, args=(('egon',)))
t.start() # 告诉操作系统去开辟一个线程，线程的开销远小于进程
print('主')

2、继承Thread

from threading import Thread
import time

class MyThread(Thread):
    def __init__(self, name):
        super().__init__()
        self.name = name

    def run(self):
        print('{} is running'.format(self.name))
        time.sleep(2)
        print('{} is over'.format(self.name))

t = MyThread('egon')
t.start()
print('主')

线程对象及方法：

from threading import Thread, current_thread, active_count
import time

def task(name, i):
    time.sleep(i)
    print('{} is running'.format(name))
    print(current_thread().name)  # Thread-1
    print('11111111')

t = Thread(target=task, args=(('egon', 1)))
t2 = Thread(target=task, args=(('tank', 2)))
t.start()
t2.start()
# t.join()

print(current_thread().name)  # MainThread  
print(active_count()) # 3
print('主')

threading.current_thread()：当前线程

threading.active_count()：活跃线程数量

thread.join()：主线程等待子线程结束

守护线程

thread.daemon()

只有当非守护线程的线程全部结束时，主线程才会结束。

主线程结束意味着进程结束，意味着线程共享的资源销毁。

守护线程在主线程结束之后则不会运行。

from threading import Thread
import time, random

def task(name, i=0.2):
    print(name)
    time.sleep(i)
    print('{} is running'.format(name))


t = Thread(target=task, args=(('egon',0.1)))
t2 = Thread(target=task, args=(('egon1',)))
t3 = Thread(target=task, args=(('egon2',)))
t4 = Thread(target=task, args=(('egon3',)))

t.daemon = True
t.start()
t2.start()
t3.start()
t4.start()

daemon小例子：

from threading import Thread
import time
def foo():
    print(123)
    time.sleep(1)
    print("end123")

def bar():
    print(456)
    time.sleep(3)
    print("end456")

if __name__ == '__main__':
    t1=Thread(target=foo)
    t2=Thread(target=bar)
    t2.daemon=True
    t1.start()
    t2.start()
    print("main-------")

互斥锁

acquire()：抢锁

release()：释放锁