Modification script shell

Bonjour,
En ajoutant un sleep ça fonctionne avec ./sr.sh x & ./sr.sh y & ./sr.sh z . . . .. :

for i in 1 2 3 
do 
        if [ "$1" = "x" ] 
        then 
                FILE=$1.sync 
                echo > $FILE 
        fi 
while [ ! -f $FILE ] 
do 
        sleep 1 
done 

echo $1 : $i 
rm -f $FILE 
sleep 0.01 
done 

Edit: petite modification du sleep que j'ai rajouté, viens juste d'apprendre qu'on peut utiliser moins d'une seconde
Edit²: Ouais non en fait le sleep plus il est long mieux ça fonctionnera, quand je test avec la même valeur 0.01 et que j'ajoute une commande supplémentaire ça déraille, en augmentant le sleep ça fix le problème

salut HXYP, non j'avais déjà essayé de rajouter un sleep exactement au même endroit que toi mais ça ne fonctionne pas, en fait a fonctionne à 90% mais pas à 100% car rien n'empêche à un processus d'afficher 2 fois x :1 x : 2, essaye tu verras :-).
Donc le fait de rajouter un sleep à mon grand désarroi ne change rien...

Re, je pense avoir trouvé un début de réponse ou peut-être la réponse ? en utilisant le C car on peut exécuter des commandes avec et gérer l'ordre. Alors voici un petit code en c :
en commentaire j'ai mis la référence du bout de code que j'ai pompé et modifié pour qu'on puisse faire une boucle en fonction des paramètres... j'explique un peu plus bas

//https://stackoverflow.com/questions/646241/c-run-a-system-command-and-get-output
#include <stdio.h>
#include <stdlib.h>

int main(int argc,char *argv[])
  {
    FILE *fp;
    char path[1035];
    int i, a, x=atoi(argv[1]);
    for(a=0;a<x;a++)
      {
        for(i=2;i<argc;i++)
          {
            fp=popen(argv[i],"r");
            if(fp==NULL)
              {
                fprintf(stderr,"Erreur popen()\n");
                exit(1);
              }
            while(fgets(path,sizeof(path),fp) != NULL)
              {
                printf("%s",path);
              }
            pclose(fp);
          }
      }
    return 0;
  }

Pour compiler tu peux faire :
gcc -Wall -o prog prog.c

Pour l'utiliser :
./prog 3 "echo x" "echo y"

le premier paramètre le 3 pour l'exemple c'est le nombre de répétitions : les commandes qui suivent seront alors exécutées à la suite le nombre de fois indiqué dans le premier param!

le résultat :
x
y
x
y
x
y

Faut pas oublier de mettre les commandes entre des guillemets

l'exercice est uniquement à faire en sh lol, j'ai tenté de poser des verrous avec lockfile mais ça n'a pas marché, si jamais un connaisseur du sh passe par là qu'il se manifeste car tout le monde se casse les dents dessus lol.
Merci Hxyp pour ces tentatives :-(

Salut.
en fait, c'est assez simple en modifiant le script pour vérifier les pichier .sync

for i in 1 2 3 
do 

  FILE=$1.sync 
  echo $i> $FILE 
  
  echo $1 : $i 
  rm -f $FILE 
  test=0
  while $test
  do :
      for a in $(ls *.sync)
      do :
          if  [ $i <= $(cat $a) ]
             test=1
          fi
      done
      sleep 1
  done

done

Je n'ai pas testé, mais tu vois l'idée ? tu stockes dans le fichier le nombre courant, tant que ce nombre est supérieur à ceux des autres scripts, tu attends. ça garantie d'avoir 1 puis 2 puis 3.
si tu veux aficher x y z dans cet ordre, c'est faisable avec un classement par ordre alphabétique des fichier : tant qu'il y a une lettre avant le script en court ne rien faire.
Si l'affichage doit se faire selon l'ordre de lancement des scripts, je pense que c'est impossible à réaliser.

je vais tester, en fait l'exercice c'est ça, soit le script suivant:

for i in 1 2 3
do
echo $1 : $i
done

modifier ce script pour que lors de la commande ./script.sh x & ./script.sh y & on ait un affichage alternatif parfait:

x: 1
y: 1
x: 2
y: 2
x: 3
y: 3

alors j'ai testé ton script et ton algorithme me semble pas mal, je voulais faire ça au début mais bon, ton script m'affiche:

y : 1
x : 1

et ensuite un défilement du message ls: ne peut accéder *.sync: Aucun fichier ou dossier de ce type. impossible à arrêter meme avec un ctrl+c ...
Même en déplaçant l'instruction rm -f $FILE après la boucle while ça ne change rien, bizarre.

alors regarde j'ai modifié le script mais ça marche tjs pas et d'ailleurs je trouve bizarre qu'on doive vérifier que le fichier .sync existe puisque de toute manière il existe avant d'entrer dans la boucle si on met le rm -f $FILE à la fin, voici le script:

#! /bin/bash

for i in 1 2 3 
do 

  FILE=$1.sync 
  echo $i> $FILE 
  echo $1 : $i 
  test=0
  while [ $test ]
  do
     if [ -f $FILE ]
     then
      for x in 'ls *.sync'
      do
          if  [ $i <= 'cat $x' ]
	  then
             test=1
          fi
      done
      else
      sleep 1
      fi
  done
rm -f $FILE
done

c'est cette ligne if [ $i <= 'cat $x' ] qui pose problème même avec ton script...

non ya rien à faire, je me demande finalement si l'idée est bonne car rien n'empêche ton algorithme d'afficher:

a: 1
a: 2
...

bref ça ne fonctionne tjs pas et on est plusieurs à y avoir réfléchi c'est incroyable qu'un exercice si court nous demande tant de reflexion ça doit pas etre sorcier pourtant....

Personne connait un expert en sh? lol

là c'est pas de l'expertise en sh qu'il faut, c'est un bon algoritmhe.
Je me suis d'ailleur rendu compte que mon algo été mauvais.
Je regarde si un seul fichier vaut au moins $i, alors qu'il faudrait tout les regardé.
C'est tout con, mais j'ai un peu de mal à l'écrire cet algo.

#! /bin/bash

FILE=$1.sync 
touch  $FILE
# on attend un peu que tout les scripts créent leur fichier
sleep 10

#on compte le nombre de script
nbs=$(ls *.sync|wc -l)

for i in 1 2 3 
do 
  echo $i> $FILE 
  echo $1 : $i 
  test=0
#tant que tout les scripts n'ont pas atteints la valeur en cour
  while [ $test -lt $nbs ]
  do
      test=0
      for x in 'ls *.sync'
      do
          if  [ $i <= 'cat $x' ]
	  then
             (( test++ )
          fi
      done
      sleep 1
  done
#mieu vaut ecraser que supprimer
#rm -f $FILE
done

non ça ne marche pas, et cela me semble bien trop volumineux pour ce qui est demandé, je crois que je vais abandonné cet exercice tant pis, merci pour tes réflexions c'est sympa.

sinon à tout hasard dans mon script de départ:

for i in 1 2 3 
do 

if [ $1 = "x" ] 
then 
 FILE=$1.sync 
 echo > $FILE 
fi 

while [ ! -f $FILE ] 
do 
sleep 1 
done 

echo $1 : $i 
rm -f $FILE 
done

as tu une petite idée pour juste forcer le premier affichage à être x : 1 ?

Salut,

$ cat foo.sh
#! /bin/bash

#set -xv

for i in 1 2 3
do
        echo $1 : $i
        sleep 1
done

$ ./foo.sh x& ./foo.sh y
x : 1
[1] 25503
y : 1
x : 2
y : 2
x : 3
y : 3
[1]+  Done                    ./foo.sh x
$

A part le PID du job en arrière-plan qui vient s'intercaler, le résultat me semble bon, non ?

non zipe ta solution marche pas je l'avais déjà essayé tout au début, si tu fais 10 essais tu verras que à un moment tu auras 2 x ou 2 y qui se suivent.

voici la preuve:

image x : 1 s'affiche, tu commutes donc y : 1 s'affiche ok? mais rien n'empêche le processus y de continuer par la suite...il y a d'autres commutations aléatoires produites par l'ordonnanceur.

Donc malheureusement je suis pas le seul à bloquer sur ce petit exercice...

zipe tu es vraiment chanceux mais je t'assure que ton script ne fonctionne pas je l'ai testé des dizaines de fois et ya tjs une erreur tôt ou tard, j'ai donné la preuve théorique il me semble...
crois moi j'aurais aimé que tu aies raison :'(

alors mon ami zipe voici le preuve que tu es chanceux et je te conseille tout de suite d'aller t'acheter un billet de loto, j'ai testé ton script donc celui ci:

#! /bin/bash 

for i in 1 2 3 
do 
        echo $1 : $i 
        sleep 1 
done

et voici ce que j'ai dans le shell, observe bien l'erreur arrive à la fin :-)

-VirtualBox:~/TEST$ ./toto.sh a & ./toto.sh b & 
[1] 1884 
[2] 1885 
-VirtualBox:~/TEST$ b : 1 
a : 1 
b : 2 
a : 2 
b : 3 
a : 3 

[1]-  Done                    ./toto.sh a 
[2]+  Done                    ./toto.sh b 
-VirtualBox:~/TEST$ ./toto.sh a & ./toto.sh b & 
[1] 1892 
[2] 1893 
-VirtualBox:~/TEST$ a : 1 
b : 1 
a : 2 
b : 2 
a : 3 
b : 3 

[1]-  Done                    ./toto.sh a 
[2]+  Done                    ./toto.sh b 
-VirtualBox:~/TEST$ ./toto.sh a & ./toto.sh b & 
[1] 1900 
[2] 1901 
-VirtualBox:~/TEST$ b : 1 
a : 1 
b : 2 
a : 2 
b : 3 
a : 3 

[1]-  Done                    ./toto.sh a 
[2]+  Done                    ./toto.sh b 
-VirtualBox:~/TEST$ ./toto.sh a & ./toto.sh b & 
[1] 1908 
[2] 1909 
-VirtualBox:~/TEST$ b : 1 
a : 1 
b : 2 
a : 2 
b : 3 
a : 3 

[1]-  Done                    ./toto.sh a 
[2]+  Done                    ./toto.sh b 
-VirtualBox:~/TEST$ ./toto.sh a & ./toto.sh b & 
[1] 1916 
[2] 1917 
-VirtualBox:~/TEST$ a : 1 
b : 1 
a : 2 
b : 2 
a : 3 
b : 3 

[1]-  Done                    ./toto.sh a 
[2]+  Done                    ./toto.sh b 
-VirtualBox:~/TEST$ ./toto.sh a & ./toto.sh b & 
[1] 1924 
[2] 1925 
-VirtualBox:~/TEST$ b : 1 
a : 1 
b : 2 
a : 2 
b : 3 
a : 3 

[1]-  Done                    ./toto.sh a 
[2]+  Done                    ./toto.sh b 
-VirtualBox:~/TEST$ ./toto.sh a & ./toto.sh b & 
[1] 1932 
[2] 1933 
-VirtualBox:~/TEST$ b : 1 
a : 1 
b : 2 
a : 2 
b : 3 
a : 3 

[1]-  Done                    ./toto.sh a 
[2]+  Done                    ./toto.sh b 
-VirtualBox:~/TEST$ ./toto.sh a & ./toto.sh b & 
[1] 1940 
[2] 1941 
-VirtualBox:~/TEST$ a : 1 
b : 1 
a : 2 
b : 2 
b : 3 
a : 3 

Tiens essaie ça :

#! /bin/bash

#set -xv

for i in {1..50}
do
        while :
        do
                if [ -e lock.tmp ]
                then continue
                else
                        echo "$1 : $i"
                        touch lock.tmp
                        sleep 1
                        rm -f lock.tmp
                        break
                fi
        done
done

je ne comprends pas ton while : (jamais vu) et je n'ai pas encore vu l'instruction lock, les seules choses dont j'ai le droit c'est le lockfile et un fichier de synchronisation, on ma dit que c'était ça la clef..

j'ai testé le script et échec du premier coup lol, c'est pas évident je sais...