O correto é usar uma classe que implemente a interface java.concurrent.Callable em vez de uma Thread.

Usando a interface Future (um objeto de uma classe que implementa Future é retornada pelo método submit de ExecutorService), é possível cancelar e checar se esse Callable foi cancelado.

http://download.oracle.com/javase/6/docs/api/java/util/concurrent/Future.html

Um exemplo do uso de Future e Callable está no Javadoc acima.

O correto é usar uma classe que implemente a interface java.concurrent.Callable em vez de uma Thread.

Usando a interface Future (um objeto de uma classe que implementa Future é retornada pelo método submit de ExecutorService), é possível cancelar e checar se esse Callable foi cancelado.

http://download.oracle.com/javase/6/docs/api/java/util/concurrent/Future.html

Um exemplo do uso de Future e Callable está no Javadoc acima.

Muito interessante. Não fui apresentado a esta classe. Não costumo mexer com Thread já que meu forte é trabalhar com web.

Mas isso garante que a execução irá para no tempo certo?

O método stop() foi deprecated pois ele gera leak de recursos:

1. Locks de sincronização ficam presos;
2. Arquivos podem ficar abertos;
3. Conexões de BD também.

Em resumo, você joga isso numa thread e ela aborta na hora. Nada garante que o que foi reservado por ela seja liberado.

2. Arquivos podem ficar abertos;

vivi isso um tempo desses por aqui!

e como ficaria a implementação por exemplo:

Thread thread = new Thread(minhaClasse, id);
thread.start();

//Depois de um Tempo
thread.stop();

abraço!

leo_mf:

Mas isso garante que a execução irá para no tempo certo?

Não: o método “cancel” apenas força uma exceção InterruptedException na thread que está executando esse Callable. Se a thread estiver porventura em um ponto em que ela não consegue ser interrompida (tipicamente quando está travada em um loop fazendo contas, sem fazer I/O como arquivos ou sockets) então ela só irá ser interrompida quando sair desse loop.

aeciovc:

2. Arquivos podem ficar abertos;

vivi isso um tempo desses por aqui!

e como ficaria a implementação por exemplo:

Thread thread = new Thread(minhaClasse, id);
thread.start();

//Depois de um Tempo
thread.stop();

abraço!

Veja o exemplo em http://download.oracle.com/javase/6/docs/api/java/util/concurrent/Future.html

O certo seria chamar Interrupt(), que faz o que o cancel() que o entanglement está citando faz. Com as mesmas limitações.
E procurar APIs que tenham timeouts máximos para operações críticas (como I/O ou leituras de sockets).

Exemplo.

package guj;

import java.awt.BorderLayout;
import java.awt.FlowLayout;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JProgressBar;
import javax.swing.SwingUtilities;

class Atualizador implements Callable<Void> {
    public Atualizador(JProgressBar prb) {
        this.prb = prb;
    }

    @Override
    public Void call() throws Exception {
        while (true) {
            SwingUtilities.invokeLater(new Runnable() {
                public void run() {
                    prb.setValue(val++);
                }
            });
            if (val >= 100)
                val = 0;
            Thread.sleep(100);
        }
    }

    private JProgressBar prb;
    private int val = 0;
}

public class ExemploCallable extends JFrame {

    private static final long serialVersionUID = 1L;
    private JPanel jContentPane = null;
    private JPanel pnlBotoes = null;
    private JButton btnIniciar = null;
    private JButton btnParar = null;
    private JProgressBar prbProgresso = null;

    private ExecutorService executor;
    private FutureTask<Void> future;

    private JPanel getPnlBotoes() {
        if (pnlBotoes == null) {
            pnlBotoes = new JPanel();
            pnlBotoes.setLayout(new FlowLayout());
            pnlBotoes.add(getBtnIniciar(), null);
            pnlBotoes.add(getBtnParar(), null);
        }
        return pnlBotoes;
    }

    private JButton getBtnIniciar() {
        if (btnIniciar == null) {
            btnIniciar = new JButton();
            btnIniciar.setText("Iniciar!");
            btnIniciar.addActionListener(new java.awt.event.ActionListener() {
                public void actionPerformed(java.awt.event.ActionEvent e) {
                    btnIniciar.setEnabled(false);
                    future = new FutureTask<Void>(new Atualizador(prbProgresso));
                    executor.execute(future);
                    btnParar.setEnabled(true);
                }
            });
        }
        return btnIniciar;
    }

    private JButton getBtnParar() {
        if (btnParar == null) {
            btnParar = new JButton();
            btnParar.setText("Parar!");
            btnParar.setEnabled(false);
            btnParar.addActionListener(new java.awt.event.ActionListener() {
                public void actionPerformed(java.awt.event.ActionEvent e) {
                    btnParar.setEnabled(false);
                    future.cancel(true);
                    btnIniciar.setEnabled(true);
                }
            });
        }
        return btnParar;
    }

    private JProgressBar getPrbProgresso() {
        if (prbProgresso == null) {
            prbProgresso = new JProgressBar();
            prbProgresso.setStringPainted(true);
        }
        return prbProgresso;
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                ExemploCallable thisClass = new ExemploCallable();
                thisClass.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                thisClass.setVisible(true);
            }
        });
    }

    public ExemploCallable() {
        super();
        initialize();
        executor = Executors.newCachedThreadPool();
    }

    private void initialize() {
        this.setSize(300, 111);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setContentPane(getJContentPane());
        this.setTitle("Exemplo Callable");
    }

    private JPanel getJContentPane() {
        if (jContentPane == null) {
            jContentPane = new JPanel();
            jContentPane.setLayout(new BorderLayout());
            jContentPane.add(getPnlBotoes(), BorderLayout.SOUTH);
            jContentPane.add(getPrbProgresso(), BorderLayout.CENTER);
        }
        return jContentPane;
    }
}

Bom pessoal para quem gosta de mexer com Thread, tenho uma boa prática para vocês.

ScheduledExecutorService thread = Executors.newSingleThreadScheduledExecutor(); Runnable run = new Runnable() { @Override public void run() { JOptionPane.showMessageDialog(null, "Open"); } }; thread.scheduleWithFixedDelay(run, 0, 15, TimeUnit.SECONDS);
Esse tem shutdown. Fiz uns testes e não deu nenhum problema, aparentemente.

“Eu odeio trabalhar com Threads. Malditas Threads!”

leo_mf:

Bom pessoal para quem gosta de mexer com Thread, tenho uma boa prática para vocês.

ScheduledExecutorService thread = Executors.newSingleThreadScheduledExecutor(); Runnable run = new Runnable() { @Override public void run() { JOptionPane.showMessageDialog(null, "Open"); } }; thread.scheduleWithFixedDelay(run, 0, 15, TimeUnit.SECONDS);
Esse tem shutdown. Fiz uns testes e não deu nenhum problema, aparentemente.

“Eu odeio trabalhar com Threads. Malditas Threads!”

Cuidado - o nome “thread” que você deu ao ExecutorService é realmente “misleading” (enganador).

Acho que pior que comentários incorretos são nomes enganadores para variáveis.

Um ExecutorService não é e nunca vai ser uma thread. Objetos cujas classes implementam ExecutorService, como o próprio nome indica, servem para solicitar a execução de comandos, que casualmente podem ser associados a threads, ou não, conforme a implementação do ExecutorService. Você poderia ter um ExecutorService que rodasse as coisas na mesma thread do programa principal.

Senhor, entanglement

Desculpe por isso, prometo que nunca mais vai acontecer.

Arrumei o código de acordo com seu comentário.

ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor(); Runnable thread = new Runnable() { @Override public void run() { JOptionPane.showMessageDialog(null, "Open"); } }; scheduledExecutorService.scheduleWithFixedDelay(thread, 0, 15, TimeUnit.SECONDS);

Magoei com isso :lol: . Não precisava falar assim.