并发编程之线程

一,线程的定义

1.1什么是线程

(进程其实是一个资源单位,而进程内的线程才是cpu上的执行单位)线程其实指的就是代码的执行过程

1,2为何要用线程(相比进程,线程有什么优点)

(1)同一进程下的多个线程共享该进程内的资源

(2)创建线程的开销要远远小于进程

二,开启线程的两种方式(类似于开启进程的两种方式)

首先导入threading里面的Thead方法,定义一个新的线程对象

方式一:定义一个线程执行的函数

from threading import Thread
import time


def task(name):
    print('%s is running' %name)
    time.sleep(2)
    print('%s is done' %name)


if __name__ == '__main__':
    t=Thread(target=task,args=('线程1',))  #定义一个新的线程对象
    t.start()  #线程在发送信号的那一刻就执行了
    print('主')

方式二:定义一个执行线程执行的类,类下面有二个run方法

from threading import Thread
import time

class Mythread(Thread):
    def run(self):
        print('%s is running' %self.name)
        time.sleep(2)
        print('%s is done' %self.name)

if __name__ == '__main__':
    t=Mythread()
    t.start()
    print('主')

二,线程特性的介绍

2.1线程之间的资源是共享的

from threading import Thread
import time

n=100
def task():
    global n
    n=0  #把另一个线程里面的n改了

if __name__ == '__main__':
    t=Thread(target=task)
    t.start()
    t.join()
    print('主',n)   #这里是主线程里面的n

输出结果是0

2.2线程之间是平级的,没有主次之分(这也是和进程的区别)

from threading import Thread
import time,os

def task():
    print('%s is running' %os.getpid())

if __name__ == '__main__':
    t=Thread(target=task)
    t.start()
    print('主',os.getpid())

输出结果你会发现,两个线程的pid进程是一样的

 

2.3查看当前现成的名字

from threading import Thread,active_count,current_thread
import time,os

def task():
    print('%s is running' %current_thread().name) #调用线程里面的方法,自动获取名字
    time.sleep(2)

if __name__ == '__main__':
    t=Thread(target=task,)
    t.start()
    print('主',current_thread().name)

# 可以后期自动给线程添加名字

from threading import Thread
import time

def task(name):
    print('%s is running' %name)
    time.sleep(2)
    print('%s is done' %name)

if __name__ == '__main__':
    t=Thread(target=task,args=('线程1',))
    t.daemon=True
    t.start()
    print('主')

三,守护线程

等待所有非守护线程全部结束之后,守护进程无论运行到哪一步都会强制停止(注意区别于守护进程)

from threading import Thread
from multiprocessing import Process
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)

    t1.daemon=True
    t1.start()
    t2.start()
    print("main-------")

四,线程互斥锁

from threading import Thread,Lock
import time


mutex = Lock()   #产生一个互斥锁对象
n =100
def task():
    global n
    mutex.acquire()  #把下面的内容锁起来,这个线程执行完以后下一个是未知的
    temp = n
    time.sleep(0.1)
    n = temp-1
    mutex.release()

if __name__ == '__main__':
    t_l = []
    for i in range(100):
        t=Thread(target=task)
        t_l.append(t)
        t.start()

    for t in t_l:   #等待所有的线程全部结束
        t.join()
    print(n)