Newsgroup: it.comp.programmare.win32
Titolo: Come sapere se un programma è già in esecuzione?

Come faccio a sapere se il programma che ho lanciato è già in esecuzione
perche' lanciato precedentemente?
Posso avere la lista dei programmi che sono in esecuzione, tipo la lista del
TaskManager?
Mi serve per non poter caricare 2 volte il mio stesso programma.
In pratica dovrei metterlo nelle operazioni pianificate, in modo pero' che
non partano mai piu' di 1 alla volta.
Qualcuno ha un'idea?
Grazie.

Mi serve per non poter caricare 2 volte il mio stesso programma.
Usa un mutex, per esempio.
Pseudo-codice in Delphi:
var
  MyMutex: THandle; 
begin
  MyMutex := CreateMutex(nil, False, 'MYPROGRAM_MUTEX');
  try
    if (GetLastError = ERROR_INVALID_HANDLE) then
    begin
      // errore durante la creazione del mutex !
      // avverto l'utente ed esco...
    end
    else
    if (GetLastError = ERROR_ALREADY_EXISTS) then
    begin
      // un'istanza e` gia` attiva !
      // avverto l'utente ed esco...
    end
    else
    begin 
      // lancio tranquillamente il mio programma
    end;
  finally
    CloseHandle(MyMutex);    
  end;
end.
-- 
Andrea Laforgia
#exclude <windows.h>

 esecuzione perche' lanciato precedentemente?
Usa GlobalAddAtom, GlobalDeleteAtom e GlobalFindAtom.
char SIGNATURE[] = "MyProgram version xx.yy, developed by MyName, ecc...";
WinMain(...)
{
    if (!GlobalFindAtom(SIGNATURE))
    {
        ATOM atom = GlobalAddAtom(SIGNATURE);
        .
        .
        .
        .
        .
        .
        .
        GlobalDeleteAtom(atom);
    }
}
Kiuhnm

 Grazie.
ciao

 pero' che non partano mai piu' di 1 alla volta.
per i fatti miei ho scritto un'utility che permette di fare questa cosa 
con qualsiasi programma. La copi dove vuoi, e poi la chiami così:
once -- <comando>
(il "--" è importante se il comando ha opzioni che iniziano con un "-")
Normalmente, once calcola l'hash MD5 del comando, e come identificatore 
usa quello. Quindi, se cambi qualche opzione del comando, lo puoi anche 
avviare più di una volta. Se non ti piace così passa a once l'argomento 
-i <identificatore>, dove <identificatore> è una stringa a tua scelta - 
in questo modo se passi sempre la stessa stringa a -i, qualsiasi sia il 
comando, once avvierà una sola istanza. Esempio:
once -i blah -- <comando1>
once -i blah -- <comando2>
Anche con due comandi diversi il secondo non verrà eseguito se il primo 
è ancora attivo. Dato che once l'ho pensato piuttosto per link nel menu 
avvio, di default avvia una sola istanza *per schermo*. Ad esempio, nel 
tuo caso, conviene invece usare un lock file o un mutex:
once -pmutex -i <identificatore> -- <comando>
Se vuoi essere sicuro che *assolutamente* una sola istanza possa girare 
anche se ti trovi sotto Terminal Services, usa un mutex globale:
once -pgmutex -i <identificatore> -- <comando>
Se ti interessa te lo spedisco, completo di sorgenti C
-- 
  < 
http://www.reactos.com/
 >  Open source clone of Windows NT. Current
      Don't stand, REACT!      version 0.0.21. C/C++ and ASM developers
                               and beta testers are welcome!

#pragma data_seg()
Questo vale solo se usi il Visual C++.


 wrote in message
news:45WV9.15490$YG2.4...@twister1.libero.it...

FindWindow (......)
Emidio  Marchese

 #exclude <windows.h>
:-):-)

 Questo vale solo se usi il Visual C++.
o qualsiasi compilatore con output COFF (il Borland C++ non lo supporta 
perchè il suo formato non permette di definire segmenti oltre ai CODE e 
DATA predefiniti). Tipo un qualsiasi assembler. Sempre che il linker lo 
supporti :-) ok, Peppi', non è una grande idea :-)


o qualsiasi compilatore con output COFF [...]
Non c'entra l'output COFF (che io sappia, DJGPP/GCC supporta il
formato COFF, ma non ha alcuna direttiva #pragma data_seg).  
Le direttive #pragma, in generale, servono a impartire istruzioni
precise a compilatori precisi, quindi (esattamente allo stesso modo
delle funzioni di lancio dei processi di cui si discuteva in un altro
thread), a priori, la tecnica di usare una particolare direttiva
#pragma non e` trasportabile su altri compilatori.


 
IMHO è preferibile utilizzare un named mutex che funziona nel 100% 
dei casi. Il metodo basato su FindWindow (che pure ho visto 
consigliare spesso) potrebbe non funzionare se due o più istanze del 
programma vengono lanciate quasi contemporaneamente.
Se il codice è stutturato così:
- esegui FindWindow
- se hai trovato una finestra valida termina questa istanza
- Create Window
Rischi che due o più istanze eseguano la FindWindow prima che almeno 
una delle istanze abbia richiamato CreateWindow e, in questo modo, 
tutti saranno convinti di essere l'unica istanza in esecuzione.
Con il mutex questo problema non sussiste.
-- 
Valter Minute
vmi...@inwind.it
 (the reply address of this message is invalid)

 formato COFF, ma non ha alcuna direttiva #pragma data_seg).
intendevo compilatore in senso lato, includendo anche gli assembler. In 
fondo, è una caratteristica del formato eseguibile


fondo, è una caratteristica del formato eseguibile
Io mi sto riferendo all'uso di una particolare direttiva #pragma e
questa direttiva non e` supportata da qualunque "compilatore" supporti
il formato COFF.


 ha scritto nel messaggio
news:45WV9.15490$YG2.4...@twister1.libero.it...


 + di una applicazione alla volta. Spero di non aver detto bufale!
eh eh,non ci siamo,cosi prorpio non va bene ;-)
hPrevInstance in ambienti a 32 bit non serve + a nulla
infatti se ci fai caso è sempre NULL
ciao