linkedMap si svuota da sola

[processore]

Sto scrivendo una classe in cui devo salvare degli elementi in una map, ogni volta che c'è un elemento mi chiedo se è contenuto nella map, se è contenuto prendo il suo valore altrimenti inserisco i dati nella map.
funziona tutto bene tranne il fatto che a un certo punto la map si svuota da sola e quindi rimette di nuovo tutti gli elementi e mi perdo i vecchi elementi.

la mia classe è questa

public class Visitable {
private LinkedHashMap<String, Client> rb = new LinkedHashMap<String, Client>();

public boolean isVisitable(String param){


           
        
            Client cl = getIstanceCl(param);


        
            return true;
        }



private Client getIstanceCl(String param){


        
        if(rb.containsKey(param)){       
            
            return rb.get(param);
        }
        else {
            
            
            //istanza di robots che contiene le regole
            rb.put(param, new Client(param));         


            return rb.get(param);




        }


    }



    }

se provo a mettere System.out.println(rb.size);

vedo che riempie la map per 40 record e poi si svuota da sola e riparta da zero.

forse la map non è adatta per questo lavoro ?

grazie a tutti

[andbin]

vedo che riempie la map per 40 record e poi si svuota da sola e riparta da zero.

forse la map non è adatta per questo lavoro ?

No, non è sicuramente quello il punto. Non è chiaro perché hai usato LinkedHashMap invece che HashMap ma questa è un'altra questione: devi mantenere l'ordine di inserimento? Se sì, LinkedHashMap è ok, Se no, basta HashMap.

Le questioni sono altre e mi vengono in mente 2 domande:
- Quanti oggetti Visitable hai? Usi sempre lo stesso?
- C'è di mezzo il multi-threading? Ovvero uno stesso oggetto Visitable è usato da più thread contemporaneamente? Perché la tua classe non è thread-safe ....

[processore]

avevo usato hashMap prima e mi dava questo problema, ho pensato di provare linkedMap ma il problema non si risolve quindi posso ritornate ad hashmap,

-la map non so quanti elementi deve contenere, prende una stringa controlla che ci sia una key uguale nella map, se non esiste la inserisce e istanzia un oggetto che per ogni elemento con la stessa stringa è sempre uguale, quindi a me interessa tenere traccia nella map solo di un unico elemento distinto.

- no non uso il multi-thread altrimenti dovrei usare una struttura thread-safe

quello che non capisco è come mai in questa classe che al massimo la map puo contenere 200 elementi dopo un po me li svuota,

mentre in un altra classe che gli metto 2milioni di oggetti funzioni beneo almeno stampando il size vedo che non viene svuotata all'improvviso.


quello che ho incollato era un codice che stavo provando per capire il problema, ti posto l'intera classe magari vedi qualcosa che io non riesco a vedere.

package web.jsoup;




import robots.RobotClient;


import java.awt.*;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Properties;


/**
 * Controlla se una url è visitabile
 * 1) controlla se è da visitare
 * 2) controlla se è visitata
 * 3) controlla le regole del robots
 */
public class Visitable {










	private LinkedHashMap<String, RobotClient> rb = new LinkedHashMap<String, RobotClient>();
    //private Map<String, RobotClient> rb = new HashMap();




    /**
     *
     * @param url
     * @return
     */
    public boolean isVisitable(String url){


        url = url.trim();








        if(isUrlToVisited(url)){
            return false;
        }


        else if(isUrlVisited(url)){
            return false;


        }
        else{






            RobotClient robots = getIstanceRobots(url);


            
            


            return robots.isUrlAllowed(url);
        }








    }


    private boolean isUrlToVisited(String url){


        return UrlToVisit.getIstance().containsKey(url);


    }


    private boolean isUrlVisited(String url){


        return UrlVisit.getIstance().isVisited(url);


    }




    /**
     * Inserisce le istanza in una map cosi da non dover
     * istanziare per ogni url
     * @param url
     * @return
     */
    private RobotClient getIstanceRobots(String url){


        URL ur = null;


        try {


            ur = new URL(url);


        } catch (MalformedURLException e) {
            e.printStackTrace();
        }






        String host = ur.getHost();
        String protocol = ur.getProtocol();


        String baseUrl = protocol+"://"+host;
       
        /**
         * Se la url si trova nel set ritorna l'istanza del robot
         * altrimeti la inserisce nella map e ritorna istanza
         */


        
        if(rb.containsKey(baseUrl)){   	
        	
            return rb.get(baseUrl);
        }
        else {
        	
        	
            //istanza di robots che contiene le regole
            rb.put(baseUrl, new RobotClient(Parameter.USER_AGENT, baseUrl));         


            return rb.get(baseUrl);




        }


    }






}

[processore]

forse ho capito, è possibile che la classe dove la map funziona a dovere funziona perche ho fatta singleton, mentre qui ogni volta viene istanzato una istanza di visitable e per ogni istanza mi perde i dati della map ? anche se ancora non capisco perche arriva fino a 40 elementi e poi si azzera.

posso fare pure questa classe singleton, oppure metto la map con i metodi che la gestiscono static perchè sono dati condivisi con tutti il programma

[andbin]

- no non uso il multi-thread altrimenti dovrei usare una struttura thread-safe

Ok. Ma non servirebbe un'altra struttura dati ... serve che la TUA classe sia thread-safe, non tanto la struttura interna.

mentre qui ogni volta viene istanzato una istanza di visitable e per ogni istanza mi perde i dati della map ?

Sì, può essere questo. In tutto il codice che hai postato finora NON si vede chi/dove istanzia un oggetto Visitable. E finché non è chiaro (a te ma anche a chi legge qui), non saprei cosa altro dire.

[processore]

ho risolto mettendo hashmap come static.
grazie mi illumini sempre

-Solo un ultimo chiarimento se non ti disturbo molto.
io ho questa map che mi deve mantenere dei dati comunti a tutto il programma, non mi importa istanziare diversi oggetti visitable, perche il suo compito è solo quello di riempire la map e controllare che ci siano dei dati dentro, mi conviene gestirla come static oppure è meglio gestire la classe come singleton.
come questa :

package web.jsoup;


import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;


/**
 * 
 * Gestione delle url da visitare
 *
 */






public class UrlToVisit{
	
	private  Map<String, Record> linkDaVisitare = new LinkedHashMap<String, Record>();








	private UrlToVisit(){
	}




	//bill pugh technique singleton
	private static class Instance{
		private static final UrlToVisit INSTANCE = new UrlToVisit();
	}




	public static UrlToVisit getIstance(){
		return Instance.INSTANCE;
	}












	/**
	 * @description aggiunge elementi nella map 
	 * @param key URL da visitare
	 * @param value oggetto di tipo URL
	 */
	public void setLinkDaVisitare(String key, Record value) {
		this.linkDaVisitare.put(key, value);
	}


	/**
	 *
	 * @return Map
	 */
	public   Map<String, Record> getLinkDaVisitare() {
		return linkDaVisitare;
	}
	
	
	/**
	 * @description prende il primo elemento dalla map e poilo elimina dalla map
	 * 
	 * @return objcet V
	 * 
	 */
	
	public Record next(){
		
		System.out.println(linkDaVisitare.size());
		
		Map.Entry<String, Record> next = linkDaVisitare.entrySet().iterator().next();
		
		String key = next.getKey();
		Record value = next.getValue();
		
		linkDaVisitare.remove(key);
		
		return value;
	}


	public boolean containsKey(String url){


		return linkDaVisitare.containsKey(url);


	}


	public boolean isEmpty(){
		return linkDaVisitare.isEmpty();
	}




}




/*
public class UrlToVisit  {
	
	private Set<String> linkDaVisitare = new HashSet<String>();
	
	public void add(String val){
		this.linkDaVisitare.add(val);
	}
	
	public void addAll(Collection<? extends String> c){
		
		this.linkDaVisitare.addAll(c);
	}
	
	public Set<String> getLinkDaVisitare(){
		
		return this.linkDaVisitare;
	}
	
	
	public boolean isEmpty() {
		
		if(this.linkDaVisitare.size()> 0 ){
			return false;
		}
		else{
			return true;
		}


	}
	
	
	
	public String next(){
		
		String next = this.linkDaVisitare.iterator().next();
		this.linkDaVisitare.remove(next);
		
		return next;
	}
	


}
*/

comunque ti ringrazio davvero ogni volta mi aiuti moltissimo, e scusa se faccio domande banali ma sono un novellino che si sta innamorando di java