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
mList = new ArrayList();
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 map = new LinkedHashMap();
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;
socket 的一个案例，注意要判断socket是否断开连接，断开连接后要自动停止监听循环和线程，不然cpu会很高 主要判断 try { // System.out.println("判断用户是否断开"); // 判断用户是否断...
DougLee可扩展的网络服务事件驱动Reactor模式基础版多线程版其他变体
java
.io包中分阻塞IOAPI一览Web服务器，分布式对象系统等等它们的共同特点Read请求解码请求报文业务处理编码响应报文发送响应实际应用中每一个步骤的不一样XML解析文件传输动态生成网页计算型服务每个线程运行一个handlerNote:异常处理省略压力持续增大时服务优雅的降级（客户端增多）性能随着资源（
CPU
，内存，磁盘，带宽）的提升持续增加高可用和性能的目标低延迟应对请求尖峰服务质量可控分而治之是解决扩展性问题的常用方法把处理流程切分成更小的task，每个task都是非阻塞的只有当任务准备好才去执行，IO事
private Server
Socket
server
Socket
;
private ExecutorService executorService; //线程池
private final int POOL_SIZE=4; //单个
CPU
时线程池中工作线程的数目
public EchoServer() throws IOException { server
Socket
= new Server
Socket
(port); //创建线程池
//Runtime的availableProcessors()方法返回当前系统的
CPU
的数目 //系统的
CPU
越多，线程池中工作线程的数目也越多 executorService= Executors.newFixedThreadPool(
Runtime.getRuntime().availableProcessors() * POOL_SIZE); System.out.println("服务器启动"); }
public void service() { while (true) {
Socket
socket
=null; try {
socket
= server
Socket
.accept();
executorService.execute(new Handler(
socket
)); }catch (IOException e) { e.printStackTrace(); } } }
public static void main(String args[])throws IOException { new EchoServer().service(); }
今天复习了一波多进程
提示：这里可以添加本文要记录的大概内容：
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。
提示：以下是本篇文章正文内容，下面案例可供参考
一、pandas是什么？
示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。
二、使用步骤
1.引入库
代码如下（示例）：
import numpy as
我们在监听客户端信息时，一般会使用while(true)的方式来循环监听。
当客户端没有发送消息，这时就造成了
cpu
的开销浪费
为了解决这个问题，可以在循环中添加判断，判断是否有消息被送过来，如果没有则休眠一段时间。
while (true) //循环从客户端获取信息
//没有访问连接时，进程休眠
let
socket
;
if(localStorage.getItem('
socket
')) {
socket
= JSON.parse(localStorage.getItem('
socket
'));
// 创建一个不自动连接的
socket
对象
let temp = io({autoConnect: false});
对于一个双向的tcp会话，tcp应为双向的持续长链接，
而有可能我们会通过多次创建
socket
实现类似多次通信，此种做法是较为浪费资源了。
故 研究一下如何 一个
socket
多次通信
flush()
java
io 里面的方法 ，清空缓冲区，立即输出数据
强调一下， flush 之前，其io流 所加载的数据 最后应有个换行符，否则程序会阻塞
代码如下：
Server
import
java
.io.BufferedReader;
import
java
.io.BufferedWriter;
import j
socket
=server
Socket
.accept();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
/***处理微信获取名字带特殊符号**/
public static String deWXName(String showName){
if(!SimpleToof.checkNotNull(showName))return null;
Pattern emoji = Pattern.compile ("[\ud83c...
这段代码定义了一个名为 map1 的 Map 变量，并从 result 列表中获取第一个元素（即 result.get(0)），将这个元素赋值给 map1。
如果想要优化这段代码，可以考虑：
1. 使用
Java
8 的 Stream API，将 for 循环改为 stream.forEach()。
2. 使用并行流，将 stream.forEach() 改为 stream.parallel().forEach()，可以利用多核
CPU
的优势，提升代码的执行效率。
3. 如果要对 map1 进行多次访问，可以考虑将 map1 缓存在局部变量中，避免每次都从 result 列表中取值。
4. 对于 result 列表，如果只需要访问一次，可以考虑使用 Iterator 或者 ListIterator，避免每次都枚举整个列表。
希望这些建议能帮到你！
Java.lang.OutOfMemoryError: unable to create new native thread (server responded connection closed)
解决阿里云ECS磁盘在线扩容不生效
