python中线程和进程(一)

目录

  • 进程和线程
  • Python中的线程
    • 1. Thread类
    • 2. 线程的启动
    • 3. 线程的传参
    • 4. 线程的属性和方法
    • 5. daemon线程和non-daemon线程
    • 6. join方法
    • 7. 定时器Timer

进程和线程

  • 进程:进程是计算机中程序正在执行的实例,是系统进行资源分配和调度的基本单位。
  • 线程:也被称为轻量级进程,是程序执行流的最小单元。一个标准的线程由线程ID,当前指令指针,寄存器集合和堆栈组成。

线程和进程的关系:

现代操作系统中,每一个进程都认为自己独占所有的计算机资源。进程好比一个国家,各个进程间不可以随便的共享数据,而线程就像是省份,同一个进程内的线程可以共享进程的资源,每一个线程拥有自己独立的堆栈。

进程和程序的关系:

程序是源代码编译后的文件,当该程序被操作系统加载到内存中,就是进程,进程中存放着指令和数据,它也是线程的容器。

Python中的线程

1. Thread类

python中线程的开发使用标准库:threading

def __init__(self, group=None, target=None, name=None,
             args=(), kwargs=None, *, daemon=None):
  • target:线程调用的对象,即目标函数
  • name: 线程名
  • args:为目标函数传递的实参,元组
  • kwargs:为目标函数关键字传参,字典

2. 线程的启动

import threading

def worker():
    print("I'm working")
    print("Finished")

t = threading.Thread(target=worker,name='worker') #创建线程对象
t.start() # 启动线程

可以通过threading.Thread创建一个线程对象,target指定目标函数,然后调用start方法进行启动线程。

3. 线程的传参

import threading
import time

def add(x,y):
    print("{} + {} = {}  线程ID:{}".format(x,y,x+y,threading.current_thread().ident))

thread1 = threading.Thread(target=add,name='add1',args=(4,5)).start()
time.sleep(1)
thread2 = threading.Thread(target=add,name='add2',args=(10,),kwargs={'y':5}).start()
time.sleep(1)
thread3 = threading.Thread(target=add,name='add3',kwargs={'x':20,'y':5}).start()

线程传参和函数传参没有什么区别,本质上就是函数传参。

4. 线程的属性和方法

threading的属性和方法

名称 含义
current_thread() 返回当前线程对象
main_thread() 返回主线程对象
active_count() 当前处于alive状态的线程数
enumerate() 返回所有活着的线程的列表,不包括已经终止的线程和为开始的线程
get_ident() 返回当前线程的ID

Thread实例的属性和方法

名称 含义
name 名称,仅仅是一个标识。可以通过getName()获取,setName()设置该名称
ident 线程ID
is_alive() 返回线程是否活着
start() 启动线程。每个线程必须且只能执行该方法一次
run() 运行线程函数

start和run的区别:
使用start启动线程,会启动一个新的线程,而使用run方法,并没有启动新的线程,只有在主线程上调用一个普通的函数。

5. daemon线程和non-daemon线程

在Python中,构造线程时,可以设置daemon属性。默认daemon线程是None,即non-daemon线程。

import time
import threading

def foo():
    time.sleep(5)
    for i in range(20):
        print(i)

t = threading.Thread(target=foo,daemon=True) #修改成None
t.start()
print("main thread Exit")

如果一个程序中只有daemon线程,那么主线程退出的时候,会结束所有的daemon线程,退出。
总结:
在一个程序中,如果有non-daemon线程的时候,主线程退出时,不会杀掉所有的daemon线程,直到所有的non-daemon线程全部结束,如果还有daemon线程,主线程退出的时候,会结束所有的daemon线程,然后退出。

6. join方法

import time
import threading

def foo(n):
    for i in range(n):
        print(i)
        time.sleep(1)

t = threading.Thread(target=foo,args=(10,),daemon=True)
t.start()
t.join() # 设置join
print("main thread Exit")

设置join后,daemon线程执行完了,程序才会退出。
join(timeout=None):
一个线程中调用另一个线程的join方法,此时调用者将会被阻塞,直到被调线程终止。一个线程可以被join多次。调用谁的join方法,就要等谁。

import time
import threading

def bar():
    while True:
        time.sleep(1)
        print("bar")

def foo():
    print("t1's daemon = {}".format(threading.current_thread().isDaemon()))
    t2 = threading.Thread(target=bar)
    t2.start()
    print("t2's daemon = {}".format(t2.isDaemon()))

t1 = threading.Thread(target=foo,daemon=True)
t1.start()
time.sleep(3)
print("main thread exiting")

只要主程序退出,2个工作线程就结束。

import time
import threading

def bar():
    while True:
        time.sleep(1)
        print("bar")

def foo():
    print("t1's daemon = {}".format(threading.current_thread().isDaemon()))
    t2 = threading.Thread(target=bar)
    t2.start()
    print("t2's daemon = {}".format(t2.isDaemon()))
    t2.join()

t1 = threading.Thread(target=foo,daemon=True)
t1.start()
t1.join()
time.sleep(3)

print("main thread exiting")

通过相互调用join方法,使线程结束不了。

7. 定时器Timer

class Timer(Thread):
    def __init__(self, interval, function, args=None, kwargs=None):

threading.Timer继承自Thread,该类用来定义多久执行一个函数。
start方法执行之后,Timer对象就会处于等待状态,等待了interval之后,开始执行function函数,如果在执行函数之前的等待阶段,使用了cancel方法,就会跳过执行函数。
但是如果线程中的函数已经开始执行,cancel就没有效果了。

import threading
import logging
import time

FORMAT = '%(asctime)s %(threadName)s %(thread)d %(message)s'
logging.basicConfig(format=FORMAT,level=logging.INFO)

def worker():
    logging.info('in worker')
    time.sleep(2)

t = threading.Timer(5,worker)
t.setName('w1')
t.cancel()  # 提前取消
t.start()
print(threading.enumerate())
time.sleep(8)
print(threading.enumerate())

原文地址:https://www.cnblogs.com/dianel/p/10477819.html

时间: 2024-10-10 23:01:10

python中线程和进程(一)的相关文章

python中线程和进程相关

1.操作系统/应用程序 a : 硬盘 , CPU , 主板 , 显卡 , 内存 , 电源 ... b.装系统 (软件) 系统就是一个由程序员写出来的软件 , 该软件用于控制计算机的硬件 , 让他们之间相互进行配合. c.安软件 (安装应用程序) QQ 百度云 pycharm .... 2.操作中的"并发"   ('并行') 并发 , 伪 , 由于执行速度特别快 , 人感觉不到停顿. 并行 , 真 , 创建10个人同时操作. 3.其他语言线程 , 进程 a. 单进程 , 单线程的应用程序

python中线程、进程和协程的区别

进程是资源分配的单位 线程是操作系统调度的单位 协程,又称微线程,纤程,协程的切换只是单纯的操作CPU的上下文,资源很小,效率高 进程切换需要的资源很最大,效率很低 一个程序至少有一个进程,一个进程至少有一个线程 线程执行开销小,但不利于资源的管理和保护:而进程正相反 通俗描述 有一个老板想要开个工厂进行生产某件商品(例如剪子) 他需要花一些财力物力制作一条生产线,这个生产线上有很多的器件以及材料这些所有的 为了能够生产剪子而准备的资源称之为:进程 只有生产线是不能够进行生产的,所以老板的找个工

Python:线程、进程与协程(2)——threading模块(1)

上一篇博文介绍了Python中线程.进程与协程的基本概念,通过这几天的学习总结,下面来讲讲Python的threading模块.首先来看看threading模块有哪些方法和类吧. 主要有: Thread :线程类,这是用的最多的一个类,可以指定线程函数执行或者继承自它都可以实现子线程功能. Timer:与Thread类似,但要等待一段时间后才开始运行,是Thread的子类. Lock :原锁,是一个同步原语,当它锁住时不归某个特定的线程所有,这个可以对全局变量互斥时使用. RLock :可重入锁

Python:线程、进程与协程(4)——multiprocessing模块(1)

multiprocessing模块是Python提供的用于多进程开发的包,multiprocessing包提供本地和远程两种并发,通过使用子进程而非线程有效地回避了全局解释器锁. (一)创建进程Process 类 创建进程的类,其源码在multiprocessing包的process.py里,有兴趣的可以对照着源码边理解边学习.它的用法同threading.Thread差不多,从它的类定义上就可以看的出来,如下: class Process(object):     '''     Proces

Python:线程、进程与协程(3)——Queue模块及源码分析

Queue模块是提供队列操作的模块,队列是线程间最常用的交换数据的形式.该模块提供了三种队列: Queue.Queue(maxsize):先进先出,maxsize是队列的大小,其值为非正数时为无线循环队列 Queue.LifoQueue(maxsize):后进先出,相当于栈 Queue.PriorityQueue(maxsize):优先级队列. 其中LifoQueue,PriorityQueue是Queue的子类.三者拥有以下共同的方法: qsize():返回近似的队列大小.为什么要加"近似&q

Python:线程、进程与协程(7)——线程池

前面转载了一篇分析进程池源码的博文,是一篇分析进程池很全面的文章,点击此处可以阅读.在Python中还有一个线程池的概念,它也有并发处理能力,在一定程度上能提高系统运行效率:不正之处欢迎批评指正. 线程的生命周期可以分为5个状态:创建.就绪.运行.阻塞和终止.自线程创建到终止,线程便不断在运行.创建和销毁这3个状态.一个线程的运行时间可由此可以分为3部分:线程的启动时间.线程体的运行时间和线程的销毁时间.在多线程处理的情景中,如果线程不能被重用,就意味着每次创建都需要经过启动.销毁和运行3个过程

Python基础—线程、进程和协程

今天已是学习Python的第十一天,来干一碗鸡汤继续今天的内容,今天的鸡汤是:超越别人对你的期望.本篇博客主要介绍以下几点内容: 线程的基本使用: 线程的锁机制: 生产者消费之模型(队列): 如何自定义线程池: 进程的基本使用: 进程的锁机制: 进程之间如何实现数据共享: 进程池: 协程的基本使用. 一.线程 1.创建线程 上篇博客已经介绍过如何创建多线程的程序,在这里在复习一下如何创建线程过程以及线程的一些方法: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 1

Python菜鸟之路:Python基础-线程、进程、协程

上节内容,简单的介绍了线程和进程,并且介绍了Python中的GIL机制.本节详细介绍线程.进程以及协程的概念及实现. 线程 基本使用 方法1: 创建一个threading.Thread对象,在它的初始化函数(__init__)中将可调用对象作为参数传入 import threading import time def worker(): time.sleep(2) print("test") for i in range(5): t = threading.Thread(target=

Python之线程与进程

1.程序 程序指的是指令的集合:程序不能单独的运行,必须将程序装载在内存中,系统给它分配资源才可以运行. 程序是进程动态运行的静态描述文本 2.进程 进程指的是程序在数据集中一次动态运行的过程: 3.线程 线程进程的最小执行单位,真正在CPU运行的是线程 4.进程与线程的关系 一个线程只能在一个进程里面,一个进程可以包含多个线程: 进程是资源管理单位(容器)  线程是最小执行单位 5.并行与并发 并行:指的是同时处理多个任务(多个线程被不同的CPU执行) 并发:指的是交替处理多个任务(多个线程被