[JAVA] zaustavitev niti (threadov)

Kako pravilno ustavim/ubijem nit v javi. Metoda stop je kolkr gledam neprimerna in je odsvetovana.
Je torej torej uredu če prekinem neskončno zanko ki teče v niti in potem odstranim referenco na to nit pa jo bo potem že GC spucal ?
Kaj pa join metoda, mi kdo lahko po kmečko razloži kaj le ta nardi.

Hvala

http://java.sun.com/j2se/1.4.2/docs/guide/misc/threadPrimitiveDeprecation.html -> What should I use instead of Thread.stop?

Ker se v tvoji kodi res ne znajdem (ne da se mi ) ti prilepim en preprost serverček, mogoče pa ti pride prav. Za vsako vtičnico ustvari novo nit in jo po prejemu ukaza exit tudi lepo zapre. Edini problem predstavlja glavna nit, ki je v bistvu neskončna zanka in se je ne da lepo zaustavit (ServerSocket.accept() blokira nit v kateri se izvaja, tako da preverjanje odpade ). To lahko rešiš tako da server poženeš v nekem preprostem GUI-ju, kot daemon thread - torej nit kjer izvajaš ServerSocket.accept() naj bo daemon. Ko boš zaprl GUI, se bo zaustavila tudi ta nit.

Na server se priključi s telnetom

package simpleserver;

import java.io.IOException;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Scanner;

/**
 *
 */
public class SimpleServer {
    
    // seznam handlerjev vtičnic
    private ArrayList<ClientHandler> handlerji = new ArrayList<ClientHandler>();
    /*
     * Konstruktor
     */
    public SimpleServer() throws IOException {
        
        try {
            ServerSocket ss = new ServerSocket(4999);
            int id = 1;
            while (true) {
                Socket s = ss.accept();
                ClientHandler handler = new ClientHandler(s, id);
                new Thread(handler).start();
                synchronized (handlerji) {
                    handlerji.add(handler);
                }
                poslji(id + " se je prikljucil na server.", handler);
                id++;
            }
        } catch (IOException ex) {
            throw ex;
        }
    }
    /**
     * poslje sporocilo v vse vtičnice, razen pošiljateljeve
     */
    private synchronized void poslji(String sporocilo, ClientHandler posiljatelj) {
        
        for (ClientHandler hand : handlerji) {
            if (hand == posiljatelj)
                continue;
            hand.pisi(sporocilo);
        }
    }
    
    /**
     * Razred ClientHandler skrbi za branje iz vtičnice in razpošiljanje prebranega
     * ostalim handlerjem
     */
    class ClientHandler implements Runnable {
        
        private final Socket vticnica;
        private final int id;
        private PrintWriter pisec;
        
        /*
         * Konstruktor
         */
        public ClientHandler(Socket s, int id) throws IOException {
            
            this.vticnica = s;
            this.id = id;
            pisec = new PrintWriter(vticnica.getOutputStream(), true);
        }
        
        public void run() {
            
            try {
                pisi("Pozdravljen/a! Za izhod vpisi ukaz EXIT.\n");
                Scanner bralec = new Scanner(vticnica.getInputStream());
                try {
                    //System.out.println("Zaganjam " + this.id + "-o vtičnico");
                    boolean zakljuci = false;
                    // dokler skozi vtičnico ne dobimo ukaza exit, beremo vrstice
                    // teksta, ki ga razpošljemo vsem ostalim vtičnicam.
                    while (!zakljuci && bralec.hasNextLine()) {
                        
                        String sporocilo = bralec.nextLine();
                        if (sporocilo.trim().equalsIgnoreCase("exit")) {
                            zakljuci = true;
                            sporocilo = id + " je zaprl povezavo.";
                        }
                        poslji(id + ": " + sporocilo, this);
                    }
                } finally {
                    // handlerja izločimo iz seznama in zapremo resurse
                    synchronized (handlerji) {
                        handlerji.remove(this);
                    }
                    bralec.close();
                    pisec.close();
                    vticnica.close();
                }
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
        /**
         * zapiše sporočilo v vtičnico
         */
        protected void pisi(String sporocilo) {
            
            pisec.println(sporocilo);
        }
    }
    
    public static void main(String[] args) {
        
        try {
            new SimpleServer();
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }
    
}

morbo: Če ne želiš da bi ti ServerSocket blokiral, ima Java non-blocking I/O že implementiran v java.nio paketu.

Spovnil sem se da k zgornjemu serverju spada zraven tudi client, ker sem nekoč jst to že delal...

l0g1t3ch, tvoje koda se mi zdi way to much zakomplicirana. Bom poiskal, pa priflikam...

Spet jaz

Zanima me kako narediti java program ki bi poganjal več takih serverjev kot je zgoraj. Recimo da en server predstavlja en kanal kot kanal na ircu. Recimo program izvaja vsak gornji server kot nit.

Sam sem se nekaj igral z svojo verzijo chat serverja in stvar približno deluje. Požene dve niti objekta Room ki predstavljata vsaka svoj kanal in zaenkrat delujeta vsaka na svojem portu.
Problem je samo v tem da kar napišem v enem klientu ki je povezan na prvo nit(je v prvi sobi) dobi tudi drugi klient ki je povezan na drugo nit(je v drugi sobi)

Problem je verjetno v temle

private static Vector<ClientHandler> activeThreads; 

To je seznam vseh clientHandlerjev torej niti ki v končni fazi komunicirajo z clienti. Definiran je znotraj razreda Room in je mišljeno da ima do tega seznama dostop samo tisti ki se poveže na določeno sobo.

V praksi naj bi zgledal tkole, če poženeš Server na portu 8000 potem naj bi prva nit Room poslušala na portu 8000 druga nit pa na portu 8001
In uporabniki ki se povežejo prek porta 8000 lahko komunicirajo samo med sabo torej uporabniki povezani prek porta 8001 ne dobivajo tega kar pišejo.

Ampak meni gre to vsepovprek. Kdorkoli kaj napiše dobijo vsi. Pa nevem zakaj sej je seznam definiran kot privatni znotrej tistega razreda, ki predstavlja potem sobo

import java.util.*;
import java.io.*;
import java.net.*; 

public class Server 
{
	public static void main(String[] args) 
	{
		if (args.length != 1)
		{
			System.out.println("Usage: java Server port");
			System.exit(1);
		}	
		else
		{
			Room soba = new Room( Integer.parseInt(args[0]), "soba" );
			soba.start();
			
			Room soba2 = new Room( Integer.parseInt(args[0])+1 , "soba2" );
			soba2.start();
			
			
		}
		

	}
	
}

class Room extends Thread 
{
	private static Vector<ClientHandler> activeThreads; 
	protected int i;
	protected int port; 
	
	public Room(int p, String name)
	{
		System.out.println("Chat server started."); 
		activeThreads = new Vector<ClientHandler>(); 
		i = 1; 
		port = p;
	}

	public static void removeThread( ClientHandler nit )
	{
		activeThreads.removeElement(nit); 	
	
	}
	
	public static Iterator getIterator()
	{
	    return activeThreads.iterator(); 
	}
	
	
	public void run()		
	{
			try 
			{
				ServerSocket s = new ServerSocket( port ); 
				while(true) 
				{
					Socket incoming = s.accept(); 
					System.out.println("Spawning client thread " + i);
					ClientHandler newThread = new ClientHandler(incoming, i); 
					activeThreads.addElement(newThread); 
					newThread.start(); 
					i++; 
				}
			} 
			catch (NumberFormatException nfe) 
			{
				System.out.println("Parse error: " + nfe); 
			}
			catch (Exception e) 
			{
				System.out.println("Error: " + e); 
			}
	}
}

class ClientHandler extends Thread
{
	protected Socket incoming;  
	protected int id; 
	protected String nick;
	protected BufferedReader in; 
	protected PrintWriter out;
 
	//konstruktor
	public ClientHandler(Socket incoming, int id) 
	{
		this.incoming = incoming; 
		this.id = id; 
		try 
		{
			in = new BufferedReader(new InputStreamReader(incoming.getInputStream())); 	    
			out = new PrintWriter(new OutputStreamWriter(incoming.getOutputStream())); 	 

			putMessage("Hello! This is simple java chat server. Enter \"EXIT\" to end chat.");   
			putMessage("Enter your nickname: "); 
			nick = in.readLine(); 
			putMessage("Welcome " + nick + ", now you can start chating");
			putMessage("****************************************");
			
		} 
		catch (IOException ioe) 
		{
			System.out.println("IO Error: " + ioe); 
		}
	}

	public synchronized void putMessage(String msg) 
	{
		if(out != null) //preverimo če izhodni tok obstaja, ker metodi ne mečeta izjem
		{
			out.println(msg); 
			out.flush();
		}
	}

	public void run() 
	{
		System.out.println("Client handler " + id + " started."); 
		if (in != null && out != null) 
		{		
			try 
			{
				while(true) 
				{
					String str = in.readLine(); 
					if (str == null) 
					{
						break; 
					} 
					else 
				    {
						System.out.println("Received (" + id + "): " + str);

						if (str.trim().equals("EXIT")) 
						{
							break; 
						} 	
						else 
						{
							Iterator iter = Room.getIterator();
							while  (iter.hasNext()) 
							{
								ClientHandler t = (ClientHandler)iter.next(); 
								if (t != this)
								{
									t.putMessage(nick + ": " + str); 
								}
							}
						}
					}
				}
				incoming.close(); 
			//	Room.activeThreads.removeElement(this);
				Room.removeThread(this);
			} 
			catch (IOException ioe) 
			{
				System.out.println("IOE Error: " + ioe); 
			}
		}
		System.out.println("Client thread " + id + " stopped."); 
		return;
	}	
}

Vem da ta pristop ni najbolši in sem tudi sam premišljal o pristopu kot ga omenjaš ti. Vendar ko sm že neki naredu me vseeno zanima kako to pripravit do delovanja oz kaj delam narobe da vsi vidijo vse.

eh ja kera bedna napaka
Maš drugače kak link kje so dobr razloženi ti access modifier-ji oz če se teb da to mal po kmečk povedat

Aha no jest sm mislu d private prepreč d bi drugi dostopal do tega. Hvala za pojasnilo

Seveda teži, saj imaš v Room dve statični metodi, ki kličeta 'activeThreads' (getIterator() in removeThread()) - iz teh metod ne moreš klicat nestatičnih spremenljivk, saj so slednje spremenljivke stanja (instance), statične metode pa ne vedo nič o instancah predmeta.

Pobriši static in razredu ClientHandler pošlji referenco na Room, ki ga je ustvarila. Potem te metode kliči s pomočjo reference.

metoda run() ni statična - saj ni definirana kot taka!

Glej, čisto preprosto je:

najprej pobriši static metodam in seznamu, ki sem jih omenil. Potem konstruktorju handlerja dodaj nov parameter tipa Room, shrani ga v private spremenljivko. Ob stvarjenju novih predmetov handler, pošlji konstruktorju referenco 'this' (torej referenco na Room, ki ga je ustvarila). Metodi getIterator() in removeThread() lahko zdaj kličeš preko te reference in ne statično.

Statične metode lahko kličeš kar direktno, brez predmetne spremenljivke:

 Room.getIterator() 

Medtem ko za ostale rabiš objekt:

Room soba = new Room()
soba.getIterator()

Ti moraš vsakemu handlerju poslat sklic na objekt Room - na isti način kot mu pošlješ Socket in id

ps:
protected modifier je namenjen dedovanju - če hočeš paketni dostop najavi predmet brez modifierja

To pa je zato ker si do spremenljivke še vedno dostopal kot da bi bila statična