求一段代码，扫描自己的计算机端口是否被占用

Question

一般是用下面这段程序来扫描被占用端口的for(int port = 0; i < 65535; i++){
  try{
    ServerSocket ss = new ServerSocket(port);
  } catch(Exception e){
     System.out.println("port " + port + " 已经被占用");
  }
}问题是效率太低，等死我了，想让大家帮我升级成多线程版的，做成“生成者-消费者”模式吧
计算机资源有限，就只允许100个线程同时运行吧，当然，同步是必不可少的，千万别忘了：）可能要用到wait(),notify()好吧，就说到这，有问题了我再补充。

Answer 1

CSDN有个获得系统资源的包.里面有NetStat类,你研究一下
下载地址:http://download.csdn.net/source/367067

Answer 2

public class ScanUsedSockets {    private static int counter;    private static synchronized int next() {
        counter += 1;
        if (counter > 65535) {
            counter = -1;
        } else if (counter % 1000 == 999) {
            System.out.println("..." + counter);
        }
        return counter;
    }    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread() {
                @Override
                public void run() {
                    int port = ScanUsedSockets.next();
                    while (port > -1) {
                        try {
                            new ServerSocket(port).close();
                            Thread.sleep(100);
                        } catch (IOException e) {
                            System.out.println("端口 " + port + " 已经被占用。");
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        port = ScanUsedSockets.next();
                    }
                }
            }.start();
        }
    }}

Answer 3

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketException;
import java.net.SocketTimeoutException;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class TcpPortScanner { private static final int MAX_THREAD_NUM = 700;
private static final int MAX_TIMEOUT = 3000;
private static final String HOSTNAME = "127.0.0.1"; @SuppressWarnings("unchecked")
public static void main(String[] args) {
final class Worker implements Callable<Boolean> {
private int port = 0;
public Worker(int port) {
if (port < 0 || port > 0xFFFF) {
throw new IllegalArgumentException("port out of range:" + port);
}
this.port = port;
}
public Boolean call() throws Exception {
boolean open = false;
Socket tcpskt = null;
try {
tcpskt = new Socket();
tcpskt.setSoLinger(false, 0);
tcpskt.setKeepAlive(false);
tcpskt.setTcpNoDelay(true);
tcpskt.connect(new InetSocketAddress(HOSTNAME, this.port), MAX_TIMEOUT);
open = tcpskt.isConnected();
} catch (SocketTimeoutException e) {
} catch (SocketException e) {
} catch (IOException e) {
} finally {
if (tcpskt != null && !tcpskt.isClosed()) {
try {
tcpskt.close();
} catch (IOException e) {
}
}
}
return Boolean.valueOf(open);
}
}
Future<Boolean>[] result = new Future[65536];
ExecutorService tPool = Executors.newFixedThreadPool(MAX_THREAD_NUM);
for (int i = 1; i < result.length; i++) {
result[i] = tPool.submit(new Worker(i));
}
tPool.shutdown();
try {
System.out.println("TCP Port");
System.out.println("=====================");
for (int i = 1; i < result.length; i++) {
if (result[i].get().booleanValue()) {
System.out.println(i);
}
}
System.out.println("完成 TCP 端口扫描！");
} catch (InterruptedException e) {
} catch (ExecutionException e) {
}
}}