正文

Python 并发部分的面试题

IP云
IP云V管理员/3 阅读
12/02
提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

进程
  • 进程间内存是否共享？如何实现通讯？
    进程间内存不共享，可以通过
    1. Manage模块加锁
    2. 通过队列或
    3. 通过管道加锁
    4. socket实现通讯
  • 请聊聊进程队列的特点和实现原理？
    1. 先进先出 Queue
    2. 后进先出 LifoQueue
    3. 优先级队列 PriorityQueue
    4. 线程本身带锁通过put()数据和get()数据，同一时间只有一个线程运行修改任务实现数据安全
  • 请画出进程的三状态转换图 
    就绪====运行

       \阻塞/
  • 你了解生产者模型消费者模型么？如何实现？ 
yield:

def consumer():

    n = yield

    n = yield

    n = yield

    n = yield

    n = yield

    n = yield

    n = yield

    n = yield

def producer():

    g = consumer()

    next(g)

    for i in range(2000000):

        g.send(i)
  • 从你的角度说说进程在计算机中扮演什么角色？
    进程在计算机中扮演数据集的调用调配角色。
    负责回收和控制子线程的运行，是一个数据集。
    ##线程
  • GIL锁是怎么回事?
    GIL锁是全局解释器锁，只有CPython中使用，同一时间只能有一个线程调度CPU
  • 在python中是否线程安全？
    不安全，需要加锁才安全
  • 什么叫死锁？
    同时满足两个条件锁才能解开，分别有两把或以上的锁，有多个线程分别抢占了两个条件中的锁，互不释放造成阻塞，死锁现象。
  • logging模块是否是线程安全的？
    logging模块是线程安全的，因为使用的是单例设计模式。
  • threading.local的作用？
    Python提供了 threading.local 类，将这个类实例化得到一个全局对象，
    但是不同的线程使用这个对象存储的数据其它线程不可见(本质上就是不同的线程使用这个对象时为其创建一个独立的字典)。
  • 程序从flaga执行到falgb的时间大致是多少秒？
    60s 因为没有设置守护线程，需要等子线程跑完主线程才结束 
import threading

import time

def _wait():

    time.sleep(60)

# flag a

t = threading.Thread(target=_wait, daemon=False)

t.start()

# flag b
  • 程序从flaga执行到falgb的时间大致是多少秒？
    0.01s 因为设置守护线程，子线程等待所有非子线程结束子线程结束。 
import threading

import time

def _wait():

    time.sleep(60)

# flag a

t = threading.Thread(target=_wait, daemon=True)

t.start()

# flag b
  • 程序从flaga执行到falgb的时间大致是多少秒？
    60s 因为设置了阻塞需要等待子线程结束主线程才能结束 
import threading

import time

def _wait():

    time.sleep(60)

# flag a

t = threading.Thread(target=_wait, daemon=True)

t.start()

t.join()

# flag b
  • 读程序，请确认执行到最后number是否一定为0
    不一定，因为存在线程安全问题，同一时间修改变量值 
import threading

loop = int(1E7)

def _add(loop: int = 1):

    global number

    for _ in range(loop):

        number += 1

def _sub(loop: int = 1):

    global number

    for _ in range(loop):

        number -= 1

number = 0

ta = threading.Thread(target=_add, args=(loop,))

ts = threading.Thread(target=_sub, args=(loop,))

ta.start()

ts.start()

ta.join()

ts.join()

print(number)
  • 读程序，请确认执行到最后number是否一定为0
    一定为0 ,因为增删操作只有一条语句不会产生数据安全问题。 
import threading

loop = int(1E7)

def _add(loop: int = 1):

    global number

    for _ in range(loop):

        number += 1

def _sub(loop: int = 1):

    global number

    for _ in range(loop):

        number -= 1

number = 0

ta = threading.Thread(target=_add, args=(loop,))

ts = threading.Thread(target=_sub, args=(loop,))

ta.start()

ta.join()

ts.start()

ts.join()

print(number)
  • 读程序，请确认执行到最后number的长度是否一定为1
    不一定为1，因为产生了阻塞可能有数据安全问题。 
import threading

loop = int(1E7)

def _add(loop: int = 1):

    global numbers

    for _ in range(loop):

        numbers.append(0)

def _sub(loop: int = 1):

    global number

    while not numbers:

        time.sleep(1E-8)

    numbers.pop()

numbers = [0]

ta = threading.Thread(target=_add, args=(loop,))

ts = threading.Thread(target=_sub, args=(loop,))

ta.start()

ta.join()

ts.start()

ts.join()

print(numbers)
  • 读程序，请确认执行到最后number的长度是否一定为1
    不一定为1，因为产生了阻塞可能有数据安全问题。 
import threading

loop = int(1E7)

def _add(loop: int = 1):

    global numbers

    for _ in range(loop):

        numbers.append(0)

def _sub(loop: int = 1):

    global number

    while not numbers:

        time.sleep(1E-8)

    numbers.pop()

numbers = [0]

ta = threading.Thread(target=_add, args=(loop,))

ts = threading.Thread(target=_sub, args=(loop,))

ta.start()

ts.start()

ta.join()

ts.join()

print(numbers)

协程
  • 什么是协程？常用的协程模块有哪些？
    在线程遇到阻塞的情况时切换到另一个线程继续执行，如果遇到阻塞再到另一个线程执行。如果跳转过的线程转为就绪状态就直接执行，
    知道程序中没有阻塞。有gevent,和greenlet.
  • 协程中的join是用来做什么用的？它是如何发挥作用的？
    协程是遇到阻塞才切换，join负责阻塞开始执行程序。
  • 使用协程实现并发的tcp 
server端

from gevent import monkey;monkey.patch_all()

import gevent

import time

import random

import socket

sk = socket.socket()

server_addr = ('127.0.0.1',9988)

sk.bind(server_addr)

sk.listen()

def listen(conn):

    while True:

        msg = conn.recv(1024).decode('utf-8')

        if msg == 'q':break

        conn.send(msg.upper().encode('utf-8'))

if __name__ == '__main__':

    while True:

        conn,addr = sk.accept()

        gevent.spawn(listen,conn)
  • 在一个列表中有多个url，请使用协程访问所有url，将对应的网页内容写入文件保存 
from gevent import monkey;monkey.patch_all()

import time

import random

import gevent

from urllib.request import urlopen

url_dic = {

   '协程':'http://www.cnblogs.com/Eva-J/articles/8324673.html',

   '线程':'http://www.cnblogs.com/Eva-J/articles/8306047.html',

   '目录':'https://www.cnblogs.com/Eva-J/p/7277026.html',

   '百度':'http://www.baidu.com',

   'sogou':'http://www.sogou.com',

   '4399':'http://www.4399.com',

   '豆瓣':'http://www.douban.com',

   'sina':'http://www.sina.com.cn',

   '淘宝':'http://www.taobao.com',

   'JD':'http://www.JD.com'

}

def getHtml(url):

   ret = urlopen(url)

   html = ret.read()

   html_file = url.replace('.','_').lstrip('https://').replace('/','_')+'.html'

   with open(html_file,mode='wb') as f:

       f.write(html)

   print(url+'done')

if __name__ == '__main__':

    print('start')

    lst = list()

    for url in url_dic:

       ret = gevent.spawn(getHtml,url_dic[url])

       lst.append(ret)

    for url in lst:

       url.join()

    print(1)

综合
  • 进程和线程的区别
    进程是计算机资源分配的最小单位，线程是cpu调度的最小单位，线程较进程来说较轻量，启动更迅速。调用更方便
  • 进程池、线程池的优势和特点
    进程池一般在高计算的条件下使用，资源消耗更多。
    线程池可以运行在一个进程中，执行效率更高，可控cpu使用率。节约资源。
  • 线程和协程的异同?
    协程，即协作式程序，其思想是，一系列互相依赖的协程间依次使用CPU，每次只有一个协程工作，而其他协程处于休眠状态。
    协程实际上是在一个线程中，只不过每个协程对CUP进行分时，协程可以访问和使用unity的所有方法和component
    线程，多线程是阻塞式的，每个IO都必须开启一个新的线程，但是对于多CPU的系统应该使用thread，尤其是有大量数据运算的时刻，
    但是IO密集型就不适合；而且thread中不能操作unity的很多方法和component
  • 请简述一下互斥锁和递归锁的异同？
    两者在在单锁的情况下都可以保证数据的可靠性。
    二者唯一的区别是，同一个线程可以多次获取同一个递归锁，不会产生死锁。而如果一个线程多次获取同一个非递归锁，则会产生死锁。
  • 请列举一个python中数据安全的数据类型？
    Queue
  • Python中如何使用线程池和进程池 
from concurrent.futures import ThreadPoolExecutor

from concurrent.futures import ProcessPoolExector

p = ProcessPoolExector(4)

ret = p.submit(func,aa)

print(ret.result())
  • 简述
    进程、线程、协程的区别
    进程是：一个CPU情况下，多个程序分别使用机器资源（CPU或硬盘等）的概念；
    线程是：一个进程情况下，多个执行流程（即线程）分别使用分配给该进程的机器资源的概念；
    • 协程是：一个线程情况下，多个执行流程（即协程）由线程控制，分别使用分配给该线程的机器资源的概念；
      以及应用场景？
    • 多进程：密集CPU任务，需要充分使用多核CPU资源（服务器，大量的并行计算）的时候，用多进程。 multiprocessing
      缺陷：多个进程之间通信成本高，切换开销大。
    • 多线程：密集I/O任务（网络I/O，磁盘I/O，数据库I/O）使用多线程合适。
      threading.Thread、multiprocessing.dummy
      缺陷：同一个时间切片只能运行一个线程，不能做到高并行，但是可以做到高并发。
    • 多线程请求返回是无序的，那个线程有数据返回就处理那个线程，而协程返回的数据是有序的。
      缺陷：单线程执行，处理密集CPU和本地磁盘IO的时候，性能较低。处理网络I/O性能还是比较高.
  • 什么是并行，什么是并发？
    并行是同一时间在多个cpu上同时执行多个程序
    并发是同一时间在同一个cpu上在不同程序之间切换运行
  • 请解释同步和异步这两个概念？
    同步执行程序需要等待结果
    异步执行程序不需要等待结果
  • 请谈谈对异步非阻塞的了解？
    执行效率高，可以实现高并发的应用场景
  • 简述信号量的实现原理
    • 信号量机制即利用pv操作来对信号量进行处理。什么是信号量？信号量（semaphore）的数据结构为一个值和一个指针，指针指向等待该信号量的下一个进程。信号量的值与相应资源的使用情况有关。当它的值大于0时，表示当前可用资源的数量；
    • 当它的值小于0时，其绝对值表示等待使用该资源的进程个数。注意，信号量的值仅能由PV操作来改变。一般来说，信号量S³0时，
    • S表示可用资源的数量。执行一次P操作意味着请求分配一个单位资源，因此S的值减1；当S<0时，表示已经没有可用资源，
    • 请求者必须等待别的进程释放该类资源，它才能运行下去。而执行一个V操作意味着释放一个单位资源，因此S的值加1；若S£0，
    • 表示有某些进程正在等待该资源，因此要唤醒一个等待状态的进程，使之运行下去。
  • 程序中的阻塞有哪些？给程序带来了哪些影响？
    input,sleep,io 程序会等待阻塞完成才会进入就绪队列，影响程序运行效率
  • 请分别用多进程、多线程、协程实现生产者消费者模型？

多进程 
import time

import random

from multiprocessing import Process,Queue

def producer(name,que):

    for i in range(10):

        time.sleep(random.random())

        food = '便便

相关阅读

目录[+]