DBMNG数据库管理与应用

独立思考能力，对于从事科学研究或其他任何工作，都是十分必要的。

目录 / 分类

数据库基础
Access
SQLServer
MySQL
SQLite
Oracle
PostgreSQL
移动应用
经验分享
服务器配置
网文摘录
下载中心
CUBRID数据库
验证/二维/条形码
当前位置：首页 > 经验分享 > Java开发

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

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

 

先写个例子：

 

Java代码  
  1. public class TestThread extends Thread {  
  2.     @Override  
  3.     public void run() {  
  4.         while(true){  
  5.             System.out.println("一直运行");  
  6.             try {  
  7.                 sleep(3000);  
  8.             } catch (InterruptedException e) {  
  9.                 e.printStackTrace();  
  10.             }  
  11.         }  
  12.     }  
  13. }  

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

 

Java代码  
  1. public class TestThread extends Thread {  
  2.     private boolean flag = true;  
  3.     @Override  
  4.     public void run() {  
  5.         while(flag){  
  6.             System.out.println("一直运行");  
  7.             try {  
  8.                 sleep(3000);  
  9.             } catch (InterruptedException e) {  
  10.                 e.printStackTrace();  
  11.             }  
  12.         }  
  13.     }  
  14.       
  15.     public void stopThread(){  
  16.         this.flag = false;  
  17.     }  
  18. }  

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

 

Java代码  
  1. package cn.std.run.monitor;  
  2.   
  3. import java.io.IOException;  
  4. import java.net.ServerSocket;  
  5. import java.net.Socket;  
  6.   
  7. public class TestThread extends Thread {  
  8.     private boolean flag = true;  
  9.     @Override  
  10.     public void run() {  
  11.         try {  
  12.             ServerSocket serverSocket = new ServerSocket(50001);  
  13.             Socket socket = null;  
  14.             while (flag) {  
  15.                 socket = serverSocket.accept();  
  16.                 //SocketCtrlHandler.processRequest(socket);此处对Socket处理  
  17.             }  
  18.         } catch (IOException e) {  
  19.             e.printStackTrace();  
  20.         }  
  21.     }  
  22.       
  23.     public void stopThread(){  
  24.         this.flag = false;  
  25.     }  
  26. }  

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

 

Java代码  
  1. socket = serverSocket.accept();  

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

于是解决办法又有了：

 

Java代码  
  1. package cn.std.run.monitor;  
  2.   
  3. import java.io.IOException;  
  4. import java.net.ServerSocket;  
  5. import java.net.Socket;  
  6. import java.net.UnknownHostException;  
  7.   
  8. public class TestThread extends Thread {  
  9.     private boolean flag = true;  
  10.     @Override  
  11.     public void run() {  
  12.         try {  
  13.             ServerSocket serverSocket = new ServerSocket(50001);  
  14.             Socket socket = null;  
  15.             while (flag) {  
  16.                 socket = serverSocket.accept();  
  17.                 //SocketCtrlHandler.processRequest(socket);此处对Socket处理  
  18.             }  
  19.         } catch (IOException e) {  
  20.             e.printStackTrace();  
  21.         }  
  22.     }  
  23.       
  24.     public void stopThread(){  
  25.         this.flag = false;  
  26.         try {  
  27.             new Socket("localhost",50001);  
  28.         } catch (UnknownHostException e) {  
  29.             e.printStackTrace();  
  30.         } catch (IOException e) {  
  31.             e.printStackTrace();  
  32.         }  
  33.     }  
  34.     public static void main(String[] args) throws InterruptedException {  
  35.         TestThread tt = new TestThread();  
  36.         tt.start();  
  37.         sleep(3000);  
  38.         tt.stopThread();  
  39.     }  
  40. }  

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

 

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

 

Java代码  
  1. package cn.std.run.monitor;  
  2.   
  3. import java.io.IOException;  
  4. import java.net.ServerSocket;  
  5. import java.net.Socket;  
  6. import java.net.UnknownHostException;  
  7. import java.util.LinkedList;  
  8.   
  9. public class TestThread extends Thread {  
  10.     private boolean flag = true;  
  11.     private LinkedList<Object> pool = new LinkedList<Object>();  
  12.       
  13.     public void add(Object obj){  
  14.         synchronized (pool) {  
  15.             pool.add(obj);  
  16.             pool.notify();  
  17.         }  
  18.     }  
  19.       
  20.     @Override  
  21.     public void run() {  
  22.         Object obj = null;  
  23.         while(flag){  
  24.             synchronized (pool) {  
  25.                 while(pool.isEmpty()){  
  26.                     try {  
  27.                         pool.wait();  
  28.                     } catch (InterruptedException e) {  
  29.                         e.printStackTrace();  
  30.                     }  
  31.                 }  
  32.                 obj = pool.remove(0);  
  33.             }  
  34.             dispose(obj);  
  35.         }  
  36.     }  
  37.       
  38.     public void dispose(Object obj){  
  39.         System.out.println(obj);  
  40.     }  
  41.       
  42.     public void stopThread(){  
  43.         this.flag = false;  
  44.           
  45.     }  
  46.     public static void main(String[] args) throws InterruptedException {  
  47.         TestThread tt = new TestThread();  
  48.         tt.start();  
  49.         sleep(3000);  
  50.         tt.stopThread();  
  51.     }  
  52. }  

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

得这样才行：

 

Java代码  
  1. public void stopThread(){  
  2.         this.flag = false;  
  3.         add("");  
    }  

from:http://sziitjiang.iteye.com/blog/1707502
上一篇：Socket及ServerSocket使用说明例子
下一篇：java.net.SocketException: recvfrom failed: ECON...
本站文章内容，部分来自于互联网，若侵犯了您的权益，请致邮件chuanghui423#sohu.com(请将#换为@)联系，我们会尽快核实后删除。
Copyright © 2006-2023 DBMNG.COM All Rights Reserved. Powered by DEVSOARTECH            豫ICP备11002312号-2

豫公网安备 41010502002439号