Estoy probando la programación multiprocesador con Python. Toma un algoritmo divide y vencerás comoFibonacci por ejemplo. El flujo de ejecución del programa se ramificaría como un árbol y se ejecutaría en paralelo. En otras palabras, tenemos un ejemplo deparalelismo anidado.

Desde Java, he usado un patrón de subprocesos para administrar recursos, ya que el programa podría extenderse muy rápidamente y crear demasiados subprocesos de corta duración. Un solo grupo de subprocesos estático (compartido) se puede crear una instancia a través deExecutorService.

Yo esperaría lo mismo paraPiscina, pero parece queEl objeto de la agrupación no debe compartirse globalmente. Por ejemplo, compartiendo la piscina usandomultiprocessing.Manager.Namespace() conducirá al error.

Los objetos del pool no se pueden pasar entre procesos o decapados.

Tengo una pregunta de 2 partes:

Que me estoy perdiendo aqui; ¿Por qué no se debería compartir un Pool entre procesos?Que es un¿Patrón para implementar paralelismo anidado en Python? Si es posible, mantener una estructura recursiva y no cambiarla por iteración.

from concurrent.futures import ThreadPoolExecutor

def fibonacci(n):
    if n < 2:
        return n
    a = pool.submit(fibonacci, n - 1)
    b = pool.submit(fibonacci, n - 2)
    return a.result() + b.result()

def main():
    global pool

    N = int(10)
    with ThreadPoolExecutor(2**N) as pool:
        print(fibonacci(N))

main()

Java

public class FibTask implements Callable<Integer> {

    public static ExecutorService pool = Executors.newCachedThreadPool();
    int arg;

    public FibTask(int n) {
        this.arg= n;
    }

    @Override
    public Integer call() throws Exception {
        if (this.arg > 2) { 
            Future<Integer> left = pool.submit(new FibTask(arg - 1));
            Future<Integer> right = pool.submit(new FibTask(arg - 2));
            return left.get() + right.get();
        } else {
            return 1;
        }

    } 

  public static void main(String[] args) throws Exception {
      Integer n = 14;
      Callable<Integer> task = new FibTask(n);
      Future<Integer> result =FibTask.pool.submit(task); 
      System.out.println(Integer.toString(result.get()));
      FibTask.pool.shutdown();            
  }    

}

No estoy seguro si importa aquí, pero estoy ignorando la diferencia entre "proceso" y "hilo"; Para mí, ambos significan "procesador virtualizado". Mi entendimiento es que el propósito de un Pool es compartir un "pool" o recursos. Las tareas en ejecución pueden hacer una solicitud al Pool. A medida que las tareas paralelas se completan en otros subprocesos, dichos subprocesos se pueden reclamar y asignar a nuevas tareas. No tiene sentido para mí no permitir compartir el grupo, por lo que cada hilo debe crear una instancia de su propio grupo nuevo, ya que eso parece anular el propósito de un grupo de hilos.