网络---中断套接字Socket

package socketpack_2;
import java.awt.BorderLayout;
import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.channels.SocketChannel;
import java.util.Scanner;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
/**
 * 网络 -可中断套接字
 * @author Visec·Dana
 */
public class InterruptibleSocketTest {
    public static void main(String[] args) {
        EventQueue.invokeLater(new Thread()
        {
            public void run(){
                JFrame frame=new InterruptibleSocketFrame();
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setVisible(true);

            }
        }
                );
    }
}
class InterruptibleSocketFrame extends JFrame{
    private static final long serialVersionUID = 1L;
    public InterruptibleSocketFrame(){
        setSize(WIDTH,HEIGHT);
        setTitle("InterruptibleSocketTest");

        JPanel northpJPanel =new JPanel();
        add(northpJPanel,BorderLayout.NORTH);

        messages=new JTextArea();
        add(new JScrollPane(messages)); 
        interruptilButton=new JButton("Interruptilbel");
        blockingButton=new JButton("Blocking");

        northpJPanel.add(interruptilButton);
        northpJPanel.add(blockingButton);
        interruptilButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent event){
                interruptilButton.setEnabled(false);
                blockingButton.setEnabled(false);
                canncelButton.setEnabled(false);
                connectThread=new Thread(new Runnable(){
                    @Override
                    public void run() {
                        try{
                            connectInterruptibly();
                        } catch (Exception e) {
                            messages.append("
InterruptibleSocketTest.connectInterruptibly:
"+e);
                        }
                    }
                });
                connectThread.start();
            }
        });
        blockingButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                interruptilButton.setEnabled(false);
                blockingButton.setEnabled(false);
                canncelButton.setEnabled(false);
                connectThread=new Thread(new Runnable(){
                    @Override
                    public void run() {
                        try {
                            connectBlocking();
                        } catch (IOException e) {
                            messages.append("InterruptibleSocketTest.connectblocking"+e);
                        }
                    }
                });
                connectThread.start();
            }
        });
        
        canncelButton =new JButton("Cancel");
        canncelButton.setEnabled(false);
        northpJPanel.add(canncelButton);
        canncelButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                connectThread.interrupt();
                canncelButton.setEnabled(false);
                
            }
        });
        server =new TestServer();
        new Thread(server).start();
        
    }
    /**
     * 连接到服务器  终端I/O流  Interruptible
     * @throws IOException
     */
    public void connectInterruptibly()throws IOException{
        messages.append("Interruptible:
");
        SocketChannel channel=SocketChannel.open(new InetSocketAddress("192.168.0.141", 514));
        try {
            in=new Scanner(channel);
            while(!Thread.currentThread().isInterrupted()){
                messages.append("Reading");
                if(in.hasNextLine()){
                    String line=in.nextLine();
                    messages.append(line);
                    messages.append("
");
                }
            }
        }finally{
            channel.close();
            EventQueue.invokeLater(new Runnable() {
                @Override
                public void run() {
                    messages.append("Channel closed
");
                    interruptilButton.setEnabled(true);
                    blockingButton.setEnabled(true);
                }
            });
        }
    }
    /**
     * 连接到服务器  终端I/O流  Blocking
     * @throws IOException
     */
    public void connectBlocking()throws IOException{
        messages.append("Blocking:

");
        Socket socket=new Socket("localhost",8189);
        try {
            in=new Scanner(socket.getInputStream());
            while (!Thread.currentThread().isInterrupted()){
                if(in.hasNextLine()){
                    String line=in.nextLine();
                    messages.append(line);
                    messages.append("
");
                }
            }
        }finally{
            socket.close();
            EventQueue.invokeLater(new Runnable() {
                @Override
                public void run() {
                    messages.append("Socket closed
");
                    interruptilButton.setEnabled(false);
                }
            });
        }
    }
    /**
     * 测试服务器监听8189端口 并返回标示给客户端
     */
    class TestServer implements Runnable{
        @Override
        public void run() {
            try {
                ServerSocket s=new ServerSocket(8189);
                while(true){
                    Socket incoming=s.accept();
                    Runnable r=new TestServerHandler(incoming);
                    Thread t=new Thread(r);
                    t.start();
                }
            } catch (Exception e) {
                messages.append("
TestServer.run:
"+e);
            }
        }

    }
    class TestServerHandler implements Runnable{
        public TestServerHandler(Socket i){
            incoming=i;
        }
        @Override
        public void run() {
            try {
                OutputStream outputStream=incoming.getOutputStream();
                PrintWriter out=new PrintWriter(outputStream,true/*autoFulsh*/);
                while(counter<=100){
                    counter++;
                    if(counter<=10) out.print(counter);
                    Thread.sleep(100);
                }
                incoming.close();
                messages.append("Closing Server
");
            } catch (Exception e) {
                messages.append("
TestServerHandler.run:
"+e);
            }

        }
        private Socket incoming;
        private int counter;
    }

    private     Scanner in;
    private  JTextArea messages=null; 
    private  JButton interruptilButton,blockingButton,canncelButton;
    private     Thread connectThread;
    private TestServer server;

    public static final int WIDTH=550;
    public static final int HEIGHT=400;
}