Trouver l'impasse

Lors de la programmation d'une application multithreading, il faut veiller à éviter de bloquer les différents threads lors de l'accès aux ressources partagées. Un blocage se produit lorsqu'un thread tente d'accéder à une ressource qui est verrouillée dans un autre thread en même temps que l'autre thread tente d'accéder à une ressource verrouillée par le premier. C'est le cas simple, mais il peut devenir plus complexe avec des chaînes de ressources plus longues.

Le défi

Vous devez écrire un programme ou une fonction qui peut détecter une situation de blocage possible dans une liste des ressources accessibles par chaque thread. C'est le code-golf, donc la réponse la plus courte en octets l'emporte.

Chaque thread est démarré en même temps, mais après cela, ils peuvent s'exécuter à n'importe quelle combinaison d'entrelacement. S'il y a 2 fils avec 4 actions chacun, il pourrait être exécuté comme (où chaque nombre est une mesure prise par le fil avec cet identifiant) 1,1,1,1,2,2,2,2, 2,2,2,2,1,1,1,1, 1,2,1,2,1,2,1,2, 1,1,2,2,2,2,1,1, ou toute autre combinaison possible.

Contribution

Vous recevrez, via STDIN, le paramètre de fonction ou l'alternative la plus proche, une liste de chaînes. Chaque chaîne sera au format +a -b. Chacune de ces chaînes représente le verrouillage ( +) / déverrouillage ( -) d'une ressource par le thread. Entre chaque fil sera un ---séparateur. Il est garanti qu'un thread ne tentera pas de verrouiller une ressource qu'il a déjà verrouillée et que tous les threads déverrouilleront explicitement toutes les ressources qu'ils ont verrouillées avant de quitter. Voici un exemple pour démontrer:

+a    # Lock resource a
+b    # Lock resource b
-a    # Unlock resource a
-b    # Unlock resource b
---   # Thread separator
+b    # Lock resource b
-b    # Unlock resource b

Production

La sortie doit être fausse si l'entrée ne contient aucune possibilité de blocage et véridique si elle contient une situation de blocage possible. Par exemple:

• true
• false
• 1
• 0

sont toutes des sorties valides, mais tout ce qui est clairement défini comme véridique / falsifié sera accepté.

Exemples

+a
-a
---
+a
-a

Production: false

+a
+b
-b
-a
---
+b
+a
-a
-b

Production true

Blocage lors de la tentative d'acquisition b,arespectivement pour les threads1,2

+a
+b
-a
-b
---
+a
+b
-b
-a

Production false

+a
+b
-b
-a
---
+b
+c
-c
-b
---
+c
+a
-a
-c

Production: true

Blocage dans les threads 1,2,3 lors de la tentative d'acquisition b,c,arespectivement.

http://pastebin.com/vMYRZxtW

Production false

http://pastebin.com/V5MVgNgS

Production true

Blocage dans les threads 1,2,3 lorsque vous essayez d'acquérir b,d,arespectivement.

Bien sûr, cela pourrait devenir beaucoup plus complexe, avec plus de threads, plus de ressources pour chacun, etc., mais je pense que ces tests couvrent les bases.

Prime

Puisqu'il est très triste de trouver des situations de blocage lors de l'écriture d'un programme, il y a un bonus de -8 octets pour les réponses générées :(et :)comme véridiques / fausses respectivement.

Python 2 - 227

S'assure fondamentalement qu'il n'y a pas de boucles de «priorité». Par exemple, dans le deuxième test, le premier thread a une a(b)priorité et le second thread a une b(a)priorité.

Je pensais à réécrire cela en Pyth car je pense que cela fonctionnerait bien avec toutes les opérations itertools, mais la conversion de l'expression régulière prendra un certain travail, donc pour l'instant je publierai ceci et j'essaierai peut-être de le convertir et de publier une autre réponse plus tard.

from itertools import*
import re
f=lambda t:any(re.search(r"(.)((.)\3)+\1",''.join(p))for i in product(*[[m.group(1)+m.group(2)for m in re.finditer(r"(\w).*(\w).*\2.*\1",e,16)]for e in t.split('---')])for p in permutations(i))

Python - 586 539 524 501 485 octets - 8 = 477

Niveaux d'indentation:

1: 1 space
2: 1 tab
3: 1 tab + 1 space
4: 2 tabs

-

import sys
V=set()
t=[[[]]]
for r in sys.stdin:
 r=r.strip()
 if'---'==r:t.append([[]])
 else:v=r[1:];V.add(v);l=t[-1][-1];t[-1].append(l+[v]if'+'==r[0]else filter(lambda x:x!=v,l))
s=lambda l:s(l[1:])+map(lambda x:(l[0],x),l[1:])if 1<len(l)else[]
E=reduce(set.union,map(lambda x:set(sum(map(s,x),[])),t),set())
for v in V:
 k=set();q=[v]
 while 0<len(q):
    u=q.pop(0)
    if u in k:continue
    k.add(u)
    for x,y in E:
     if u==x:
        if y in k:print':(';sys.exit()
        else:q.append(y)
print':)'