并发编程之多线程(更新中...)

并发编程之多线程

什么是线程？
- 被cpu直接运行，一条线程指的是一个单一顺序中的控制流，一个进程中可以并行多个进程，每个并行执行不同的任务
- ```
如果把操作系统比作一个车间的话，而进程就是一个个车间，线程就是车间里边的一条条流水线，电源就是cpu
```

进程和线程的区别

- 线程 ：单指代码的执行过程
- 进程：资源的申请与销毁的过程
- 进程内存空间彼此隔离
- 同一进程下的线程可以共享资源
- 进程需要申请资源开辟内存空间   慢
- 线程只是告诉操作系统一个执行方案  快

为什么要用多线程

- 多线程共享一个内存空间，节约资源
- 线程比进程更容易创建，在许多操作系统中，创建一个线程比创建一个进程要快10-100倍，在有大量线程需要动态和快速修改时，这一特性很有用
- 若多个线程都是cpu密集型的，那么并不能获得性能上的增强，但是如果存在大量的计算和大量的I/O处理，拥有多个线程允许这些活动彼此重叠运行，从而会加快程序执行的速度。
- 若多个线程都是cpu密集型的，那么并不能获得性能上的增强，但是如果存在大量的计算和大量的I/O处理，拥有多个线程允许这些活动彼此重叠运行，从而会加快程序执行的速度。

开启进程的两种方式

方式一

from threading import Thread
import time
def task():
    print("线程开启\n")
    time.sleep(2)
    print("线程结束\n")
if __name__ == '__main__':
    t = Thread(target=task)
    t.start()
    print("主线程")

方式二

from threading import Thread
import time
class myt(Thread):
    def run(self):
        print("线程开启\n")
        time.sleep(2)
        print("线程结束\n")
if __name__ == '__main__':
    t= myt()
    t.start()
    print("主进程")

线程与进程运行速度比较

from threading import Thread
from multiprocessing import Process
def task():
    print("线程开启")
    print("线程结束\n")

def task1():
    print("进程开启")
    print("进程结束\n")
if __name__ == '__main__':
    t = Thread(target=task)
    t.start()
    print("主线程")
    p = Process(target=task1)
    p.start()
    print("主线程")

线程共享内存空间

from threading import Thread
x = 100
def task():
    global x
    x =50
t = Thread(target=task)
t.start()
print(x)
def task1():
    global x
    x = 2
t1 = Thread(target=task1)
t1.start()
print(x)

线程中join用法

from threading import Thread
import time
def tast(name,time_):
    print(f"{name} 开启")
    time.sleep(time_)
    print(f"{name} 结束")
if __name__ == '__main__':
    t1 = Thread(target=tast,args=('线程1',1))
    t2 = Thread(target=tast,args=('线程2',2))
    t3 = Thread(target=tast,args=('线程3',3))
    start = time.time()
    t1.start()
    t2.start()
    t3.start()
    t1.join()
    t2.join()
    t3.join()
    end = time.time()
    print("主线程")
    print(end-start)

线程相关的其他方法

    print("线程开启\n")
    time.sleep(2)
    print("线程结束\n")
if __name__ == '__main__':
    t = Thread(target=task)
    t.start()
    # 检测线程是否活动
    print(t.is_alive())
    #返回线程名字
    print(t.getName())
    #修改线程名字
    t.setName("线程1")
    print(t.getName())
    #返回当前线程变量
    print(threading.currentThread())
    #返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
    print(threading.enumerate())
    # 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果
    print(threading.activeCount())
    print("主线程")

守护进程

等待主线程最后一行代码结束完毕之后销毁

from threading import Thread
import time
def task():
    print("这是子线程开始\n")
    time.sleep(2)
    print("这是子线程结束")
if __name__ == '__main__':
    t = Thread(target=task)
    #将线程变成守护线程
    t.daemon = True
    t.start()
    print("这是主线程")

并发编程之多线程(更新中...)

并发编程之多线程

猜你喜欢