并发编程(二) 线程

1.线程基本概念

什么是线程

　　进程和线程都是虚拟的单位,都是用来帮助我们形象的描述某种事物

　　进程是资源分配的最小单位,线程是cpu调度的最小单位,每一个进程中至少有一个线程,进程只是在线程运行过程中提供代码运行所需的资源

　　将内存比作工厂,那么进程就相当于工厂的车间,而线程就相当于车间内的流水线

为什么要有线程

　　进程

　　　　一个进程只能在一个时间干一件事,如果想干多件事,进程就无能为力了

　　　　开一个进程需要开辟一个新的内存空间,将代码丢进去执行,这是一件十分耗费资源的事

　　线程

　　　　一个进程中可以开多个线程,并且线程和线程之间的数据也是共享的

　　　　开启线程的资源耗费是远远小于开启一个进程的

进程和线程的区别:

　　1.地址空间的区别和资源之间的共享

　　2.通信:进程间通信要通过队列来实现,而线程之间可以直接读写所处进程中的数据来通信

　　3.调度和切换:线程的调度切换比进程快的多

　　4.在多线程操作系统中,进程不是一个可执行的实体

2.创建线程的两种方式

　　和创建进程类似,创建线程也有两种方式

from threading import Thread
import time

def task(name):
    print('%s开始'%name)
    time.sleep(1)
    print('%s结束'%name)

# 线程的代码块不需要写在__main__内,但是我们还是习惯性的写在里边
t = Thread(target=task,args=('sxc',))
t1 = Thread(target=task,args=('zzj',))
t.start()
t1.start()
print('主')

from threading import Thread
import time

class MyThread(Thread):  # 新建一个类继承父类Thread的方法
    def __init__(self,name):
        super().__init__()
        self.name = name

    def run(self):
        print('%s开始'%self.name)
        time.sleep(1)
        print('%s结束'%self.name)

if __name__ == '__main__':
    t1 = MyThread('sxc')  # 类名加括号实例化对象
    t2 = MyThread('zzj')
    t1.start()
    t2.start()
    print('主')

注意:创建线程时,我们可以不将执行的代码块放在__main__方法内,但是习惯还是放在里边 

3.线程对象及其他方法

current_thread().name:查看当前的线程号
os.getpid:查看当前的进程号
t.join():主线程等待子线程运行结束
active_count():查看当前活跃的进程数

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

def task(name):
    print('%s开始'%name)
    print('子current_thread:',current_thread().name)  # 查看当前线程
    print('子os.getpid',os.getpid())  # 查看进程号
    time.sleep(1)
    print('%s结束'%name)

if __name__ == '__main__':
    t = Thread(target=task,args=('sxc',))
    t.start()
    print('当前活跃的线程',active_count())  # 查看当前活跃的进程数
    t.join()  # 主线程等待子线程结束才能执行下方代码
    print('主current_thread:', current_thread().name)  # 查看当前线程
    print('主os.getpid', os.getpid())  # 查看进程号
    print('主')
    print('当前活跃的线程', active_count())

多线程也能实现TCP并发

# 多线程实现并发
# 服务端
import socket
from threading import Thread

server = socket.socket()
server.bind(('127.0.0.1',8080))
server.listen()

def task(conn):
    while True:
        try:
            data = conn.recv(1024)
            if len(data) == 0:break
            print(data.decode('utf-8'))
            conn.send(data.upper())
        except ConnectionResetError as e:
            print(e)
            break
    conn.close()

if __name__ == '__main__':

    while True:
        conn, addr = server.accept()
        t = Thread(target=task,args=(conn,))
        t.start()

# 多线程实现并发客户端
import socket
from threading import Thread,current_thread

client = socket.socket()
client.connect(('127.0.0.1',8080))

def task(client,i):
    while True:
        msg = '线程%s已开启%s'%(current_thread().name,i)
        client.send(msg.encode('utf-8'))
        data = client.recv(1024)
        print(data.decode('utf-8'))

if __name__ == '__main__':
    for i in range(10):
        t = Thread(target=task,args=(client,i))
        t.start()

4.守护线程

　　无论输进程还是线程,只要设置了守护之后,守护的进程或线程等待主运行完毕后会被销毁

from threading import Thread
import time

def task(name):
    print('%s开始'%name)
    time.sleep(1)
    print('%s结束'%name)

if __name__ == '__main__':
    t = Thread(target=task,args=('sxc',))
    t.daemon = True  # 将子进程设置为守护线程,必须在子线程开始之前设置,否则会报错
    t.start()
    print('主')

注意:主线程运行完毕指的是主线程所在的进程内所有非守护线程都运行完毕,主线程才算运行完毕

from threading import Thread
import time

def task(name,i):
    print('%s开始'%name)
    time.sleep(i)
    print('%s结束'%name)

if __name__ == '__main__':
    t = Thread(target=task,args=('sxc',1))
    t1 = Thread(target=task,args=('zzj',2))
    t.daemon = True  # 将子进程设置为守护线程,必须在子线程开始之前设置,否则会报错
    t.start()
    t1.start()
    print('主')  # 只有所有非守护进程结束才算真正的运行结束

判断上述例子的打印结果

5.线程间通信,数据共享

　　进程间数据是不能共享的,因此需要引入队列来进行通信,而线程的数据输共享的,可以直接通信

from threading import Thread

age = 18

def task():
    global age
    age = 20
    print('子:',age)

if __name__ == '__main__':
    print('生成子之前的主:',age)
    t = Thread(target=task)
    t.start()
    t.join()
    print('生成子之后的主:',age)

6.互斥锁

 　　在多个线程修改共享的数据时,数据安全性和可靠性不能保证,需要进行加锁处理

from threading import Thread,Lock
import time
n = 100

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

if __name__ == '__main__':
    mutex = Lock()  # 实例化锁对象
    t_list = []
    for i in range(100):
        t = Thread(target=task,args=(mutex,))  # 把锁传入
        t.start()
        t_list.append(t)
    for t in t_list:
        t.join()
    print(n)

注意:这个锁我们只需要加在共享的数据部分就行了,即只有加锁的部分是串行,这样能在保证数据安全的前提下,最大化效率.

31