线程第一讲

什么是线程，以及和进程的区别

进程是资源分配的最小单位，线程是cpu调度的最小单位，每个进程中至少有一个线程
进程利用了多核优势，线程没用利用多核优势
线程是包含在进程里面，是正直干活的，而进程只是一个程序运行的状态
线程中数据没有隔离
线程很轻，开销很小,速度很快

如何开启一个线程

from threading import Thread


def task():
    print(‘我是子线程‘)


if __name__ == ‘__main__‘:  # 线程可以不用放在这个方法里面，不过为了看起来舒服，线程也放在这个里面
    t = Thread(target=task, )
    t.start()
    print(‘我是主线程‘)

GIL全局解释器锁

python在设计之初就考虑到要在主循环中，同时只有一个线程在执行，虽然python解释器中可以‘运行；多个线程，但在任意时刻只有一个线程在解释器中执行.
而正是因为有这个锁所以在同一时刻才能保证只有一个线程在运行。

验证线程中数据共享

from threading import Thread


def task():
    global n
    n = 10
    print(‘我是子线程的n: %s‘ % n)


if __name__ == ‘__main__‘:
    n = 100
    t = Thread(target=task, )
    t.start()
    print(‘我是主线程的n: %s‘ % n)

内置方法

is_alive()  # 判断线程是否存活
getName()   # 返回线程名
setName()   # 设置线程名
join()      # 子线程运行完之后在运行主线程
threading模块提供的方法
threading.currentThread()  # 返回当前的线程变量
threading.enumerate()      # 返回一个正在运行的线程列表
threading.activeCount()    # 返回正在运行的线程数量

上代码：
from threading import Thread
import time
import threading


def task():
    time.sleep(3)
    print(‘我是子线程‘)
    # print(‘子线程： ‘, threading.current_thread())  # 注意这个是返回当前的线程变量


if __name__ == ‘__main__‘:
    t = Thread(target=task, )
    t.start()
    # t.join()
    print(‘我是主线程‘)

    # print(t.is_alive())
    # t.setName(‘lyh‘)
    # print(t.getName())
    # print(‘主线程:‘ ,threading.current_thread())

    print(threading.enumerate())   # 这个以及下面那个，返回的都是正在运行
    print(threading.active_count())

守护线程

"""
对于进程还是线程来说，守护都是指的主结束，被守护立马结束，但是并不是立即终止运行

对于主进程来说： 运行完毕指的是主进程代码运行完毕
对于主线程来说： 运行完毕指的是主进程里面的所有非守护线程运行完毕，主线程才算运行完毕
"""
例一(主线程里面只有一个守护线程)

from threading import Thread
import time


def task():
    time.sleep(3)
    print(‘我是子线程‘)


if __name__ == ‘__main__‘:
    t = Thread(target=task, )
    t.setDaemon(True)
    t.start()
    print(‘我是主线程‘)
    
"""
这个例子就是只有一个线程，还是守护线程，程序运行起来，没用守护线程之前，先运行子线程代码，接着运行主线代码，
但是有了守护线程以后，程序运行，开启一个线程，在哪里睡3秒，而此时运行主线程内容，主线程结束，子线程被迫结束
"""

例二：(主线程里面有两个线程，一个守护线程，一个非守护线程)
from threading import Thread
import time


def task():
    time.sleep(3)
    print(‘我是非守护线程‘)

def func():
    time.sleep(1)
    print(‘我是守护线程‘)


if __name__ == ‘__main__‘:
    t = Thread(target=task, )
    # t.setDaemon(True)
    t.start()

    t1 = Thread(target=func)
    t1.setDaemon(True)
    t1.start()
    print(‘我是主线程‘)
    
 """
 这个呢我们给func设置成守护线程，程序启动，先开启两个线程，func和task都阻塞在睡眠哪里，先运行主线程代码
 但是呢，task是非守护线程，并且task睡眠时间要比func长，此时主线程结束的时候，task还没用结束，所以最终的打印结果就是全都有
 """


****** 对主线程来说，运行完毕指的是主线程所在的进程内所有非守护线程统统运行完毕，主线程才算运行完毕

互斥锁(同步锁)

锁就是为了数据安全的

from threading import Thread


def task():
    global n
    n -= 1


if __name__ == ‘__main__‘:
    ll = []
    n = 10
    for i in range(10):
        t = Thread(target=task, )
        t.start()

    print(n)
    
"""
这个呢就是十个进程操作一个数据
"""


from threading import Thread
import time


def task():
    global n
    temp = n
    time.sleep(1)
    n = temp - 1


if __name__ == ‘__main__‘:
    ll = []
    n = 10
    for i in range(10):
        t = Thread(target=task, )
        t.start()
        ll.append(t)
    for i in ll:
        i.join()

    print(n)
    
"""
这里数据就是不安全的，把那个参数n传给了temp， 接下来就是睡眠，是个进程全部阻塞在这里，拿到的都是temp也就是10，
"""

加锁：

from threading import Thread, Lock
import time


def task():
    global n
    lock.acquire()
    temp = n
    time.sleep(0.1)
    n = temp - 1
    lock.release()


if __name__ == ‘__main__‘:
    ll = []
    n = 10
    lock = Lock()
    for i in range(10):
        t = Thread(target=task, )
        t.start()
        ll.append(t)
    for i in ll:
        i.join()

    print(n)

信号量

from threading import Thread, Semaphore
import time


def task(i):
    sm.acquire()
    print(f‘{i}开始蹲坑‘)
    time.sleep(0.1)
    print(f‘{i}蹲坑完毕‘)
    sm.release()



if __name__ == ‘__main__‘:
    sm = Semaphore(2)

    for i in range(10):
        t = Thread(target=task, args=(i, ))
        t.start()
        
        
"""
本质其实就是多把锁
"""

Event事件

from threading import Thread, Event
import time

def girl(event):
    print(f‘黄仁金正在恋爱‘)
    time.sleep(3)
    print(‘黄仁金分手了‘)
    event.set()   # 传出一个信号，


def boy(i, event):
    print(f‘{i}正在等待黄仁金分手‘)
    event.wait()  # 在这接受信号
    print(f‘{i}开始追黄仁金‘)


if __name__ == ‘__main__‘:
    event = Event()
    t = Thread(target=girl, args=(event, ))
    t.start()
    for i in range(10):
        t = Thread(target=boy, args=(i, event))
        t.start()

线程第一讲

原文：https://www.cnblogs.com/lyh-cur/p/15044589.html