garbage collector i xsocket

Witam mam troszkę dziwny problem z pamięcią a mianowicie w klasie w której wysyłam wiadomość

import java.net.InetAddress;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.xsocket.connection.INonBlockingConnection;
import org.xsocket.connection.IServer;
import org.xsocket.connection.NonBlockingConnection;
import org.xsocket.connection.Server;

public class C_send {
 public void wyslij(String zzz) {
      InetAddress inetAddress=null;
      INonBlockingConnection bc=null;      
      try{ inetAddress = InetAddress.getByName("127.0.0.1");  }catch (Exception ee){}
      try{ bc = new NonBlockingConnection(inetAddress, 8090);
        }catch(java.io.IOException f){}    
 } 
}

za każdym razem gdy odwołam Sie do klasy to tworzona jest zmienna „bc” po opuszczeniu klasy powinna zostać usunięta ale z tego co zauważyłem nie jest usuwana i zapełnia sie pamięć próbowałem wywołać System.gc(); ale bez rezultatu pewnie chodzi o to że trzyma go referencja… ktoś mógł by mnie nakierować co zrobić z tym?

Nigdy nie używałem tej biblioteki, to zapewne problemem jest to, że nie kończysz połączeń. Poza tym - nie ignoruj wyjątków.

public class C_send {
 public void wyslij(String zzz) throws Exception{
      InetAddress inetAddress = InetAddress.getByName("127.0.0.1");
      INonBlockingConnection bc = new NonBlockingConnection(inetAddress, 8090);    
      try{ 
             bc.write(zzz, "UTF8", null);
      } finally{
             bc.close();
      }   
 }
}

public class C_send {
    InetAddress inetAddress=null;
    INonBlockingConnection bc=null;
    int str_dlugi=100;
    int str_dlugi_r=0;
    NonBlockingConnectionPool pool = new NonBlockingConnectionPool();
    String req="";
 public void wyslij(String co) {
        str_dlugi=100;
        str_dlugi_r=0;
        req="";
       try{ inetAddress = InetAddress.getByName("127.0.0.1");  }catch (Exception ee){}
       try{ bc = pool.getNonBlockingConnection(inetAddress, 8090);
        req+=co;
        str_dlugi_r=str_dlugi-req.length();
        for (int xx=1;xx<=str_dlugi_r;xx++){
           req=req+";";
        }
       try{ bc.write(req + "\r\n"); }catch(Exception ee){}
       }catch(java.io.IOException f){}
 }
}

finalizacja tez nie pomaga... udało mi sie zapobiec zapełnianiu pamięci po przez przeniesienie zmiennej "bc" do C_send i odwołanie się do tego po przez NonBlockingConnectionPool co i tak nie do końca naprawia błąd bo pamięć się jeszcze zapełnia... zrobiłem inny test wysyłam 100000 wiadomości do S_echo:

public class S_echo implements IDataHandler {
public boolean onData(INonBlockingConnection nbc) throws SocketTimeoutException, ClosedChannelException, IOException {

return true;
}

S_echo ma tylko nasłuchiwać zrobilem je puste tak jak widać tylko odbiera pakiety ale pamięć się niestety szybko zapełnia. Probowałem z:

nbc.flush();
nbc.close();
nbc.removeReadMark();
nbc.removeWriteMark();

ale to nic niestety nie pomaga.

Nie wiem w jakim celu tak kombinujesz.
NonBlockingConnection posługuje się oddzielnym wątkiem dlatego połączenie nie jest usuwano po wyjściu zmiennej z zakresu.

ZAMYKAJ POŁĄCZENIE

http://www.java2s.com/Open-Source/Java-Document/Web-Server/xsocket/org/xsocket/connection/NonBlockingConnectionPool.java.java-doc.htm

// create a unbound connection pool
 NonBlockingConnectionPool pool = new NonBlockingConnectionPool();
 INonBlockingCinnection con = null;
 try {
 // retrieve a connection (if no connection is in pool, a new one will be created)
 con = pool.getNonBlockingConnection(host, port);
 con.write("Hello");
 ...
 // always close the connection! (the connection will be returned into the connection pool)
 con.close();
 } catch (IOException e) {
 if (con != null) {
 try {
 // if the connection is invalid -> destroy it (it will not return into the pool)
 pool.destroy(con);
 } catch (Exception ignore) { }
 }
 }

Ustal też w puli maksymalną liczbę wątków za pomocą metod

setMaxActivePooled(int maxActive)
setMaxIdlePooled(int maxIdle)

Czy tworzysz obiekt C_send za każdym razem, gdy wysyłasz wiadomość?
Jeżeli tak, to uczyć NonBlockingConnectionPool polem statycznym.