java 关闭serversocket_java主动式关闭线程-ServerSocket堵塞关闭的一个法子

在Java上，启动一个线程容易，让一个线程不断运行，也很容易，只要一个while循环，一直做死循环就行了。不过问题来了，那关闭线程怎么办？

先写个例子：

Java代码

public class TestThread extends Thread {

@Override

public void run() {

while(true){

System.out.println("一直运行");

try {

sleep(3000);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

这样就可以让线程一直运行了，没错，这样是可以，让线程关闭的最好方法不是使用destroy方法，而是让线程自己结束。这个就是主动式关闭。所以一般都是这样处理一个线程：

Java代码

public class TestThread extends Thread {

private boolean flag = true;

@Override

public void run() {

while(flag){

System.out.println("一直运行");

try {

sleep(3000);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

public void stopThread(){

this.flag = false;

}

}

当这个线程正在运行时，可以用别的线程调用 stopThread()方法，这个时候flag就变成了false，循环结束，线程也就停止了！不过问题又来了，如果是线程里面是这样子的：你看怎么解决？

Java代码

package cn.std.run.monitor;

import java.io.IOException;

import java.net.ServerSocket;

import java.net.Socket;

public class TestThread extends Thread {

private boolean flag = true;

@Override

public void run() {

try {

ServerSocket serverSocket = new ServerSocket(50001);

Socket socket = null;

while (flag) {

socket = serverSocket.accept();

//SocketCtrlHandler.processRequest(socket);此处对Socket处理

}

} catch (IOException e) {

e.printStackTrace();

}

}

public void stopThread(){

this.flag = false;

}

}

这个时候，stopThread方法就不行了，因为在

Java代码

socket = serverSocket.accept();

处，程序会一直堵塞，就像是在循环里面停止了一样，只有等到新的Socket连接进来了，才能不再堵塞。

于是解决办法又有了：

Java代码

package cn.std.run.monitor;

import java.io.IOException;

import java.net.ServerSocket;

import java.net.Socket;

import java.net.UnknownHostException;

public class TestThread extends Thread {

private boolean flag = true;

@Override

public void run() {

try {

ServerSocket serverSocket = new ServerSocket(50001);

Socket socket = null;

while (flag) {

socket = serverSocket.accept();

//SocketCtrlHandler.processRequest(socket);此处对Socket处理

}

} catch (IOException e) {

e.printStackTrace();

}

}

public void stopThread(){

this.flag = false;

try {

new Socket("localhost",50001);

} catch (UnknownHostException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

}

public static void main(String[] args) throws InterruptedException {

TestThread tt = new TestThread();

tt.start();

sleep(3000);

tt.stopThread();

}

}

在stopThread方法里面new Socket,让线程不再堵塞，进入下一个循环，但是进入下一个循环判断的时候已经变为false，循环结束，线程停止！

那再来一个例子，线程等待队列：

Java代码

package cn.std.run.monitor;

import java.io.IOException;

import java.net.ServerSocket;

import java.net.Socket;

import java.net.UnknownHostException;

import java.util.LinkedList;

public class TestThread extends Thread {

private boolean flag = true;

private LinkedList pool = new LinkedList();

public void add(Object obj){

synchronized (pool) {

pool.add(obj);

pool.notify();

}

}

@Override

public void run() {

Object obj = null;

while(flag){

synchronized (pool) {

while(pool.isEmpty()){

try {

pool.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

obj = pool.remove(0);

}

dispose(obj);

}

}

public void dispose(Object obj){

System.out.println(obj);

}

public void stopThread(){

this.flag = false;

}

public static void main(String[] args) throws InterruptedException {

TestThread tt = new TestThread();

tt.start();

sleep(3000);

tt.stopThread();

}

}

这是一个经常使用的线程排队，如果这时候stopThead不做特殊处理，也不能成功关闭线程，

得这样才行：

Java代码

public void stopThread(){

this.flag = false;

add("");

}

from:http://sziitjiang.iteye.com/blog/1707502