завершение потока с блокирующим i/o

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
 
public class StopThreadExampleApplication extends JFrame {
 
    private static final long serialVersionUID = -482967528453725691L;
 
    private JPanel jContentPane = null;
    private JLabel outputLabel = null;
    private JPanel buttonsPane = null;
     
    private JButton startButton = null;
    private JButton stopButton = null;
     
    private CustomThread customThread = null;
 
    public StopThreadExampleApplication() {
        super();
        initialize();
    }
     
    private void initialize() {
        this.setSize(250, 250);
        this.setContentPane(getJContentPane());
        this.setTitle("JFrame");
    }
 
    private JPanel getJContentPane() {
        if (jContentPane == null) {
            jContentPane = new JPanel();
            jContentPane.setLayout(new BorderLayout());
            jContentPane.add(getOutputLabel(), BorderLayout.CENTER);
            jContentPane.add(getButtonsPane(), BorderLayout.PAGE_END);
        }
        return jContentPane;
    }
 
    private JLabel getOutputLabel() {
        if (outputLabel == null) {
            outputLabel = new JLabel();
        }
        return outputLabel;
    }
     
    private JPanel getButtonsPane() {
        if ( buttonsPane == null ) {
            buttonsPane = new JPanel();
            buttonsPane.setLayout(new BorderLayout());
            buttonsPane.add(getStartButton(), BorderLayout.WEST);
            buttonsPane.add(getStopButton(), BorderLayout.EAST);
        }
        return buttonsPane;
    }
     
    private JButton getStartButton() {
        if ( startButton == null ) {
            startButton = new JButton();
            startButton.setText("Start");
            startButton.addActionListener(new ActionListener(){
                @Override public void actionPerformed(ActionEvent arg0) {
                    SwingUtilities.invokeLater(new Runnable() {
                        public void run(){
                            if ( customThread == null ) {
                                customThread = new CustomThread(getOutputLabel());
                                customThread.start();
                                getStartButton().setEnabled(false);
                                getStopButton().setEnabled(true);
                            }
                             
                        }
                    });
                }
            });
        }
        return startButton;
    }
     
    private JButton getStopButton() {
        if ( stopButton == null ) {
            stopButton = new JButton();
            stopButton.setText("Stop");
            stopButton.setEnabled(false);
            stopButton.addActionListener(new ActionListener(){
                @Override public void actionPerformed(ActionEvent arg0) {
                    SwingUtilities.invokeLater(new Runnable() {
                        public void run(){
                            if ( customThread != null ) {
                                customThread.requestForStop();
                                customThread = null;
                                getStartButton().setEnabled(true);
                                getStopButton().setEnabled(false);
                            }
                        }
                    });
                }
            });
        }
        return stopButton;
    }
     
    @Override
    public void dispose() {
        if (this.customThread != null) this.customThread.requestForStop();
        this.customThread = null;
        super.dispose();
    }
 
     
    public static void main(String args[]) {
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                StopThreadExampleApplication thisClass = new StopThreadExampleApplication();
                thisClass.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
                thisClass.setResizable(false);
                thisClass.setVisible(true);
            }
        });
    }
     
         
}
 
class CustomThread extends Thread {
 
    private boolean requestForStop = false;
    private JLabel outputLabel;
    private int counter = 0;
 
    public CustomThread(JLabel outputLabel){
        super();
        this.outputLabel = outputLabel;
    }
     
    private synchronized void fireCounterChanged() {
        // Run asynchronous update of the JLabel, but in the valid sequence  
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                // Don't forget to check that JLabel still exists
                if ( outputLabel != null )
                    // Update JLabel with new value
                    outputLabel.setText(Integer.toString(counter));
            }
        });
    }
     
    @Override public void run(){
        System.out.println("run: entry");
        try {
            while (true) {
                counter++;
                this.fireCounterChanged();
                sleep(100);
            }  
        } catch (InterruptedException ex) {
            System.out.println("run: thread interrupted!");
        } catch (Exception ex) {
            System.out.println(ex.toString());  
        }
        System.out.println("run: exit");
    }
     
    public synchronized void requestForStop(){
        System.out.println("requestForStop: entry");
        if ( !this.requestForStop ) {
            this.requestForStop = true;
            interrupt();
            System.out.println("requestForStop: exit");
        }
    }
}

public void close()
           throws IOException
Closes this socket. Any thread currently blocked in accept() will throw a SocketException.

If this socket has an associated channel then the channel is closed as well.