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

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

 

先写个例子：

 

public class TestThread extends Thread {
	@Override
	public void run() {
		while(true){
			System.out.println("一直运行");
			try {
				sleep(3000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

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

 

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，循环结束，线程也就停止了！不过问题又来了，如果是线程里面是这样子的：你看怎么解决？

 

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方法就不行了，因为在

 

socket = serverSocket.accept();

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

于是解决办法又有了：

 

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，循环结束，线程停止！

 

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

 

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<Object> pool = new LinkedList<Object>();
	
	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不做特殊处理，也不能成功关闭线程，

得这样才行：

 

public void stopThread(){
		this.flag = false;
		add("");
	}

 原理跟上面的ServerSocket堵塞一样，这个就是我说的主动式关闭！好吧，再加一句，原谅我菜，呵呵~~