Problema com conexao socket

Galera, estou com esse problema no meu aplicativo:

06/12/2011 07:34:09,005 32092830 [main] ERROR root  - Principal-mainjava.net.SocketException: Too many open files
    at java.net.PlainSocketImpl.socketAccept(Native Method)
    at java.net.PlainSocketImpl.accept(PlainSocketImpl.java:408)
    at java.net.ServerSocket.implAccept(ServerSocket.java:462)
    at java.net.ServerSocket.accept(ServerSocket.java:430)
    at br.com.ces.svias.principal.Principal.main(Principal.java:68)

o que ja tentei para resolver esse problema:

1º Criei um timer no aplicativo que de tempo em tempo varre a lista dos equipamentos que estao conectados, verefico se eles estão conectados em caso negativo fecho a conexao java e retiro ele da lista.

Quando eu aplico esse comando: socket.isClosed(); ele sempre me retorna false, ja cheguei fazer o teste com o meu equipamento embarcado, assim que o meu equipamento conectava, eu desligava o equipamento da tomada e aguardava o ciclo do timer, quando o ciclo do timer chamava o meu equipamento no comando citado acima ele retornava false, mesmo o equipamento desligado.

2º Uso linux ubuntu, ja passei o numero maximo de conexoes para 100000. Sendo que o numero de equipamentos simultaneos nao passa de 7 mil.

3º Quando vou rodar a minha aplicação eu chamo ela assim: java -server -jar MinhaAplicacao.jar

Galera, nao sei mais o que eu faço. Ja entreguei para Deus!!!

Eu nao quero fazer isso em C++, pq eu nao tenho os macetes de ligar o C++ no Mysql e sem contar que vou ter que fazer tudo de novo.

Att

Galera,

Deem uma olhada no meu codigo. Eu já nao sei mais o que fazer!!!

Principal.class

import java.net.InetSocketAddress;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;

import java.util.Date;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ConcurrentSkipListSet;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SimpleTrigger;
import org.quartz.impl.StdSchedulerFactory;

/**
 *
 * @author Vinicius
 */
public class Principal {

    private static ConcurrentSkipListSet<Bean> cl = new ConcurrentSkipListSet<Bean>();
    
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
       new Principal().iniciar();
    }
    
    private void iniciar(){
         try {
            
           // Collections.synchronizedList(null)
            
            ExecutorService service = Executors.newFixedThreadPool(3000);
            
            
            BlockingQueue<Bean> queue = new LinkedBlockingQueue<Bean>(10000);
            
            
            executarQuartz(service);
            
            EquipamentoConectado conectado = new EquipamentoConectado(queue, cl);
            service.execute(conectado);
            
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
            serverSocketChannel.socket().bind(new InetSocketAddress(8003));
            
            while (true) {
                SocketChannel socketChannel = serverSocketChannel.accept();
                TrataEquipamento equipamento = new TrataEquipamento(queue, socketChannel);
                service.execute(equipamento);
                 
            }
            
        } catch (Exception e) {
           SViasLogger.logError("Principal", e);
        }
    }
    
    
    private static void executarQuartz(ExecutorService executor) throws Exception {
        ValidaConexao validaConexao = new ValidaConexao();
        validaConexao.setCl(cl);

        JobDetail job = new JobDetail();
        job.setName("runValidaConexaoJob");
        job.setJobClass(ValidaConexao.class);
        job.getJobDataMap().put("validaConexao", validaConexao);
        SimpleTrigger trigger = new SimpleTrigger();
        trigger.setName("validaConexao");
        trigger.setStartTime(new Date(System.currentTimeMillis() + 1000));
        trigger.setRepeatCount(SimpleTrigger.REPEAT_INDEFINITELY);
        trigger.setRepeatInterval(300000);
        Scheduler scheduler = new StdSchedulerFactory().getScheduler();
        scheduler.start();
        scheduler.scheduleJob(job, trigger);
    }
}

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ConcurrentSkipListSet;

/**
 *
 * @author Vinicius
 */
public class EquipamentoConectado implements Runnable{

    private BlockingQueue<Bean> queue;
    private ConcurrentSkipListSet<Bean> cl;
    
    public EquipamentoConectado(BlockingQueue<Bean> queue, ConcurrentSkipListSet<Bean> cl){
        this.queue = queue;
        this.cl = cl;
    }
  
    @Override
    public void run() {
        while(true){
            try {
                Bean bean = queue.take();
                cl.add(bean);
            } catch (Exception e) {
                SViasLogger.logError("EquipamentoConectado", e);
            }
        }
    }
}

import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.nio.channels.SocketChannel;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.BlockingQueue;

/**
 *
 * @author Vinicius
 */
public class TrataEquipamento implements Runnable {

    private BlockingQueue<Bean> queue;
    private SocketChannel socketChannel;

    public TrataEquipamento(BlockingQueue<Bean> queue, SocketChannel socketChannel) {
        this.queue = queue;
        this.socketChannel = socketChannel;
    }

    @Override
    public void run() {
        try {
            Socket socket = socketChannel.socket();
            String comando = lerComando(socket);
            SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss"); 
            SViasLogger.logInfo("Mais um equipamento conectado:"+comando+" as "+formatador.format(new Date()));
            enviarComando(socket, "@");
            Bean bean = new Bean();
            bean.setChannel(socketChannel);
            bean.setIdentificacao(comando);
            queue.put(bean);
        } catch (Exception e) {
            SViasLogger.logError("TrataEquipamento", e);
        }
    }

    private String lerComando(Socket socket) throws Exception {

        InputStream in = null;
        in = socket.getInputStream();
        byte[] buffer = new byte[1024];
        in.read(buffer);
        String retorno = new String(buffer);
        return retorno;
    }

    private void enviarComando(Socket socket, String comando) throws Exception {
        OutputStream out = socket.getOutputStream();
        out.write(comando.getBytes());
    }
}

import java.io.OutputStream;
import java.net.Socket;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ConcurrentSkipListSet;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

/**
 *
 * @author Vinicius
 */
public class ValidaConexao implements Job  {

    private ConcurrentSkipListSet<Bean> cl;

    private boolean isConectado(Socket socket) throws Exception {
        try {
            enviarComando(socket, "AT+PSW?");
            enviarComando(socket, "@");
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    private void enviarComando(Socket socket, String comando) throws Exception {
        OutputStream out = socket.getOutputStream();
        out.write(comando.getBytes());
    }

    @Override
    public void execute(JobExecutionContext jec) throws JobExecutionException {
         Map dataMap = jec.getJobDetail().getJobDataMap();
         ValidaConexao validaConexao = (ValidaConexao) dataMap.get("validaConexao");
         ConcurrentSkipListSet<Bean> clTemp = validaConexao.getCl();
         System.out.println("Tamanho da lista"+clTemp.size());
         try {
                int cont = 0;
                for (Iterator<Bean> iterator = clTemp.iterator(); iterator.hasNext();) {
                    Bean bean = iterator.next();
                    if (!isConectado(bean.getChannel().socket())) {
                        clTemp.remove(bean);
                        SViasLogger.logInfo("Mais um equipamento removido");
                        cont++;
                    }
                }
                System.out.println("Quantidade de equipamentos na lista:"+ clTemp.size()+" quantidade de equipamentos desconectados:"+cont);
            } catch (Exception e) {
                SViasLogger.logError("ValidaConexao", e);
            }
         
    }

    public ConcurrentSkipListSet<Bean> getCl() {
        return cl;
    }

    public void setCl(ConcurrentSkipListSet<Bean> cl) {
        this.cl = cl;
    }
    
    
}

Eu uso um agendador quartz para limpar a fila de equipanentos que não estao conectados a cada 5 minutos.

Att

4 Respostas

Topicos relacionados