Permitir apenas 1 execução por jar

Crie um arquivo txt com o nome do jar. Caso, ao tentar ler, ele exista, invoque a saída do sistema. Se ele não existir, prossiga.

eu tinha pensado em algo com um arquivo, mas descartei a ideia pq achei que não houvesse jeito de saber o nome do arquivo jar que está sendo executado, já que pro SO é a JVM que está sendo executada. Mas vou pesquisar melhor como fazer isso então. Muito obrigado.

Mas você pode ler o diretório onde o jar está e descobrir o nome do mesmo… Não pode?

se eu entendi o que voce quis dizer não pode não, pq pode ter /root/ficha1.jar e /root/ficha2.jar por exemplo, apesar de estarem no mesmo diretorio tem o nome diferente e podem ser executados ao mesmo tempo.

Acho que o que o drsmachado sugeriu, é você - ao executar o jar - verificar se existe um arquivo no diretório de execução chamado por exemplo meujar.txt…

Se não houver, tudo bem, cria um arquivo deste e executa normalmente. Seria a primeira instancia do teu programa a rodar.

Se tentasse rodar novamente o programa, na verificação inicial ele encontraria o arquivo de texto, e então fecharia automaticamente…

O problema maior é começar a desenvolver sem planejar. Isso já deveria ter sido pensado antes de desenvolver o sistema.
Se você fizer uma pesquisa no google, verá que há formas de se identificar o jar onde o arquivo está empacotado.
E, quanto ao problema de existir dois jars dentro do mesmo diretório, você irá criar um arquivo por jar. Além do mais, existem outras formas de validar, como a data, por exemplo. Você está vendo a situação por uma ótica muito reduzida.

drsmachado:

Crie um arquivo txt com o nome do jar. Caso, ao tentar ler, ele exista, invoque a saída do sistema. Se ele não existir, prossiga.

Se o arquivo existir, está sendo executado.

Ou então, dentro desse arquivo coloque algo como
processo_ativo=true

[=

drsmachado:

O problema maior é começar a desenvolver sem planejar. Isso já deveria ter sido pensado antes de desenvolver o sistema.

realmente não houve planejamento, este é um projeto que comecei assim que aprendi a fazer um hello world, eu ia usando ele pra praticar enquanto estava aprendendo, acabou que ele cresceu, se tornou um monstro feioso mas que tinha alguma utilidade, hj depois de muito tempo, estou refatorando e “limpando” bastante coisa.

Mas e se o projeto estivesse começando do zero e este fosse um requisito, o que vocês recomendariam? O uso do arquivo mesmo?

acabei de achar aqui: http://bjornn.wordpress.com/2007/07/18/como-saber-de-qual-jar-uma-classe-foi-carregada/

vou fazer isso então, vou ver de qual jar a classe main foi carregada e armazenar no arquivo, se ele ja existir eu bloqueio a execução.

Muito obrigado a todos, quando tiver implementado a solução eu volto aqui pra postar o resultado ^^

e se o programa estiver rodando e desligar a maquina ? finalizar o processo ? o arquivo vai continuar la e não abre mais…

cria um arquivo instancia

no construtor do seu programa você tenta um trylock se null você da um lock no arquivo, caso contrário você sai do programa

use a segunda resposta.

tem que alterar o código do cara, qualquer dúvida posta ai

douglaskd:

e se o programa estiver rodando e desligar a maquina ? finalizar o processo ? o arquivo vai continuar la e não abre mais…

cria um arquivo instancia

no construtor do seu programa você tenta um trylock se null você da um lock no arquivo, caso contrário você sai do programa

use a segunda resposta.

tem que alterar o código do cara, qualquer dúvida posta ai

vou dar uma olhada no link, qualquer duvida eu posto aqui então, valeu galera

bem, a solução a que cheguei por enquanto foi serializar uma List de Strings que é sempre utilizada pelos programas, está funcionando perfeitamente. O problema que estou enfrentando agora é o que douglaskd disse, ainda n cheguei a uma solução e não entendi como o link postado poderia ser aplicado ao meu caso, pelo que li, aquilo lá serve pra "travar" o arquivo, sinalizando pra outros processos que o arquivo já está sendo usado...

Vou deixar o código que escrevi aqui, se alguem tiver alguma sugestão/critica/opinião e quiser falar...

public class ExecUnica {

    private List<String> jarsExecutando;
    private final String SERIALIZATION_PATH = System.getProperty("user.home") + File.separator + ".fichas_editadas";

    ExecUnica() {
        this.jarsExecutando = new ArrayList<>();
    }

    private void serializarJars() {
        try {
            FileOutputStream fos = new FileOutputStream(SERIALIZATION_PATH);
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(jarsExecutando);
            oos.close();
            fos.close();
        } catch (IOException ioe) {
            ioe.printStackTrace();
        }
    }

    private void desserializarJars() {
        ObjectInputStream ois = null;
        FileInputStream fis = null;
        try {

            fis = new FileInputStream(SERIALIZATION_PATH);
            ois = new ObjectInputStream(fis);
            this.jarsExecutando = (List<String>) ois.readObject();
            ois.close();
            fis.close();
            
        } catch (StreamCorruptedException sce) {
            JOptionPane.showMessageDialog(null, "Um arquivo foi corrompido e será recriado, feche todas as fichas que estão abertas.", "Erro", JOptionPane.ERROR_MESSAGE);
            serializarJars();
            sce.printStackTrace();
        } catch (IOException | ClassNotFoundException ex) {
            ex.printStackTrace();
        } finally {
            try {
                ois.close();
                fis.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }

    private String getJar() {
        Class cls = getClass();
        ProtectionDomain pDomain = cls.getProtectionDomain();
        CodeSource cSource = pDomain.getCodeSource();
        URL jarLocation = cSource.getLocation();
        return jarLocation.getPath();
    }

    public void travarExecucao() {
        desserializarJars();
        this.jarsExecutando.add(getJar());
        serializarJars();
    }

    public void liberarExecucao() {
        desserializarJars();
        this.jarsExecutando.remove(getJar());
        serializarJars();
    }

    public boolean estaEmExecucao() {
        desserializarJars();
        return this.jarsExecutando.contains(getJar());
    }
}

Documentação: A file-lock object is initially valid. It remains valid until the lock is released by invoking the release method, by closing the channel that was used to acquire it, or by the termination of the Java virtual machine, whichever comes first. The validity of a lock may be tested by invoking its isValid method.

usando esta lógica, basicamente o funcionamento seria esse:

esse código vai no construtor do Jframe principal/ ou no main() do seu aplicativo:

String pathArquivoFlag = ""; //insira aqui o path do arquivo, ou tente encontrar uma maneira de descobrir o path

try {
	
        File file = new File(pathArquivoFlag);
        FileChannel channel = new RandomAccessFile(file, "rw").getChannel();
	FileLock lock;

	//tenta o lock, se arquivo estiver bloqueado cai na exception
	try {
               lock = channel.tryLock(0,10,false);
        } catch (OverlappingFileLockException e) {

        //como o arquivo esta bloqueado, significa que outra instancia igual a esta deu lock no arquivo e esta aberta então sair da aplicação
	       System.exit(0); 
        }

	//se chegou até aqui quer dizer que esta é a unica instancia aberta e esta com lock no arquivo, qualquer outra que tentar ser executada será 		  automaticamente fechada.

    } catch (Exception e) {
	//exceptions adicionais, debugue seu código
    }

não testei esse código, então provavel que tenha algum erro, mas acho que ajuda.