2017-06-21 3 views
0

bisuness LogicFamine des acteurs Akka qui participent à un processus de séquence

Nous avons la logique métier suivante pour accomplir:

1 million de fois faire:

  1. télécharger le fichier dans l'index i
  2. décompressez le fichier
  3. extraire quelques informations du fichier
  4. supprimer le fichier

solution actuelle Akka

La solution Akka que nous avons à l'heure actuelle crée 1 million d'acteurs qui sont responsables d'un fichier à télécharger et une fois qu'ils ont fini, ils créent un acteur prendre soin des étapes 2,3,4.

Le problème

Une fois que nous courons le processus, nous avons rencontré la situation où l'Akka donne la priorité aux acteurs de téléchargement, et le reste des acteurs sont Beeing en mode famine.

Nous savons que le disque de la machine est plein parce que les acteurs de téléchargement téléchargent constamment, mais les autres acteurs n'ont pas la chance de scanner et de supprimer les fichiers.

Questions

  1. Y at-il un moyen de forcer Akka ne pas mourir de faim les acteurs en bas de la chaîne des acteurs?
  2. est-il un moyen de dire à un acteur de téléchargement d'attendre jusqu'à ce qu'il obtenir une certaine notification qu'il puisse continuer (par exemple, pas plus de 1000 fichiers parallèle dans le disque)

Merci.

+0

Quant à la question 2: Utiliser seulement 1000 acteurs, qui sont responsables de toutes les étapes -> 1000 fichiers au maximum sur le disque, pas de famine possible, car un acteur est responsable de la chaîne entière de pas.Vous pouvez utiliser une file d'attente avec tous les fichiers à télécharger, afin que les 1000 acteurs puissent demander un nouveau fichier, une fois qu'ils ont terminé le leur. – thwiegan

+0

1000000 acteurs en téléchargeant des fichiers 1000000 simultanément est une absurdité. Un seul thread ferait ce travail beaucoup plus rapidement. Les étapes 2 à 4 doivent être combinées dans un seul travail et soumises à un pool de threads de taille availableProcessors + 1. –

Répondre

0

Utilisez différents répartiteurs pour les deux types d'acteurs:

Dans votre configuration, vous pouvez définir un répartiteur séparé comme (par exemple):

my-dispatcher { 
    type = Dispatcher 
    executor = "thread-pool-executor" 
    thread-pool-executor { 
    fixed-pool-size = 32 
    } 
    throughput = 100 
} 

Et puis vous pouvez affecter à un acteur spécifique à la création:

val myActor = context.actorOf(Props[MyActor].withDispatcher("my-dispatcher"), "myactor1") 

Les répartiteurs sont, en fait, des pools d'unités d'exécution. Séparer les deux garantit que les opérations de blocage ne lâchent pas l'autre. Cette approche, en général, est appelée en vrac-, parce que l'idée est que si une partie de l'application échoue, le reste reste sensible.

Pour plus d'informations, voir the documentation