python进程线程

【Python】 进程与线程 在计算机操作系统中,进程是资源分配和调度的基本单位。每个进程都有自己独立的内存空间、代码执行上下文以及系统资源,如文件描述符、网络连接等。进程之间相互隔离,一个进程的崩溃通常不会影响到其他进程。 在 Python 中,多进程编程允许我们充分利用多核处理器的优势,并行地执行多个任务,从而提高程序的执行效率和响应速度。例如,在处理大规模数据计算、网络爬虫的并发请求、图像处理等任务时,多进程可以显著缩短执行时间。 阅读详情

进程与线程

进程是程序执行的最小单元,每个进程都有自己独立的内存空间,而线程是进程的一个实体,是系统调用调用的一个基本单位。

举个栗子吧:

我们启动一个app 这就创建了一个进程,这个app里可能有语音播放、搜索等功能,这些是进程里不同的线程。

注意:线程是轻量级的,他没有独立的空间地址(内存空间),因为他是由进程创建的,寄存在进程的内存地址中。一个进程会包含多个线程

 

线程的5种状态:

1、新建状态:

    当一个线程被创建时就开始了它的生命周期,在启动线程之前他一直处于新建状态。

2、就绪状态:

    当线程被启动时,由于还没有分配到cpu资源,该线程进入等待队列在等待另一个线程执行完(等待cpu服务),此时线程被称为就绪状态。

3、运行状态:

    当处于就绪状态的线程被调用并获得cpu资源时,此时为运行状态。

4、阻塞状态:

    一个正在执行的线程在某些情况下不得已让出cpu资源时,会中止自己的执行过程,这是被称为阻塞状态。值得注意的是:阻塞被消除后是回到就绪状态,不是运行状态。

5、死亡状态:

    线程被终止、销毁、或执行完毕则进入死亡状态。不可再重新启动

阻塞状态又分为三种情况:等待阻塞、同步阻塞、其他阻塞

说到阻塞不得不提到一个‘锁’的概念

多线程可以运行多个任务,很大程度上提高了我们程序的工作效率,但是面临一个非常致命的问题。如果有多个线程去操作同一个列表(这个列表被称为:共享数据),比如线程a要列表第一个元素的值加1,这个过程可以细分为3步:1.取出元素;2:元素加1;3:将最终的结果放入列表。那如果在a线程执行到第二步加1的时候线程b突然要读取列表 那么他读取到的列表仍然是没修改之前的内容。这并不是我们想要的

所以引进了锁的概念。当某个线程需要独占共享资源时,必须先上锁,这样别的线程就无法再操作。当操作完之后一定要将锁打开,别的线程才可以操作数据。

在I/O密集型操作中,需要保持数据同步的时候需要加锁 保证资源同步。但同时因为其他线程面临阻塞,性能不可避免的会下降。

同步阻塞:线程请求锁定的时候进入同步阻塞,一旦获得锁又变成运行状态。

等待阻塞:是指等待其他线程通知的状态,线程获得条件锁定后,调用“等待”将进入这个状态,一旦其他线程发出通知,线程将进入同步状态,再次竞争条件锁定。

其他阻塞:指线程sleep 、join或等待io时的阻塞。

进程

 fork()一个进程,包括代码、数据和分配给进程的资源。fork()函数通过系统调用创建一个与原来进程几乎完全相同的进程,也就是两个进程可以做完全相同的事,但如果初始参数或者传入的变量不同,两个进程也可以做不同的事。

Unix/Linux操作系统提供了一个fork()系统调用,它非常特殊。普通的函数调用,调用一次,返回一次,但是fork()调用一次,返回两次,因为操作系统自动把当前进程(称为父进程)复制了一份(称为子进程),然后,分别在父进程和子进程内返回。

子进程永远返回0,而父进程返回子进程的ID。这样做的理由是,一个父进程可以fork出很多子进程,所以,父进程要记下每个子进程的ID,而子进程只需要调用getppid()就可以拿到父进程的ID。

Python的os模块封装了常见的系统调用,其中就包括fork,可以在Python程序中轻松创建子进程:

import os

print('Process (%s) start...' % os.getpid())
# Only works on Unix/Linux/Mac:
pid = os.fork()
if pid == 0:
    print('I am child process (%s) and my parent is %s.' % (os.getpid(), os.getppid()))
else:
    print('I (%s) just created a child process (%s).' % (os.getpid(), pid))


>>>Process (8232) start...
I (8232) just created a child process (8283).
I am child process (8283) and my parent is 8232.

 有了fork调用,一个进程在接到新任务时就可以复制出一个子进程来处理新任务,常见的Apache服务器就是由父进程监听端口,每当有新的http请求时,就fork出子进程来处理新的http请求。

 Multiprocessing

multiprocessing模块提供了一个Process类来代表一个进程对象,下面的例子演示了启动一个子进程并等待其结束:

from multiprocessing import Process
import os

# 子进程要执行的代码
def run_proc(name):
    print('Run child process %s (%s)...' % (name, os.getpid()))

if __name__=='__main__':
    print('Parent process %s.' % os.getpid())
    p = Process(target=run_proc, args=('test',))
    print('Child process will start.')
    p.start()
    p.join()
    print('Child process end.')

>>>Parent process 8360.
Child process will start.
Run child process test (8453)...
Child process end.

创建子进程时,只需要传入一个执行函数和函数的参数,创建一个Process实例,用start()方法启动,这样创建进程比fork()还要简单。

join()方法可以等待子进程结束后再继续往下运行,通常用于进程间的同步。

 

Pool

如果要启动大量的子进程,可以用进程池的方式批量创建子进程:

from multiprocessing import Pool
import os, time, random

def long_time_task(name):
    print('Run task %s (%s)...' % (name, os.getpid()))
    start = time.time()
    time.sleep(random.random() * 3)
    end = time.time()
    print('Task %s runs %0.2f seconds.' % (name, (end - start)))

if __name__=='__main__':
    print('Parent process %s.' % os.getpid())
    p = Pool(4)
    for i in range(5):
        p.apply_async(long_time_task, args=(i,))
    print('Waiting for all subprocesses done...')
    p.close()
    p.join()
    print('All subprocesses done.')


>Parent process 8360.
Waiting for all subprocesses done...
Run task 0 (8525)...
Run task 1 (8526)...
Run task 2 (8527)...
Run task 3 (8528)...
Task 2 runs 0.13 seconds.
Run task 4 (8527)...
Task 4 runs 0.54 seconds.
Task 3 runs 1.04 seconds.
Task 1 runs 1.14 seconds.
Task 0 runs 1.34 seconds.
All subprocesses done.

对Pool对象调用join()方法会等待所有子进程执行完毕,调用join()之前必须先调用close(),调用close()之后就不能继续添加新的Process了。

请注意输出的结果,task 0,1,2,3是立刻执行的,而task 4要等待前面某个task完成后才执行,这是因为Pool设置为4,因此,最多同时执行4个进程。这是Pool有意设计的限制,并不是操作系统的限制。如果改成:

p = Pool(5)

就可以同时跑5个进程。

 

 

线程

import _thread
import threading
import time

def my_thread(threadName):
   for i in range(10):
       print(' 线程 :' + threadName + '正在执行')

# 启动线程
# 方法名  方法参数,无参时空tuple
# _thread.start_new_thread()
t1 = threading.Thread(target=my_thread, args=('name1',))
t2 = threading.Thread(target=my_thread, args=('name2',))

## t1 = _thread.start_new_thread(my_thread, ('name1',))
# t2 = _thread.start_new_thread(my_thread, ('name2',))

# 通过start方法 启动线程
t1.start()
t2.start()

从控制台打印的结果来看 t1线程和t2线程无规律的交错打印。这正是两个线程之间抢占cpu资源的结果。

 

模拟多窗口出售电影票的场景来理解阻塞和锁

import threading
# 库存电影票数量,为了使结果更加准确设置成10w
num = 100000
def thread(name):
   global num
   while num > 0:
       num -= 1
       print('%s出售 1 张电影票 === 剩余 %d 张电影票' % (name, num))

# 三种售票途径
businesses = ['美团', '淘票', '糯米']
for i in businesses:
   # 创建线程
   t = threading.Thread(target=thread, args=(i,))
   # 启动线程
   t.start()

通过多次运行代码、发现控制台打印的结果有时候明明两个窗口都售出去一张票了,但余票数量相等。更明显的是明明美团窗口显示余票已经为0了,但是另外两个窗口还是有很多剩余电影票 。

通过分析控制台记录我们会发现,美团售票窗口一次性卖了好几百张票,糯米和淘票窗口的数据一直没有更新成最新的库存,导致明明没票了,缺还显示剩余很多。

不仅仅是售票,生活中有很多这样的例子,比如抢购火车票,银行取钱等...都会有这种数据不同步的问题。解决这一问题的办法就是前面提到的‘锁’。

简单的讲美团在卖票的过程中,将库存进行锁定,在这期间糯米和淘票票不可以在操作,只能等待美团操作完将数据更新后,然后释放锁才可以继续操作。

在threading模块中提供了一个获得线程锁的方法:

threading.Lock()

import threading
# 库存电影票数量,为了使结果更加准确设置成10w
num = 100000
lock = threading.Lock()
def thread(name):
   global num
   while num > 0:
       # 加锁  这里一定要放在判断总量之前,
       # 不然会导致另外两个窗口最后会出现负数票的情况
       # 如果没有加锁就释放锁会导致报错,所以在while循环里又加了一层if判断
       lock.acquire()
       if num > 0:
           num -= 1
           print('%s出售 1 张电影票 === 剩余 %d 张电影票' % (name, num))
           # 释放锁
           lock.release()
       else:
           lock.release()

# 三种售票途径
businesses = ['美团', '淘票', '糯米']
for i in businesses:
   # 创建线程
   t = threading.Thread(target=thread, args=(i,))
   # 启动线程
   t.start()

 在运行时我们发现,无论执行代码多少次,最终票数为0时,所有窗口都停止售票了。这个例子很完美的阐述了阻塞和锁在多线程中的重要性!!!

线程一:创建线程

Python中有两个线程模块,分别是thread和threading,threading是thread的升级版。threading的功能更强大。

创建线程有3种方法:

1.thread模块的start_new_thread函数

2、继承自threading.Thread模块

3、用theading.Thread直接返回一个thread对象,然后运行它的start方法

方法一、thread模块的start_new_thread函数


其函数原型:
    start_new_thread(function,atgs[,kwargs])
其参数含义如下:
    function: 在线程中执行的函数名
    args:元组形式的参数列表。
    kwargs: 可选参数,以字典的形式指定参数(即对一些参数进行指定初始化)

import _thread
 
def hello(id = 0, interval = 2):
    for i in filter(lambda x: x % interval == 0, range(10)):
        print ("Thread id : %d, time is %d\n" % (id, i))
 
if __name__ == "__main__":
 
    #_thread.start_new_thread(hello, (1,2))   这种调用形式也是可用的
    #_thread.start_new_thread(hello, (2,4))
     
    _thread.start_new_thread(hello, (), {"id": 1})
    _thread.start_new_thread(hello, (), {"id": 2})

方法二:继承自threading.Thread模块

注意:必须重写run函数,而且想要运行应该调用start方法

import threading
 
class MyThread(threading.Thread):
 
    def __init__(self, id, interval):
        threading.Thread.__init__(self)
 
        self.id = id
        self.interval = interval
 
    def run(self):
        for x in filter(lambda x: x % self.interval == 0, range(10)):
            print ("Thread id : %d   time is %d \n" % (self.id, x))
 
 
if __name__ == "__main__":
    t1 = MyThread(1, 2)
    t2 = MyThread(2, 4)
 
    t1.start()
    t2.start()
 
    t1.join()
    t2.join()

 方法三:用theading.Thread直接返回一个thread对象,然后运行它的start方法

import threading
 
def hello(id, times):
    for i in range(times):
        print ("hello %s time is %d\n" % (id , i))
 
 
if __name__ == "__main__":
    t = threading.Thread(target=hello, args=("Tom", 5))
    t.start()

 

python线程二:Timer(定时器) join()

Timer:  隔一定时间调用一个函数,如果想实现每隔一段时间就调用一个函数的话,就要在Timer调用的函数中,再次设置Timer。Timer是Thread的一个派生类

import threading
import time

def hello(name):
    print ("hello %s\n" % name)

    global timer
    timer = threading.Timer(2.0, hello, ["Tom"])
    timer.start()

if __name__ == "__main__":
    timer = threading.Timer(2.0, hello, ["Tom"])
    timer.start()

join()
如果一个线程在执行过程中要调用另外一个线程,并且等到其完成以后才能接着执行

def my_thread(threadName):
  for i in range(10):
      print(' 线程 :' + threadName + '正在执行')

# 启动线程
# 方法名  方法参数,无参时空tuple
# _thread.start_new_thread()
t1 = threading.Thread(target=my_thread, args=('name1',))
t2 = threading.Thread(target=my_thread, args=('name2',))

# t1 = _thread.start_new_thread(my_thread, ('name1',))
# t2 = _thread.start_new_thread(my_thread, ('name2',))

# 通过start方法 启动线程
t1.start()
t2.start()
# 如果不加join 则Ending会在t1和t2没有执行完就会打印
# 加了join之后 Ending会等待线程执行完毕之后才会打印
t1.join()
t2.join()
print("Ending 。。。。。")

python线程三:简单锁实现线程同步

Python中有两种锁,一个锁是原始的锁(原语), 不可重入,而另一种锁则是可重入的锁即递归锁。而thread模块中,只提供了不可重入的锁,而在threading中则提供这两种锁。

可重入:当一个线程拥有一个锁的使用权后,再次获取锁的使用权时,不会阻塞,会立马得到使用权,则原始锁的话,则不行,会阻塞。

方法一:thread的不可重入锁

import _thread
import time
 
lock = _thread.allocate_lock()
 
def Count(id):
    global num;
 
    while True:
        lock.acquire()
        if num <= 10:
            print ("Thread id is : %s     The num is %s\n" % (id, str(num)))
            num = num + 1
        else:
            break
        lock.release()
    else:
        _thread.exit_thread()
 
if __name__ == "__main__":
    num = 1
    _thread.start_new_thread(Count, ('A',))
    _thread.start_new_thread(Count, ('B',))
 
    time.sleep(5)

方法二:theading的Lock(不可重入锁)

import threading
import time
 
lock = threading.Lock()
 
def Count(id):
    global num;
 
    while True:
        lock.acquire()
        if num <= 10:
 
            print ("Thread id is : %s     The num is %s\n" % (id, str(num)))
            num = num + 1
        else:
            break
        lock.release()
 
if __name__ == "__main__":
    num = 1
    t1 = threading.Thread(target=Count, args=('A', ))
    t2 = threading.Thread(target=Count, args=('B', ))
 
    t1.start()
    t2.start()
 
    time.sleep(5)

方法三:threading的RLock(可重入)

RLock允许在同一线程中被多次acquire。而Lock却不允许这种情况。注意:如果使用RLock,那么acquire和release必须成对出现,即调用了n次acquire,必须调用n次的release才能真正释放所占用的琐。

import threading
import time
 
lock = threading.RLock()
 
def CountNum(id):
    global num
     
    lock.acquire()
     
    if num <= 10:
        print ("Thread id is : %s     The num is %s\n" % (id, str(num)))
        num = num + 1
        CountNum(id)
 
    lock.release()
 
if __name__ == "__main__":
    num = 1
    t1 = threading.Thread(target=CountNum, args=('A'))
 
    t1.start()
 
    time.sleep(5)

 

python线程四:Condition 条件变量()

 可以把Condiftion理解为一把高级的琐,它提供了比Lock, RLock更高级的功能,允许我们能够控制复杂的线程同步问题。threadiong.Condition在内部维护一个琐对象(默认是RLock),可以在创建Condigtion对象的时候把琐对象作为参数传入。Condition也提供了acquire, release方法,其含义与琐的acquire, release方法一致,其实它只是简单的调用内部琐对象的对应的方法而已。Condition还提供wait方法、notify方法、notifyAll方法(特别要注意:这些方法只有在占用琐(acquire)之后才能调用,否则将会报RuntimeError异常)

    条件变量是属于线程的高级应用,所以我们一般需要引入threading模块,而在条件变量中,最经典的例子,恐怕就是生产者与消费者的问题了。

  Condition:  一个比Lock, RLock更高级的锁

  wait:    等待被唤醒

  notify/notifyAll : 唤醒一个线程,或者唤醒所有线程

  注意:Condition,在wait之前必须require

  代码:

import threading
import time

class Buf:
    def __init__(self):

        self.cond = threading.Condition()
        self.data = []

    def isFull(self):
        return len(self.data) == 5

    def isEmpty(self):
        return len(self.data) == 0

    def get(self):

        self.cond.acquire()

        while self.isEmpty():
            self.cond.wait()

        temp = self.data.pop(0)

        self.cond.notify()
        self.cond.release()
        return temp

    def put(self, putInfo):
        self.cond.acquire()

        while self.isFull():
            self.cond.wait()

        self.data.append(putInfo)

        self.cond.notify()
        self.cond.release()


def Product(num):
    for i in range(num):
        info.put(i+1)
        print ("Product %s\n" % (str(i+1)))

def Customer(id, num):
    for i in range(num):
        temp = info.get()
        print ("Customer%s %s\n" % (id, str(temp)))

info = Buf();


if __name__ == "__main__":
    p = threading.Thread(target=Product, args=(10, ))
    c1 = threading.Thread(target=Customer, args=('A', 5))
    c2 = threading.Thread(target=Customer, args=('B', 5))

    p.start()
    time.sleep(1)
    c1.start()
    c2.start()

    p.join()
    c1.join()
    c2.join()

    print ("Game Over")

python线程五:semphore同步

  Semaphore:Semaphore 在内部管理着一个计数器。调用 acquire() 会使这个计数器 -1,release() 则是+1(可以多次release(),所以计数器的值理论上可以无限).计数器的值永远不会小于 0,当计数器到 0 时,再调用 acquire() 就会阻塞,直到其他线程来调用release()

Semphore,是一种带计数的线程同步机制,当调用release时,增加计算,当acquire时,减少计数,当计数为0时,自动阻塞,等待release被调用。

而在Python中存在两种Semphore,一种就是纯粹的Semphore,还有一种就是BoundedSemaphore。

区别:

Semphore:  在调用release()函数时,不会检查,增加的计数是否超过上限(没有上限,会一直上升)

BoundedSemaphore:在调用release()函数时,会检查,增加的计数是否超过上限,这样就保证了使用的计数

代码:

import threading
import time

semaphore = threading.Semaphore(3)
#semaphore = threading.BoundedSemaphore(3)

def fun():
    print ("Thread %s is waiting semphore\n" % threading.currentThread().getName())
    semaphore.acquire()
    print ("Thread %s get semphore\n" % threading.currentThread().getName())
    time.sleep(1)
    print ("Thread %s release semphore\n" % threading.currentThread().getName())
    semaphore.release()


if __name__ == "__main__":
    t1 = threading.Thread(target=fun)
    t2 = threading.Thread(target=fun)
    t3 = threading.Thread(target=fun)
    t4 = threading.Thread(target=fun)

    t1.start()
    t2.start()
    t3.start()
    t4.start()

    t1.join()
    t2.join()
    t3.join()
    t4.join()

    semaphore.release()  #这里因为是简单的Semaphore,所以可以再次释放,不会报错,而BoundedSemaphore,则会报错

python线程六:Event

 

Event:  是线程同步的一种方式,类似于一个标志,当该标志为false时,所有等待该标志的线程阻塞,当为true时,所有等待该标志的线程被唤醒

 

isSet():       当内置标志为True时返回True。 
set():         将标志设为True,并通知所有处于等待阻塞状态的线程恢复运行状态。 
clear():       将标志设为False。 
wait([timeout]):  如果标志为True将立即返回,否则阻塞线程至等待阻塞状态,等待其他线程调用set()

import threading
import time

event = threading.Event()

def func():
    print ("%s is waiting for event...\n" % threading.currentThread().getName())
    event.wait()

    print ("%s get the Event..\n" % threading.currentThread().getName())


if __name__ == "__main__":
    t1 = threading.Thread(target=func)
    t2 = threading.Thread(target=func)

    t1.start()
    t2.start()

    time.sleep(2)

    print "MainThread set Event\n"

    event.set()

    t1.join()
    t2.join()

python线程七:Local(线程局部存储)

线程局部存储(tls),对于同一个local,线程无法访问其他线程设置的属性;线程设置的属性不会被其他线程设置的同名属性替换。

代码:

import threading

local = threading.local()
local.tname = "main"

def func(info):
    local.tname = info
    print local.tname

t1 = threading.Thread(target=func, args=['funcA'])
t2 = threading.Thread(target=func, args=['funcB'])

t1.start()
t1.join()

t2.start()
t2.join()

print (local.tname)

isAlive

 isAlive 等价于 is_alive(self),用于判断线程是否运行。当线程没有调用start时,或者线程执行完毕处于死亡状态,isAlive()返回false。

# False
print(t1.isAlive())
t1.start()
# True
print(t1.is_alive())

Daemon

Python主程序当且仅当不存在非Daemon线程存活时退出。即:主程序等待所有非Daemon线程结束后才退出,且退出时会自动结束(很粗鲁的结束)所有Daemon线程。

t1 = threading.Thread(target=thread_run, args=('jone', ), daemon= True)
t1.setDaemon(True)

 

Python进程、线程、协程 每个进程都有各自的一块独立的内存,保证进程彼此间的内存地址空间的隔离。这种任务虽然也可以用多任务完成,但是当任务过多时(超过cpu的核数),花在任务切换的时间就越多,CPU执行任务的效率就越低,所以,要最高效地利用CPU,计算密集型任务同时进行的数量应当等于CPU的核心数。:涉及到网络、磁盘IO的任务都是IO密集型任务,比如网络传输、数据库等调用、爬虫等,这类任务的特点是CPU消耗很少,任务的大部分时间都在等待IO操作完成(存在阻塞),99%的时间花费在IO上(因为IO的速度远远低于CPU和内存的速度)。 阅读详情

相关推荐

python 进程 线程 协程

1.进程 线程 协程 概念 a.进程 我们电脑的应用程序,都是进程,假设我们用的电脑是单核的,cpu同时只能执行一个进程。当程序处于I/O阻塞的时候,CPU如果和程序一起等待,那就太浪费了,cpu会去执行其他的程序,此时就涉及到切换,切换前要保存上一个程序运行的状态,才能恢复,所以就需要有个东西来记录这个东西,就可以引出进程的概念了。 ​ 进程就是一个程序在一个数据集上的一次动态执行过程。进程由程序,数据集,进程控制块三部分组成。程序用来描述进程哪些功能以及如何完成;数据集是程序执行过程中所使用的资源

kk_12345z的博客 1528

Python3学习19--进程和线程

本系列博文基于廖雪峰老师的官网Python教程,笔者在大学期间已经阅读过廖老师的Python教程,教程相当不错,官网链接: 廖雪峰官方网站.请需要系统学习Python的小伙伴到廖老师官网学习,笔者的编程环境是Anaconda+Pycharm,Python版本:Python3. 1.概述 """ 基础知识: 1.多任务:操作系统可以同时运行多个任务; 2.单核CPU执行多任务:操作系统轮流让各个任务交替执行; 3.一个任务即一个进程(process),如:打开一个浏览器,即启动一个浏览器进程; 4.在一个

FUXI_Willard 1423

STM32F103串口接收中断:USART_IT_IDLE和USART_IT_RXNE区别

2:如果是大于1个byte的数据,在不用DMA的情况下,同时使能USART_IT_RXNE,USART_IT_IDLE中断,每收到一个字节在中断中把数据存到缓存中,待收到USART_IT_IDLE中断时,收完整帧数据,然后再解析处理数据。比如:如上图在初始化时,同时开启了两个中断,如果传送8个字节的数据,就会产生8个USART_IT_RXNE,和1个USART_IT_IDLE中断。(如果接收到数据,在1个byte的时间内,没有收到新数据,就认为是数据传送完成,产生空闲USART_IT_IDLE中断)

weixin_66299220的博客 2403

【Linux】-- 进程概念

当我们写完代码之后,编译连接就形成一个可执行程序.exe,本质是二进制文件,在磁盘上存放着。双击这个.exe文件把程序运行起来就是把程序从磁盘加载到内存,然后CPU才能执行其代码语句。当把程序加载到内存后,这个程序就叫做进程。所有启动程序的过程,本质都是在系统上创建进程,双击.exe文件也不例外

局部变量和全局变量 2963

GD32F303驱动WS2812B灯带:用TIMER+PWM+DMA解放CPU,实现流畅灯效(附完整代码)

本文详细介绍了基于GD32F303的TIMER+PWM+DMA全自动控制方案,用于高效驱动WS2812B灯带。通过硬件外设协同工作,该方案不仅解放了CPU资源,还能实现复杂的灯光效果,如渐变、流水等。文章提供了完整的代码实现和性能优化技巧,适合嵌入式开发者参考。

weixin_42561143的博客 382

一文掌握python图形界面开发PyQt6--(一)基本操作、控件、信号与槽、常用控件、布局管理、事件处理、文件对话框

一文掌握python图形界面开发PyQt6--(一)基本操作、控件、信号与槽、常用控件、布局管理、事件处理、文件对话框

qq_38120851的博客 4047

Python基础之进程(Process)

进程是计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,是操作系统结构的基础。在早期面向进程设计的计算机结构中,进程是程序的基本执行实体;在当代面向线程设计的计算机结构中,进程是线程的容器。程序是指令、数据及其组织形式的描述,进程是程序的实体。 狭义定义:进程是正在运行的程序的实例(an instance of a computer program that is...

PythonGo 6万+

倍压整流电路设计

倍压整流电路利用二极管和电容的充放电特性实现电压提升,可分为二倍压、三倍压及多倍压结构。其工作原理是通过交流电正负半周交替对电容充电并叠加电压,具有结构简单、成本低的优点,但带载能力差且纹波较大。典型应用包括示波器、电蚊拍等小电流高压场景。设计时需重点考虑电容耐压、二极管选型和负载匹配,高频驱动可优化性能。该电路在低功耗高压电源中具有独特优势,但需注意安全防护与电压稳定性问题。

硬核科技 1726

多进程

1.fork(): import os  pid = os.fork() if pid == 0:     print('I am child process (%s) and my parent is %s.' % (os.getpid(), os.getppid())) else:     print('I (%s) just created a child process

lyj1101066558的博客 446

zynq7020的arm A9核降频实录

zynq arm9 cortex a9 降频

qq_40011737的博客 8766

【C# + HALCON 机器视觉】HALCON经典算子:光流法运动分析(optical_flow_mg)

摘要:本文面向智能监控人流统计需求,研究C#与HALCON集成开发中optical_flow_mg算子的应用。通过RTSP获取视频流,利用光流法计算运动矢量,结合形态学操作与区域筛选实现行人区域分割,最终完成人流量统计与热力图可视化。详细阐述ROI局部处理等性能优化策略、try-catch异常捕获机制及跨平台集成方案。实验表明,该系统检测准确率达93.6%,单帧处理时间42ms,为公共场所人流量统计提供了完整可行的技术方案。

专注于人工智能、软件开发、工控自动化、工厂数字化及智能化等领域,希望和大家共同进步! 1445

Python3-定时任务四种实现方式

https://blog.51cto.com/huangyg/2367088 最近做一个小程序开发任务,主要负责后台部分开发;根据项目需求需要实现三个定时任务: 1>定时更新微信token,需要2小时更新一次; 2>商品定时上线; 3>定时检测后台服务是否存活; 老猫使用Python去实现这三个任务,这里需要使用定时相关知识点; Python实现定点与定时任务方式比较多,老猫...

0x8g1T9E- 5791

小红书图文笔记图像批量爬取:Python爬虫实战与反反爬策略全解析

在当今社交媒体盛行的时代,小红书作为中国领先的生活方式分享平台,积累了海量的优质图文内容。对于数据分析师、市场研究人员或内容创作者来说,能够高效获取这些数据具有重要意义。本文将详细介绍如何使用Python构建一个高效、稳定的小红书图文笔记图像批量爬取工具,涵盖最新技术栈和反反爬策略。本文详细介绍了如何使用Python构建一个高效、稳定的小红书图文笔记图像批量爬取系统。通过结合Playwright、aiohttp等现代工具,实现了从列表页采集到图片下载的完整流程。

2201_76125261的博客 2366

Python 中进程和线程

文章目录线程和进程一、 什么是进程 / 线程1、 引论2、 线程3、 进程4、 区别5、 使用二、 多线程使用1、 常用方法2、 常用参数3、 多线程的应用3.1 重写线程法3.2 直接调用法4、 线程间数据的共享三、 多进程使用1、 简介2、 应用2.1 重写进程法2.2 直接调用法3、 进程之间的数据共享3.1 Lock 方法3.2 Manager 方法四、 池并发1、 语法2、 获取 CPU 数量3、 线程池3、 进程池 线程和进程 一、 什么是进程 / 线程 1、 引论 众所周知,CPU是计算机的

一个专注于机器学习基础与实战的技术博客,内容涵盖算法推导、模型实现、数学原理与代码实践。用通俗的语言解析复杂概念,记录学习过程中的思考与总结,适合机器学习爱好者和从业者参考。 3229

高通MBIM拨号流程简述

高通平台MBIM流程简述

不秃头的程序猿Gabriel的博客 5071

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

Python进程,线程

多任务是指在同⼀时间内执行多个任务。

m0_74263216的博客 1311

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

Python 进程、线程、协程

计算机系统抽象组成: CPU + 存储器 + IO时间片(timeslice)又称为 “量子”(quantum)或 “处理器片”(processor slice),是分时操作系统分配给每个正在运行的进程微观上的一段 CPU 时间(在抢占内核中是:从进程开始运行直到被抢占的时间)。对于单核cpu同一时刻只能有一个任务运行。1. 并发:交替执行(某时间段内的处理能力)2. 并行:同时执行线程(Thread):是操作系统最小的调度单位, 是一串指令的集合。

qq_60271706的博客 1478

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

Python中的进程和线程

Python中的进程和线程 一.进程的概念 一个正在运行的程序或者软件就是一个进程,它是操作系统进行资源分配的基本单位,也就是说每启动一个进程,操作系统都会给其分配一定的运行资源(内存资源)保证进程的运行。 注意: 一个程序运行后至少有一个进程,一个进程默认有一个线程,进程里面可以创建多个线程,线程是依附在进程里面的,没有进程就没有线程. 并行:多个cpu同时处理多个程序 并发:一个cpu在一个很小的时间段之内在多个程序之间来回切换执行,切换的时间由操作系统决定,但时间比较小 进程的作用: 单进程效果图:

Lonely_Fishes的博客 1466

python的进程、线程详解

python世界中的进程和线程理解

qq_42746084的博客 1496

Python——进程与线程

摘要:本文介绍了进程与线程相关知识。进程是启动后的程序,系统会分配内存空间。创建进程方式有使用 Process 子类和 multiprocessing 模块,还介绍了进程的方法、属性,以及获取进程信息、多进程共享数据(Queue、Value 等)、进程同步(Lock)。进程池、线程池的语法和常用方法,以及 submit 与 map 的区别,多线程和多进程的对比。进程间通过 Queue 通信。线程是 CPU 可调度最小单位,创建线程方式有 Thread 函数和继承 Thread 类。

2401_88868983的博客 1265

Python之进程与线程

进程与多线程 1. 进程 1.1 什么是进程 进程是操作系统分配内存资源的最小单位 一个进程之内会默认有一个线程 进程是Python程序中执行多任务的一种方式 1.2 多进程的使用 进程创建的三步: 导入包 import multiprocessing 创建进程 启动进程 start import multiprocessing import time def dance(): for item in range(1, 5): print("跳舞...")

不小努力的小龙 1842

Python进程和线程

thread创建线程、线程共享变量、线程互斥Lock、进程Process、创建进程、杀死进程、进程之间共享数据、进程互斥Lock

原名又逢乱世。不要放下学习的脚步,毕竟比天天打牌、钓鱼、打游戏更能从内在充实自己。 2051

Python基础:线程与进程

Python中的线程和进程是两种实现程序并发执行的基本单位,它们在计算机中扮演着不同的角色,各有其特点和用途。‌。

在技术的广袤天地里,本博客如精准罗盘。剖析前沿科技,深掘代码奥秘,以精炼笔触,带您穿越复杂技术迷宫,速达知识彼岸。 852
上一篇: Python 小知识
下一篇: python list,dict, str操作
Lxy_Python
博客等级 码龄9年 19粉丝 31原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值