# NetScanner arbeitet trotz Threads langsam



## CyD (9. Nov 2007)

Obwohl alles in Thread läuft werden die Threads 
nicht parallel ausgeführt, sondern nacheinander. 
Der ganze Scannvorgang zieht sich so von ein 
paar Sekunden auf mehrere Stunden!


```
package de.cyd.subnetscan;

import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.util.Vector;

/**
 * 

Title: SubNetzScanner</p>
 * 
 * 

Description: Durchsucht die PCs eines Subnetzes nach einem gewählten Port.</p>
 *
 * 

Lizenz: Steht unter der GPLv2
 *
 * 

Copyright: Copyright (c) 2007</p>
 *
 * 

Company: Sebastian Grosch </p>
 * 
 * @author Sebastian "CyD" Grosch
 * @version 0.0 Start 2007-11-06
 * @version 1.0 Erstversion 2007-11-09
 */
public class Subnetscan {


	/**
	 * main Methode zum Testen des Scanners
	 * @param args
	 */
	public static void main(String[] args) {
		int port = 55200;
		int millis = 5000;
		new Subnetscan(port, millis).getIpList();
		
	}
	
	
	private String subnet; // bspw. "192.168.1."
	private int port;
	
//	private int ownNumber = 0; // Letzte Ziffer der IP, um nicht den Localhost zu scannen.
	
	/**
	 * Konstruktor setzt den Port, auf welchem gescannt werden soll.
	 * 
	 * @param port int
	 */
	public Subnetscan(int port, int millis) {
		System.out.println("Start Subnetscan");
		
		this.port = port; // Standardport
		
		this.subnet = this.getSubnet();	
		System.out.println(this.subnet);
		
	}


	/**
	 * Ermittelt die eigene IP-Adresse und filtert die letzte Zahl heraus.
	 * @return String
	 */
	private String getSubnet() {
		String ip;	// IP
		String mask = ""; // return wert. bspw "192.168.1."
		String ownNumber = ""; // Eigene IP Ziffer
		try {
			ip = InetAddress.getLocalHost().getHostAddress().toString();
			
			int countDots = 0;
			for (int i = 0; i < ip.length(); i++) {

				if(countDots != 3) {	// 3. Punkt erreicht?
					if(Character.isDigit(ip.charAt(i))) {
						mask = mask + ip.charAt(i);
					} else {
						countDots++;
						mask = mask + ".";
					}
				} else {
					ownNumber = ownNumber + ip.charAt(i);
				}
				
			}
//			this.ownNumber = new Integer(ownNumber);
			
		} catch (Exception e) {
			System.out.println("FEHLER!: "+e.getMessage());
			e.printStackTrace();
		}
		return mask;
	}
	
    /**
     * Gibt einen Vector<String> mit den gefundnen IPs zurück.
     * 
     * @param port
     * @param waitms 
     * @return
     */
    public Vector<String> getIpList() {
    	Vector<String> ipList = new Vector<String>();
   	
    	// Startet den Scanner für alle Werte zwischen 1 und 254
    	for(int i=0;i<253;i++){
//    		if(i!=this.ownNumber);
    		new Scanner(this.subnet+(i+1), this.port, ipList).run();
    	}
      	return ipList;
	}

	
	
	/**
	 * Die Scanner class versucht eine Verbindung zu einem angegebenen Port auf einer übernommenen IP aufzubauen.
	 * 
	 * @author CyD
	 *
	 */
	private class Scanner extends Thread {
		
		private String ipAddress = null;
		private int port = 0;
		private Vector<String> ipList = null;
		

	    private Socket socket = null;
		
		/**
		 * Konstruktor der Klasse Scanner.
		 * 
		 * @param sns
		 * @param ipAddress
		 * @param port
		 * @param ipList
		 */
		public Scanner(String ipAddress, int port, Vector<String> ipList) {
			super("Subnetscan-Scanner");
			this.ipAddress = ipAddress;
			this.port = port;
			this.ipList = ipList;
		}
		
		/**
		 * Fügt die IP-Adresse in die IP-Liste ein, falls diese erreicht wird. 
		 * 
		 */
		public void run() {
			if(this.connectToServer(this.ipAddress, this.port)) {
				this.ipList.addElement(this.ipAddress);
				this.disconnect();
			}
		}
		
		
		/**
		 * Überprüft, ob eine Verbindung zu dem Ziel hergestellt werden kann und gibt das Ergebnis zurück.
		 * 
		 * @param ip
		 * @param port
		 * @return
		 */
		private boolean connectToServer(String ip, int port){
	       boolean bConnected = false;

	       try{
   
// Mit Timeout
//	    	   this.socket = new Socket();
//	    	   this.socket.setSoTimeout(10);
//	    	   this.socket.connect(new InetSocketAddress(ip, port));

	    	  this.socket = new Socket(ip, port);
	    	  	    	  
	          bConnected = true;
	          System.out.println("Erreicht: "+ip);
	       }catch(IOException e){
	     	  System.out.println("Nicht erreicht: "+ip);
	     	  e.printStackTrace();
	       }
	       return bConnected;
		}
		
		/**
		 * Beendet die Verbindung und schließt das Socket.
		 *
		 */
		private void disconnect() {
			try {
				this.socket.close();
				this.socket = null;
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	} 
	
}
```


Könnte das evtl. etwas mit den Sockets zu tun haben, 
dass diese nicht parallel laufen können?
 ???:L 

Bitte um Hilfe!


----------



## maki (9. Nov 2007)

die Thread.run() Methode ist nicht was du willst und 253 Threads zu starten ist... ähh... bestenfalls "suboptimal", wieviele Prozessoren hast du denn???


----------



## sparrow (9. Nov 2007)

Werden zufällig immer so ca. 10 Threads auf einmal abgearbeitet?


----------



## Wildcard (9. Nov 2007)

Threads werden mit start() gestartet.


----------



## CyD (9. Nov 2007)

1 Prozessor mit 1.92 GHz...

Ich bin der Meinung, dass die CPU-Auslastung kurz ruhig mal 100% erreichen kann. 
Das die 250 Threads nicht optimal sind ist mir klar.

hmm.. ???:L 
Vllt sollte ich trotzdem mal mit einer beschränkten Anzahl versuchen.


----------



## sparrow (9. Nov 2007)

Wildcart hat recht, du startest hier nirgends einen Thread in dem Code.

Threads starten: Thread.start()

Ansonsten such mal nach "Kamera" im Netzwerkforum. Ich kann mich erinnern, dass da schonmal was war.


----------



## CyD (9. Nov 2007)

Hmmm  ???:L 

Um eines klar zu stellen:
Normalerweise benutze ich immer ".start()". 
Wie es halt leider nun mal ist liest man irgendwo "Thread.run()", 
und schon übernimmt man es beim nächsten mal. 
Und weil auch noch ein System.out kommt, denkt man auch 
noch das es funktioniert. EIN TEUFELSKREIS! naja.


Ich werde versuchen deine theoretische Überlegung aus dem 
(Kamera-Thread )
in die Tat umzusetzten.

Kann ein bisschen dauern...  :gaen: 

Dabei wollt ich heut noch weg geh...   

Mal sehen.

*Danke erstmal an alle für die Hilfe!*


----------

