socket 的一个案例，注意要判断socket是否断开连接，断开连接后要自动停止监听循环和线程，不然cpu会很高
主要判断
try {
// System.out.println("判断用户是否断开");
// 判断用户是否断开
socket.sendUrgentData(0xFF);
} catch (Exception e) {
System.out.println("message断开连接");
// 关闭socket
socket.close();
// 释放进程 -释放cpu
Thread.yield();
// 退出循环 -释放cpu
break;
}案例代码
package com.fridge.socket;
import java.io.DataInputStream;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import org.json.JSONArray;
import org.json.JSONObject;
import com.fridge.units.DateUtil;
import com.fridge.units.SimpleToof;
public class SocketService {
private static final int PORT = 7625;
private List<Socket> mList = new ArrayList<Socket>();
private ServerSocket server = null;
private ExecutorService mExecutorService = null;
public static void main(String[] args) {
new SocketService();
}
public SocketService() {
try {
server = new ServerSocket(PORT);
mExecutorService = Executors.newCachedThreadPool();
System.out.println("Socket服务器已启动...");
Socket client = null;
while (true) {
client = server.accept();
if (!SimpleToof.checkNotNull(client)) {
continue;
}
mList.add(client);
mExecutorService.execute(new Service(client));
}
} catch (Exception e) {
e.printStackTrace();
}
}
public static class Service implements Runnable {
// 用于保存用户的Socket
public static Map<String, Socket> map = new LinkedHashMap<String, Socket>();
private Socket socket;
// private static DataInputStream dataInputStream = null;
// private static PrintStream printStream = null;
// 连接成功
public Service(Socket socket) {
this.socket = socket;
try {
// PrintStream printStream = new PrintStream(socket.getOutputStream());
// String message = "成功连接服务器";
// sendMessage(socket, message);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 发送消息 给客户端
*
* @param socketServiceUtil
* @param message
* 消息
*/
public static boolean sendMessage(Socket socket, String message) {
try {
PrintStream printStream = new PrintStream(socket.getOutputStream());
byte[] responseBuffer = message.getBytes("GBK");
printStream.write(responseBuffer, 0, responseBuffer.length);
printStream.flush();
// System.out.println(DateUtil.getTypeDate_2(new Date()) + "服务器发送1：" + message);
} catch (Exception e) {
System.out.println(DateUtil.getTypeDate_2(new Date()) + "发送消息给当前用户错误！3");
return true;
}
return true;
}
/**
* 发送给指定的设备
*
* @param message
* @return
*/
public static Boolean sendByDev_id(String dev_id, String message) {
boolean bl = false;
try {
Socket socket = map.get(dev_id);
if (!SimpleToof.checkNotNull(socket)) {
return bl;
}
bl = sendMessage(socket, message);
} catch (Exception e) {
e.printStackTrace();
bl = false;
}
return bl;
}
public void run() {
try {
String message = "";
DataInputStream dataInputStream = null;
while (true) {
// 获取接收流
dataInputStream = new DataInputStream(socket.getInputStream());
byte[] buffer = new byte[1024 * 1]; // 缓冲区的大小1M
dataInputStream.read(buffer); // 处理接收到的报文，转换成字符串
message = new String(buffer, "GBK");
// System.out.println("message(" + message.trim() + ")");
// 判断是否断开连接 start 连接中会一直读取流直到有消息才会进行下一个循环，断开后会很快就读取到空的流，会一直循环占用cpu
if (!SimpleToof.checkNotNull(message) || !SimpleToof.checkNotNull(message.trim())) {
// System.out.println("message(为空" + message.trim() + ")");
try {
// System.out.println("判断用户是否断开");
// 判断用户是否断开
socket.sendUrgentData(0xFF);
} catch (Exception e) {
System.out.println("message断开连接");
// 关闭socket
socket.close();
// 释放进程 -释放cpu
Thread.yield();
// 退出循环 -释放cpu
break;
}
}
// 判断是否断开连接 end
if (SimpleToof.checkNotNull(message) && SimpleToof.checkNotNull(message.trim())) {
try {
JSONObject object = new JSONObject(message.trim());
String dev_id = object.optString("dev_id", "");
String category = object.optString("category", "");
// System.out.println(
// DateUtil.getTypeDate_2(new Date()) + "--" + dev_id + ":客户端发送" +
// message.trim());
// 添加到map中
if (SimpleToof.checkNotNull(dev_id)) {
map.put(dev_id, socket);
}
// sendByDev_id(dev_id, message);
// 开门或关门
// {"dev_id":"869696043774525","category":"71","open":"0","errno":"0"}
if (SimpleToof.checkNotNull(category) && "71".equals(category)) {
String open = object.optString("open", "");
String errno = object.optString("errno", "");
if (SimpleToof.checkNotNull(open) && SimpleToof.checkNotNull(errno)) {
// System.out.println("开门或关门1");
WSJsonUtil.lockStart(object);
}
}
// 设备开机信号
if (SimpleToof.checkNotNull(category) && "72".equals(category)) {
JSONObject obj = new JSONObject();
obj.put("category", "1");
sendMessage(socket, obj.toString());
}
// 心跳包
if (SimpleToof.checkNotNull(category) && "73".equals(category)) {
}
// 服务器查询锁状态
if (SimpleToof.checkNotNull(category) && "74".equals(category)) {
// System.out.println("服务器查询锁状态1");
WSJsonUtil.setDevLockStart(object);
}
} catch (Exception e) {
System.out.println("读取出错");
// sendMessage(socket, "读取出错");
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 发送给所有
*
* @param message
* @return
*/
public static String sendAll(String message) {
// System.out.println("map.size()：" + map.size());
// System.out.println(message + "服务器发送给全部:" + string);
for (String string : map.keySet()) {
Socket socket = map.get(string);
boolean bl = sendMessage(socket, message);
if (!bl) {
map.remove(string);
}
}
return message;
}
/**
* 判断是否已经断开连接
*
* @param socketServiceUtil
*/
public static void isReconnect() {
try {
// 判断用户是否断开
for (String string : map.keySet()) {
Socket socket = map.get(string);
try {
// System.out.println("判断用户是否断开");
// 判断用户是否断开
socket.sendUrgentData(0xFF);
} catch (Exception e) {
map.remove(string);
socket.close();
System.out.println("isReconnect断开连接");
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 获取连上的信息
*
* @return
*/
public static JSONObject getMessage() {
JSONObject object = new JSONObject();
try {
JSONArray array = new JSONArray();
for (String string : map.keySet()) {
JSONObject object2 = new JSONObject();
object2.put("dev_id", string);
array.put(object2);
}
object.put("dev_ids", array);
// JSONArray array2 = new JSONArray();
// for (String string : ips) {
// JSONObject obj = new JSONObject();
// obj.put("ip", string);
// array2.put(obj);
// }
// object.put("ips", array2);
} catch (Exception e) {
e.printStackTrace();
}
return object;
}
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
