Pourquoi le thread client est-il détruit après une seule exécution? Java TCP sockets

Question

Je souhaite que ma classe client exécute un thread qui envoie des informations String (ordre) au serveur en continu toutes les 5 s. Mais à la place, le fil est détruit après l'envoi du premier ordre. Je ne sais pas pourquoi et comment l'arrêter, quelqu'un peut-il m'aider?

sous le code;

public class Cashier implements Runnable 
{ 
    private static final int MAX_DELAY = 5000; 
    static OrderList orderList; 
    static Socket socket; 
    static PrintWriter out = null; 
    static BufferedReader in = null; 

    int orderNumber = 0;  
    public String order, strorderNumber; 

    public static void main(String[] args){ 


     Cashier newCashier = new Cashier(); 
     Thread cashierThread = new Thread(newCashier); 
     cashierThread.setName("Olaf"); 
     cashierThread.setDaemon(false); 
     cashierThread.start(); 

     try { 
      socket = new Socket("127.0.0.1", 4444); 
      in = new BufferedReader(new InputStreamReader(socket.getInputStream())); 
      out = new PrintWriter(socket.getOutputStream(), true); 

     } catch (UnknownHostException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } catch (IOException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } 
    } 

    public void run() 
    { 
      try{ 
       Date now = new Date(); 
       Format fTime = new SimpleDateFormat("hh:mm:ss a"); 
       order = ("Order made by " + Thread.currentThread().getName()+ " at " + fTime.format(now)+ "\n"); 

       out.print(order); 

       Random randomNumber = new Random(); 
       Thread.sleep(randomNumber.nextInt(MAX_DELAY)); 
       } catch (InterruptedException exception){  
        System.out.println("Olafs interrupted exception"); 
    } 

    } 
} 

Answer 1

La méthode run pour votre classe ne contient pas une boucle, il fera ce qu'il doit faire une fois puis tomber le fond, le fil fin effectivement.

Si vous voulez faire fonctionner en permanence, vous aurez besoin de quelque chose comme:

public void run() { 
    boolean keepGoing = true; 
    while (keepGoing) { 
     try { 
      Date now = new Date(); 
      Format fTime = new SimpleDateFormat("hh:mm:ss a"); 
      order = "Order made by " + Thread.currentThread().getName() 
       + " at " + fTime.format(now)+ "\n"; 

      out.print(order); 

      Random randomNumber = new Random(); 
      Thread.sleep(randomNumber.nextInt(MAX_DELAY)); 
     } catch (InterruptedException exception){  
      System.out.println("Olafs interrupted exception"); 
      keepGoing = false; 
     } 
    } 
} 

Answer 2

Hmm .. il n'y a pas de boucle ce que-si-jamais effectuer l'opération d'intervalle de 5 minutes, ou suis-je manque quelque chose?

Answer 3

@paxdiablo vous a donné une solution à votre problème. La réponse à votre question "pourquoi" est dans la façon dont l'API Thread fonctionne; spécifiquement la méthode Thread.start(). Le javadoc dit ceci:

public void start()

Causes ce fil pour commencer l'exécution; la machine virtuelle Java appelle la méthode d'exécution de ce thread.

Le résultat est que deux threads s'exécutent simultanément: le thread en cours (qui revient de l'appel à la méthode start) et l'autre thread (qui exécute sa méthode d'exécution).

Il n'est jamais légal de démarrer un thread plus d'une fois. En particulier, un thread peut ne pas être redémarré une fois l'exécution terminée.

Cela dit qu'un thread est lancé en appelant la méthode start, qui appelle la méthode run du fil une fois. Cela à son tour appelle la méthode run du Runnable que vous avez fourni en tant qu'argument de constructeur ... une fois. (Si vous deviez étendre la classe Thread, et remplacer la méthode Thread.run(), cette deuxième étape serait généralement pas le cas. Mais c'est une question secondaire.)

Lorsque la méthode renvoie Runnable.run(), la méthode renvoie Thread.run() et qui est-ce. Le thread se termine, sa pile est emportée et vous ne pouvez plus le redémarrer. Tout ce que vous pouvez faire est d'examiner le peu de reste de l'état du fil via l'objet Thread.