Newsgroup: it.comp.java
Titolo: due chiarimenti

1) Non ho mai capito perché le stringhe, pur essendo oggetti, sono trattate
in modo diverso dagli altri, ad esempio non è necessario new per creare una
nuova istanza. Sembra una mancanza di rigore nella definizione del
linguaggio.
2) per stoppare un thread in un semplice applet, nel solito libro Apogeo si
legge:
public void run() {
    while (esecutore == Thread.currentThread()) {   // ???
        // tutto il codice di run()
    }
}
public void stop() {
    esecutore = null
}
fuori dai metodi era dichiarato: Thread esecutore;
non capisco while(esecutore == Thread.currentThread()). Non è forse
equivalente a while(esecutore != null) ?
Non ho trovato risposta neppure su Thinking in Java...:-(
Ringrazio per le risposte,
maS

 Non ho trovato risposta neppure su Thinking in Java...:-(
Mah, mi sembra che hai ragione e un controllo while(esecutore != null) mi
sembra decisamente molto più pulito. Sarà qualche trucco della Apogeo... non
sempre gli esempi
citati nei suoi testi sono comprensibili.

Innanzitutto grazie per l'attenzione.
Incuriosito, ho cercato qua e la riguardo a   while (exe ==
Thread.currentThread())
ho trovato (mi pare nel tutorial della Sun):
  // If exe refers to the same thread as the currently executing thread,
  // the thread continues executing. If, on the other hand, exe is null,
  // the thread exits. If exe refers to another thread, then a race
  // condition has occurred: start has been called so soon after stop
  // (or this thread has taken such a long time in its loop) that start
  // has created another thread before this thread reached the top of
  // its while loop. Whatever the cause of the race condition, this thread
  // should exit.
Ecco, qualche barlume l'ho colto, ma se qualcuno mi spiega chiaramente
quale è l'alto motivo per cui si esce dal ciclo (a parte il fatto che exe
diventi null)....
ciao
maS

definizione del linguaggio.
E' semplicemente una scorciatoia sintattica. "xxx" denota new String("xxx"), 
consistentemente. I motivi dovrebbero essere ovvi: le Stringhe sono tra gli 
oggetti piu' usati.
-- 
God is Real, unless declared Integer.
ObjectZone - 
http://space.tin.it/computer/csadun

Non sei obbligato a mettere il new, ma il compilatore non ti vieta di
metterlo. Personalmente trovo di maggiore leggibilità scrivere:
String a = new String( "ciao");
in quanto riconosci a priori che stai lavorando su un oggetto dinamico.
Infatti non è raro che un principiante si dimentichi di considerare le
stringhe come oggetti.
Cmq ringraziamo che Java supporti le stringhe, a differenza di altri
linguaggi.
Distinti saluti.
Francesco Agostino Fassi.

 Thread.currentThread())
Ammetto che avevo lasciato questa domanda marcata ma non avevo avuto tempo di
ragionarci un po' su, ma la soluzione è in effetti molto semplice.
Ti è mai capitato di vedere persone che fanno doppio click su un link o un
bottone in quanto abituate a fare sempre e solo doppio click da Gestione
Risorse? Ecco quindi la soluzione: questo codice ti assicura che in ogni
momento sia in esecuzione un solo thread che esegue il metodo run.
Esempio:
L'utente preme su un bottone che lancia il thread:
esecutore è null, esecutore prende il riferimento del nuovo thread A che
parte. (while esecutore == Thread.currentThread() è vero)
L'utente ripreme su un bottone che lancia il thread:
esecutore contiene il riferimento al thread A. Il thread B parte, esecutore
prende il riferimento a B. (while esecutore == Thread.currentThread() è vero
per B, ma non è più vero per A). Il thread A si accorge che un altro thread è
partito, e gli lascia il posto, uscendo dal ciclo while e terminando.
Tutto qui. In modo simile puoi verificare che un thread non sia già presente,
semplicemente controllando che esecutore sia null prima di chiamare start su
si un nuovo thread.
Ciao,
 Stefano
----------
"X WindowSSS, teSSSoro mio... lo odieremo per SSSempre"
Bill Gollum
----------