并发编程——线程

TCB包括以下信息：
（1）线程状态。
（2）当线程不运行时，被保存的现场资源。
（3）一组执行堆栈。
（4）存放每个线程的局部变量主存区。
（5）访问同一个进程中的主存和其它资源。
用于指示被执行指令序列的程序计数器、保留局部变量、少数状态参数和返回地址等的一组寄存器和堆栈。

1 内核支持线程是OS内核可感知的，而用户级线程是OS内核不可感知的。
2 用户级线程的创建、撤消和调度不需要OS内核的支持，是在语言（如Java）这一级处理的；而内核支持线程的创建、撤消和调度都需OS内核提供支持，而且与进程的创建、撤消和调度大体是相同的。
3 用户级线程执行系统调用指令时将导致其所属进程被中断，而内核支持线程执行系统调用指令时，只导致该线程被中断。
4 在只有用户级线程的系统内，CPU调度还是以进程为单位，处于运行状态的进程中的多个线程，由用户程序控制线程的轮换运行；在有内核支持线程的系统内，CPU调度则以线程为单位，由OS的线程调度程序负责线程的调度。
5 用户级线程的程序实体是运行在用户态下的程序，而内核支持线程的程序实体则是可以运行在任何状态下的程序。

优点：当有多个处理机时，一个进程的多线程可以同时执行。
缺点：由内核进行调度。

优点：
线程的调度不需要内核直接参与，控制简单。
可以在不支持线程的操作系统中实现。
创建和销毁线程、线程切换代价等线程管理的代价比内核线程少得多。
允许每个进程定制自己的调度算法，线程管理比较灵活。
线程能够利用的表空间和堆栈空间比内核级线程多。
同一进程中只能同时有一个线程在运行，如果有一个线程使用了系统调用而阻塞，那么整个进程都会被挂起。另外，页面失效也会产生同样的问题。
缺点：
资源调度按照进程进行，多个处理机下，同一个进程中的线程只能在同一个处理机下分时复用

import os
from threading import Thread
from multiprocessing import Process

def work():
    print(‘hello‘,os.getpid())

if __name__ == ‘__main__‘:
    # 在主进程下开启多个线程，每个线程都跟主进程的pid一样。
    t1 = Thread(target=work)
    t2 = Thread(target=work)
    t1.start()
    t2.start()
    print(‘主线程，主进程pid‘,os.getpid())

    # 开启多个进程，每个进程都有不同的pid.
    p1 = Process(target=work)
    p2 = Process(target=work)
    p1.start()
    p2.start()
    print(‘主线程，主进程pid‘,os.getpid())
    
# hello 5500
# hello 5500
# 主线程，主进程pid 5500

# 主线程，主进程pid 5500
# hello 4696
# hello 9900

import time
from threading import Thread
from multiprocessing import Process

def work():
    print(‘hello‘)

if __name__ == ‘__main__‘:
    # 在主进程下开启线程
    start1 = time.time()
    t = Thread(target=work)
    t.start()
    print(‘主线程，主进程‘,time.time()-start1)
    ‘‘‘
    打印结果：
    hello
    主线程，主进程 0.00099945068359375
    ‘‘‘

    # 在主进程下开启子进程
    start2 = time.time()
    p = Process(target=work)
    p.start()
    print(‘主线程，主进程‘,time.time()-start2)
    ‘‘‘
    打印结果：
    主线程，主进程 0.03098011016845703
    hello
    ‘‘‘
# 通过时间差可以看出，线程要比进程快很多。

from threading import Thread
from multiprocessing import Process

def work():
    global n
    n = 0

if __name__ == ‘__main__‘:
    # n = 100
    # p = Process(target=work)
    # p.start()
    # p.join()
    # print(n)    # 100
# 子进程中的n已经自己的全局变量改成了0，但改的仅仅是它自己的，父进程的n依然不变。

    n = 100
    t = Thread(target=work)
    t.start()
    t.join()
    print(n)    # 0
# 同一进程内的线程之间是数据共享的，所以n被改动了。

import time
import threading
from threading import Thread
from multiprocessing import Process

def work():
    time.sleep(3)
    print(threading.current_thread().getName()) # Thread-1

if __name__ == ‘__main__‘:
    # 在主进程下开启线程
    t = Thread(target=work)
    t.start()

    print(threading.current_thread().getName()) # MainThread
    print(threading.current_thread())   # <_MainThread(MainThread, started 2400)>
    print(threading.currentThread)  # <function current_thread at 0x000002261D4EC730>
    print(threading.enumerate())    # [<_MainThread(MainThread, started 2400)>, <Thread(Thread-1, started 10544)>]
    print(threading.active_count()) # 2
    print(‘主线程，主进程‘)    #  主线程，主进程

import time
from threading import Thread

def sayhi(name):
    time.sleep(2)
    print(‘%s say hello‘ % name)

if __name__ == ‘__main__‘:
    t = Thread(target=sayhi,args=(‘egon‘,))
    t.start()
    t.join() # 等待子线程结束才会继续执行下面的代码
    print(‘主线程‘)
    print(t.is_alive())
    
    ‘‘‘
    egon say hello
    主线程
    False
    ‘‘‘

#1 主进程在其代码结束后就已经算运行完毕了（守护进程在此时就被回收）,然后主进程会一直等非守护的子进程都运行完毕后回收子进程的资源(否则会产生僵尸进程)，才会结束，
#2 主线程在其他非守护线程运行完毕后才算运行完毕（守护线程在此时就被回收）。因为主线程的结束意味着进程的结束，进程整体的资源都将被回收，而进程必须保证非守护线程都运行完毕后才能结束。

import time
from threading import Thread

def sayhi(name):
    time.sleep(2)
    print(‘%s say hello‘% name)

if __name__ == ‘__main__‘:
    t = Thread(target=sayhi,args=(‘egon‘,))
    t.setDaemon(True) # 设置守护线程
    t.start()

    print(‘主线程‘)
    print(t.is_alive())
    ‘‘‘
    主线程
    True
    ‘‘‘
    
# 守护线程会随着主线程的执行完毕而结束，所以还没来得及直接子线程内的代码就结束了。

import time
from threading import Thread

def foo():
    print(123)
    time.sleep(1)
    print(‘end123‘)

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

t1 = Thread(target=foo)
t2 = Thread(target=bar)

t1.setDaemon(True)
# t1.daemon = True
t1.start()
t2.start()
print(‘main------‘)

# 主线程在代码执行完毕后会等待非守护线程的子线程结束才会结束。

import os
import time
from threading import Thread

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

if __name__ == ‘__main__‘:
    n = 100
    l = []
    for i in range(100):
        p = Thread(target=work)
        l.append(p)
        p.start()
    for p in l:
        p.join()

    print(n)

# 按逻辑说n应该是0,但是由于抢占资源，最后打印的结果可能为99

import os
import time
from threading import Thread,Lock

def work():
    global n
    lock.acquire()
    temp = n
    n = temp - 1
    lock.release()

if __name__ == ‘__main__‘:
    lock = Lock()
    n = 100
    l = []
    for i in range(100):
        t = Thread(target=work)
        l.append(t)
        t.start()
    for t in l:t.join()

    print(n)    # 0
# 由原来的并发执行变成了串行，牺牲了执行效率，但保证了数据安全。

#不加锁:并发执行,速度快,数据不安全
from threading import current_thread,Thread,Lock
import os,time
def task():
    global n
    print(‘%s is running‘ %current_thread().getName())
    temp=n
    time.sleep(0.5)
    n=temp-1


if __name__ == ‘__main__‘:
    n=100
    lock=Lock()
    threads=[]
    start_time=time.time()
    for i in range(100):
        t=Thread(target=task)
        threads.append(t)
        t.start()
    for t in threads:
        t.join()

    stop_time=time.time()
    print(‘主:%s n:%s‘ %(stop_time-start_time,n))

‘‘‘
Thread-1 is running
Thread-2 is running
......
Thread-100 is running
主:0.5216062068939209 n:99
‘‘‘


#不加锁:未加锁部分并发执行,加锁部分串行执行,速度慢,数据安全
from threading import current_thread,Thread,Lock
import os,time
def task():
    #未加锁的代码并发运行
    time.sleep(3)
    print(‘%s start to run‘ %current_thread().getName())
    global n
    #加锁的代码串行运行
    lock.acquire()
    temp=n
    time.sleep(0.5)
    n=temp-1
    lock.release()

if __name__ == ‘__main__‘:
    n=100
    lock=Lock()
    threads=[]
    start_time=time.time()
    for i in range(100):
        t=Thread(target=task)
        threads.append(t)
        t.start()
    for t in threads:
        t.join()
    stop_time=time.time()
    print(‘主:%s n:%s‘ %(stop_time-start_time,n))

‘‘‘
Thread-1 is running
Thread-2 is running
......
Thread-100 is running
主:53.294203758239746 n:0
‘‘‘

#有的同学可能有疑问:既然加锁会让运行变成串行,那么我在start之后立即使用join,就不用加锁了啊,也是串行的效果啊
#没错:在start之后立刻使用jion,肯定会将100个任务的执行变成串行,毫无疑问,最终n的结果也肯定是0,是安全的,但问题是
#start后立即join:任务内的所有代码都是串行执行的,而加锁,只是加锁的部分即修改共享数据的部分是串行的
#单从保证数据安全方面,二者都可以实现,但很明显是加锁的效率更高.
from threading import current_thread,Thread,Lock
import os,time
def task():
    time.sleep(3)
    print(‘%s start to run‘ %current_thread().getName())
    global n
    temp=n
    time.sleep(0.5)
    n=temp-1


if __name__ == ‘__main__‘:
    n=100
    lock=Lock()
    start_time=time.time()
    for i in range(100):
        t=Thread(target=task)
        t.start()
        t.join()
    stop_time=time.time()
    print(‘主:%s n:%s‘ %(stop_time-start_time,n))

‘‘‘
Thread-1 start to run
Thread-2 start to run
......
Thread-100 start to run
主:350.6937336921692 n:0 #耗时是多么的恐怖
‘‘‘

）

from threading import Lock as Lock
import time
mutexA=Lock()
mutexA.acquire()
mutexA.acquire()
print(123)
mutexA.release()
mutexA.release()

from threading import RLock as Lock
import time
mutexA=Lock()
mutexA.acquire()
mutexA.acquire()
print(123)
mutexA.release()
mutexA.release()

import time
from threading import Thread,Lock
noodle_lock = Lock()
fork_lock = Lock()
def eat1(name):
    noodle_lock.acquire()
    print(‘%s 抢到了面条‘%name)
    fork_lock.acquire()
    print(‘%s 抢到了叉子‘%name)
    print(‘%s 吃面‘%name)
    fork_lock.release()
    noodle_lock.release()

def eat2(name):
    fork_lock.acquire()
    print(‘%s 抢到了叉子‘ % name)
    time.sleep(1)
    noodle_lock.acquire()
    print(‘%s 抢到了面条‘ % name)
    print(‘%s 吃面‘ % name)
    noodle_lock.release()
    fork_lock.release()

for name in [‘哪吒‘,‘egon‘,‘yuan‘]:
    t1 = Thread(target=eat1,args=(name,))
    t2 = Thread(target=eat2,args=(name,))
    t1.start()
    t2.start()

import time
from threading import Thread,RLock
fork_lock = noodle_lock = RLock()
def eat1(name):
    noodle_lock.acquire()
    print(‘%s 抢到了面条‘%name)
    fork_lock.acquire()
    print(‘%s 抢到了叉子‘%name)
    print(‘%s 吃面‘%name)
    fork_lock.release()
    noodle_lock.release()

def eat2(name):
    fork_lock.acquire()
    print(‘%s 抢到了叉子‘ % name)
    time.sleep(1)
    noodle_lock.acquire()
    print(‘%s 抢到了面条‘ % name)
    print(‘%s 吃面‘ % name)
    noodle_lock.release()
    fork_lock.release()

for name in [‘哪吒‘,‘egon‘,‘yuan‘]:
    t1 = Thread(target=eat1,args=(name,))
    t2 = Thread(target=eat2,args=(name,))
    t1.start()
    t2.start()