¿Cómo realizar múltiples subprocesos en este escenario de problema?

Me gustaría hacer una simulación de un sistema distribuido, en el cual, debería hacer una búsqueda de información (suministros) de forma distribuida (¡paralela si pudiera !!), por ejemplo tengo la siguiente clase:

public class Group{
public int identifier;
public int[] members;
public String name; 
public String[] supplies;
public int[] neighbors;}

Hay muchos grupos, cada uno tiene un nombre y consta de una lista de miembros, vecinos y suministros, cada miembro tiene alguna información y una lista de otros grupos que pueden contener información y suministros pertinentes, etc.

1- Quiero hacer una búsqueda de suministros, Primero: dentro de un grupo, si no encuentro el suministro requerido, debo hacer una búsqueda dentro de todos los grupos que son vecinos de este grupo, creo que hacer esto usando Multi- subprocesos, quiero decir, si la búsqueda falló, debería hacer una búsqueda dentro de todos los demás vecinos al mismo tiempo usando varios subprocesos, cada uno toma en consideración un vecino, si tengo 10 vecinos, entonces se deben crear 10 subprocesos ... .

2- Ahora bien, si quiero comenzar la investigación por primera vez con varios grupos, me refiero a comenzar con 3 o 4 grupos o más, cada uno busca un suministro diferente, o el mismo .... + uno grupo que invoca la búsqueda podría ser un vecino de otro grupo ...

Entonces, mi pregunta es ¿Cómo lograr este escenario usando hilos?

PD Tengo una máquina con un solo procesador con un núcleo, y no me importa el tiempo de ejecución (la sobrecarga), lo único que quiero es simular este problema ...

Gracias por cada respuesta y saludos cordiales.

preguntado el 16 de mayo de 11 a las 17:05

3 Respuestas

Dado que tiene un problema vinculado a la CPU, es probable que la cantidad óptima de subprocesos a utilizar sea la cantidad de núcleos que tiene. Me aseguraría de que cada hilo tenga aproximadamente 100 microsegundos de trabajo o podría encontrar que tiene más sobre la cabeza que trabajo útil. por ejemplo, es posible que la búsqueda de nodos de 10K suponga un trabajo de 100 us. Si no tiene cuidado, una aplicación de subprocesos múltiples puede ser muchas veces más lenta que una de un solo subproceso.

Entonces, encontraría una manera de dividir el trabajo para que tenga entre 1K y 100K nodos para cada hilo y limitar su concurrencia a la cantidad de núcleos que tiene.

contestado el 16 de mayo de 11 a las 21:05

Gracias, pero no me importa un tiempo de ejecución (la sobrecarga), lo único que quiero es simular este problema ... - jojo

Crearía un ExecutorService con Executors y le enviaría tareas para hacer lo que necesita. Usaría un newSingleThreadExecutor () para obtener el mejor rendimiento. - Peter Lawrey

No pude entender el segundo requisito, pero para el primero, aquí hay un enfoque posible. Sin embargo, antes de eso, técnicamente su proceso no está completamente vinculado a la CPU, también está vinculado a la E / S (red). Por lo tanto, no asuma que hacerlo multiproceso proporcionará la aceleración requerida que está buscando. Supongo que su entorno de desarrollo es uni-procesador y un solo núcleo, pero es posible que su entorno de implementación no lo sea.

De vuelta a la sugerencia. Crearía una clase GroupPool que tenga un grupo de subprocesos que puedan buscar información. El número de subprocesos se podrá configurar mediante un parámetro de configuración de tiempo de ejecución. Puede crear una clase de fábrica que lea este parámetro de un archivo de configuración y cree un grupo de objetos ejecutables.

Cada uno de estos objetos representa una conexión con el nodo vecino. [TODO] No mencionó si desea recurrir a los nodos de proveedor, es decir, si no encuentra la información en un nodo de proveedor, ¿desea buscar el proveedor, los proveedores del proveedor, etc.? Si es así, lo hará tiene el problema de la detección de ciclos. Una vez que estos objetos de hilo buscan información y la encuentran, actualizan un semáforo en el objeto de fábrica (es posible que desee mover esto a un objeto separado ya que será un mejor diseño), y también envían la identificación del proveedor (ver, un el objeto tiene sentido)

Puede tener un oyente para este semáforo modificado y tan pronto como cambie el valor, sabrá que encontró su información y obtendrá la identificación del proveedor de ese objeto. Una vez que obtenga su información, puede enviar una notificación al grupo de subprocesos para apagar los objetos ejecutables, ya que ya encontró su información.

En función de si está buscando una respuesta binaria (buscar datos y cualquier proveedor está bien) y si desea recurrir, la complejidad de lo anterior aumentará.

Espero que esto le ayude a intentar diseñar la estructura para su problema.

contestado el 16 de mayo de 11 a las 22:05

No veo ninguna ventaja de rendimiento en el multihilo en una sola máquina con CPU. Esto se debe a que solo se podrá ejecutar 1 subproceso a la vez y habrá tiempo de cambio entre subprocesos, por lo que probablemente llevará más tiempo encontrar un grupo con el recurso deseado.

Personalmente, solo iteraría a través de los vecinos del primer grupo y los verificaría en busca de recursos. Luego, si no se encuentran los recursos, llamaría a la búsqueda en cada uno de los subgrupos, pasando la lista de grupos que ya estaban marcados, para que pueda omitir los grupos que ya han sido marcados. Algo como:

public Group searchForGroupWithResource(Resource resource){
    List<Group> groupsToCheck = new ArrayList<Group>();
    groupsToCheck.add(this);
    int currentIndex = 0;
    while(currentIndex < groupsToCheck.size()){
        Group currentGroup = groupsToCheck.get(currentIndex);
        if(currentGroup.hasResource(resource)){
            return currentGroup;
        }
        groupsToCheck.addAll(currentGroup.getNeighbors(groupsToCheck));
        currentIndex++;
    }
    return null;
}

public List<Group> getNeighbors(List<Group> excludeGroups){
    //Get non-excluded neighbors
    List<Group> returnNeighbors = new ArrayList<Group>();
    for(Group neighbor : neighbors){
        boolean includeGroup = true;
        for(Group excludeGroup : excludeGroups){
            if(excludeGroup.equals(neighbor)){
                includeGroup = false;
                break;
            }
        }
        if(includeGroup){
            returnNeighbors.add(neighbor);
        }
    }
    return returnNeighbors;
}

Nota: Si aún decide optar por el subproceso múltiple, sugeriría un objeto común que almacene información sobre la búsqueda que sea accesible para todos los subprocesos. Esto especificaría los grupos que se marcaron (para que no verifique el mismo grupo dos veces) y si se encontraron los suministros necesarios (para que pueda dejar de verificar los recursos).

contestado el 16 de mayo de 11 a las 23:05

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.