头歌Python 课内实验4-1：进程和线程-基础

第1关：求素数的个数

本关任务：使用Python多进程求素数个数。

import math
from multiprocessing import cpu_count
from multiprocessing import Pool


def isPrime(n):
    # 判断数字是否为素数
    #        请在此处添加代码       #
    # *************begin************#
    if n==1:
        return False
    for i in range(2,int(math.sqrt(n))+1):
        if n%i==0:
            return False
    return True
    # **************end*************#




def howMany(T):
    # 计算给定区间含有多少个素数
    #        请在此处添加代码       #
    # *************begin************#
    n=0
    for i in range(T[0],T[1]+1):
        if isPrime(i)==True:
            n=n+1
    return n
    # **************end*************#




def separateNum(N, CPU_COUNT):
    # 对整个数字空间N进行分段CPU_COUNT
    #        请在此处添加代码       #
    # *************begin************#
    x=N//CPU_COUNT
    n=0
    p=[]
    for i in range(CPU_COUNT):#101分4   1-25,26-50,51-75，76-101
        p.append([i*x+1,(i+1)*x])
        
    if p[CPU_COUNT-1][1]<N:
        p[CPU_COUNT-1][1]=N
    return p
    # **************end*************#
    
if __name__ == '__main__':
    N = int(input())
    # 多进程
    CPU_COUNT = cpu_count()  ##CPU内核数 本机为8
    pool = Pool(CPU_COUNT)
    sepList = separateNum(N, CPU_COUNT)
    result = []
    for i in range(CPU_COUNT):
        result.append(pool.apply_async(howMany, (sepList[i], )))
    pool.close()
    pool.join()
    # ans = 0
    list = [res.get() for res in result]
    print(sum(list), end = '')

第2关：求合数的个数。

本关任务：使用 Python 多线程，实现求合数的个数。

import threading
import math
ans = 0
lock = threading.Lock()


import threading
import math
ans = 0
lock = threading.Lock()


def isPrime(n):
    # 判断数字是否为素数
   
    global ans
    if n <= 1:
        return False
    for i in range(2, int(math.sqrt(n)) + 1):
        if n % i == 0:
            return False
    return True
   



def howMany(T):
    # 计算给定区间含有多少个素数
   

    sum = 0
    for i in range(T[0], T[1] + 1):
        if isPrime(i):
            sum += 1
    lock.acquire()
    try:
        global ans
        ans += sum
    finally:
        lock.release()
   




def seprateNum(N, CPU_COUNT):
    # 对整个数字空间N进行分段CPU_COUNT
    list = [[i * (N // CPU_COUNT) + 1, (i + 1) * (N // CPU_COUNT)] for i in range(0, CPU_COUNT)]
    list[0][0] = 1
    if list[CPU_COUNT - 1][1] < N:
        list[CPU_COUNT - 1][1] = N
    return list

if __name__ == '__main__':
    N = int(input())
    threadNum = 32
 #        请在此处添加代码       #
    # *************begin************#
    sepList = seprateNum(N, threadNum)
    result = []
    for i in range(0,threadNum):
        result.append(threading.Thread(target=howMany,args=(sepList[i],)))
        result[i].start()
    for i in range(0,threadNum):
        result[i].join()
    print(N-ans-1, end = '')
    # **************end*************#

第3关：交替打印foobarpython

本关任务：输入一个数n，打印n个foobarpython。

import threading
import sys
import time


def showfoo(n):
  '''
  
  :param n: 要输出foobarpython的次数
  :return: 无返回，可直接输出
  '''
  # 请在此处添加代码       #
  # *************begin************#
  for i in range(n):
    lockpython.acquire()
    print('foo',end='')
    lockfoo.release()
  # **************end*************#


def showbar(n):
    '''

      :param n: 要输出foobarpython的次数
      :return: 无返回，可直接输出
      '''
    # 请在此处添加代码       #
# *************begin************#
    for i in range(n):
      lockfoo.acquire()
      print('bar',end='')
      lockbar.release()
# **************end*************#

def showpython(n):
    '''

      :param n: 要输出foobarpython的次数
      :return: 无返回，可直接输出
      '''
     # 请在此处添加代码       #
# *************begin************#
    for i in range(n):
      lockbar.acquire()
      print('python',end='')
      lockpython.release()
# **************end*************#


if __name__ == '__main__':
    lockfoo = threading.Lock()  # 定义3个互斥锁
    lockbar = threading.Lock()
    lockpython =threading.Lock()
    n = int(input())
    t1 = threading.Thread(target=showfoo,args=[n])  # 定义3个线程
    t2 = threading.Thread(target=showbar,args=[n])
    t3 = threading.Thread(target=showpython,args=[n])
    lockfoo.acquire()  # 先锁住foo,bar锁，保证先打印foo
    lockbar.acquire()


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