一.引言
要掌握socket通信就要先知道socket通信原理,最好有一个例子,更着例子跑一遍,看看源码。socket通信是利用面向连接的、可靠的、基于字节流的传输层通信协议tcp,把数据流分区成适当长度的报文段,之后TCP把结果包传给IP层,由它来通过网络将包传送给接收端。
本地的进程间通信(IPC)有很多种方式,但可以总结为下面4类:
-
消息传递(管道、FIFO、消息队列)
-
同步(互斥量、条件变量、读写锁、文件和写记录锁、信号量)
-
共享内存(匿名的和具名的)
-
远程过程调用(Solaris门和Sun RPC)
二.tcp原理
这里就不详谈,网上搜都有,不过还是要大概说一下的,说白了就跟打电话差不多,所谓的三次握手协议,(用A,B举例),A和B通信,1.A(客户端)发送SYN(SEQ=x)报文给服务器端,进入SYN_SEND状态,2.B(服务端)收到SYN报文,回应一个SYN (SEQ=y)ACK(ACK=x+1)报文,进入SYN_RECV状态。3.A(客户端)收到服务器端的SYN报文,回应一个ACK(ACK=y+1)报文,进入Established状态,如果A几次收到的相同的确认码或没收到,A会认为我发的信息已经丢失,会启动重传机制。建立一个连接需要三次握手,而终止一个连接要经过四次握手。
三.正言
在设计模式中,Socket其实就是一个门面模式,它把复杂的TCP/IP协议族隐藏在Socket接口后面,对用户来说,一组简单的接口就是全部,让Socket去组织数据,以符合指定的协议。socket的基本操作:socket()函数,bind()函数,accept()函数,listen()、connect()函数,read()、write()函数,close()函数等。
四.线程池介绍
线程是一个操作系统概念。操作系统负责这个线程的创建、挂起、运行、阻塞和终结操作。而操作系统创建线程、切换线程状态、终结线程都要进行CPU调度——这是一个耗费时间和系统资源的事情。
最理想的处理方式是,将处理请求的线程数量控制在一个范围,既保证后续的请求不会等待太长时间,又保证物理机将足够的资源用于请求处理本身。 另外,一些操作系统是有最大线程数量限制的。当运行的线程数量逼近这个值的时候,操作系统会变得不稳定。这也是我们要限制线程数量的原因。
线程池的基本使用方式
JAVA语言为我们提供了两种基础线程池的选择:ScheduledThreadPoolExecutor和ThreadPoolExecutor
new ThreadPoolExecutor(intcorePoolSize, int maximumPoolSize,
long keepAliveTime, TimeUnitunit,
BlockingQueue workQueue,
RejectedExecutionHandlerhandler)
corePoolSize: 线程池维护线程的最少数量
maximumPoolSize:线程池维护线程的最大数量
keepAliveTime: 线程池维护线程所允许的空闲时间
unit: 线程池维护线程所允许的空闲时间的单位
workQueue: 线程池所使用的缓冲队列
handler: 线程池对拒绝任务的处理策略
// 构造一个线程池
ThreadPoolExecutor threadPool =new ThreadPoolExecutor(2, 4, 3, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(3),
new ThreadPoolExecutor.DiscardOldestPolicy());
一定要注意一个概念,即存在于线程池中容器的一定是Thread对象。
出于某些原因线程池并没有马上运行这些任务,而是送入一个队列等待执行
● 核心线程:线程池主要用于执行任务的是“核心线程”,“核心线程”的数量是你创建线程时所设置的corePoolSize参数决定的。如果不进行特别的设定,线程池中始终会保持corePoolSize数量的线程数(不包括创建阶段)。
● 非核心线程:一旦任务数量过多(由等待队列的特性决定),线程池将创建“非核心线程”临时帮助运行任 务。你设置的大于corePoolSize参数小于maximumPoolSize参数的部分,就是线程池可以临时创建的“非核心线程”的最大数量。这种 情况下如果某个线程没有运行任何任务,在等待keepAliveTime时间后,这个线程将会被销毁,直到线程池的线程数量重新达到 corePoolSize。
● maximumPoolSize参数也是当前线程池允许创建的最大线程数量。那么如果设置的corePoolSize参数和设置的maximumPoolSize参数一致时,线程池在任何情况下都不会回收空闲线程。keepAliveTime和timeUnit也就失去了意义。
● keepAliveTime参数和timeUnit参数也是配合使用的。keepAliveTime参数指明等待时间的量化值,timeUnit指明量化值单位。例如keepAliveTime=1,timeUnit为TimeUnit.MINUTES,代表空闲线程的回收阀值为1分钟。
queueCapacity:任务队列容量(阻塞队列)
l 当核心线程数达到最大时,新任务会放在队列中排队等待执行
keepAliveTime:线程空闲时间
当线程空闲时间达到keepAliveTime时,线程会退出,直到线程数量=corePoolSize
如果allowCoreThreadTimeout=true,则会直到线程数量=0
allowCoreThreadTimeout:允许核心线程超时
rejectedExecutionHandler:任务拒绝处理器
当线程数已经达到maxPoolSize,切队列已满,会拒绝新任务
当线程池被调用shutdown()后,会等待线程池里的任务执行完毕,再shutdown。如果在调用shutdown()和线程池真正shutdown之间提交任务,会拒绝新任务
线程池会调用rejectedExecutionHandler来处理这个任务。如果没有设置默认是AbortPolicy,会抛出异常
ThreadPoolExecutor类有几个内部实现类来处理这类情况:
l AbortPolicy 丢弃任务,抛运行时异常
l CallerRunsPolicy 执行任务
l DiscardPolicy 忽视,什么都不会发生
l DiscardOldestPolicy 从队列中踢出最先进入队列(最后一个执行)的任务
二、ThreadPoolExecutor执行顺序:
线程池按以下行为执行任务
1. 当线程数小于核心线程数时,创建线程。
2. 当线程数大于等于核心线程数,且任务队列未满时,将任务放入任务队列。
3. 当线程数大于等于核心线程数,且任务队列已满
a) 若线程数小于最大线程数,创建线程
b) 若线程数等于最大线程数,抛出异常,拒绝任务
线程池的等待队列
在使用ThreadPoolExecutor线程池的时候,需要指定一个实现了BlockingQueue接口的任务等待队列。在ThreadPoolExecutor线程池的API文档中,一共推荐了三种等待队列,它们是:SynchronousQueue、LinkedBlockingQueue和ArrayBlockingQueue;
有限队列
● SynchronousQueue:是这样 一种阻塞队列,其中每个 put 必须等待一个 take,反之亦然。同步队列没有任何内部容量。翻译一下:这是一个内部没有任何容量的阻塞队列,任何一次插入操作的元素都要等待相对的删除/读取操作,否则进行插入操作的线程就要一直等待,反之亦然。
● ArrayBlockingQueue:一个由数组支持的有界阻塞队列。此队列按 FIFO(先进先出)原则对元素进行排序。
无限队列
● LinkedBlockingQueue:它可以指定容量也可以不指定容量。由于它具有“无限容量”的特性,所以我还是将它归入了无限队列的范畴
拒绝任务(handler)
在ThreadPoolExecutor线程池中还有一个重要的接口:RejectedExecutionHandler。
在ThreadPoolExecutor中已经提供了四种可以直接使用的RejectedExecutionHandler接口的实现:
● CallerRunsPolicy: 这个拒绝处理器,将直接运行这个任务的run方法。但是,请注意并不是在ThreadPoolExecutor线程池中的线程中运行,而是直接调用这个任务实现的run方法。源代码如下:
● AbortPolicy:
这个处理器,在任务被拒绝后会创建一个RejectedExecutionException异常并抛出。这个处理过程也是ThreadPoolExecutor线程池默认的RejectedExecutionHandler实现。
● DiscardPolicy:
DiscardPolicy处理器,将会默默丢弃这个被拒绝的任务,不会抛出异常,也不会通过其他方式执行这个任务的任何一个方法,更不会出现任何的日志提示。
● DiscardOldestPolicy:
这个处理器很有意思。它会检查当前ThreadPoolExecutor线程池的等待队列。并调用队列的poll()方法,将当前处于等待队列列头的等待任务强行取出,然后再试图将当前被拒绝的任务提交到线程池执行
五.例子
这里把数据存放到es上
1.客户端
package client;
import java.io.DataInputStream;点击打开链接
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.Socket;
import java.net.UnknownHostException;
import java.security.KeyStore;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManagerFactory;
public class SocketClient extends Thread
{
protected String hostIp = "127.0.0.1";
protected int hostPort = 8823;
InputStream fis;
DataOutputStream ps;
DataInputStream inputStream;
File fi;
DataInputStream dis;
Socket client;
String resId = "5";
String fileName = "debug";
String groupName = "group";
String resType = "2";
public SocketClient(String resId, String fileName, String groupName, String logText, String resType)
{
this.resId = resId;
this.fileName = fileName;
this.groupName = groupName;
this.logText = logText;
this.resType = resType;
}
public void run()
{
long startRun = System.currentTimeMillis();
try
{
sendMessage();
}
catch (Exception e)
{
e.printStackTrace();
}
long endRun = System.currentTimeMillis();
System.out.println("run time = " + (endRun - startRun));
}
public void setUpConnection()
{
try
{
//加密
/*String clientTrustKeyStoreFile = "D:\\ihos.keystore";
String clientTrustKeyStorePwd = "foxclienttrustks";
KeyStore clientTrustKeyStore = KeyStore.getInstance("JKS");
clientTrustKeyStore.load(new FileInputStream(clientTrustKeyStoreFile), clientTrustKeyStorePwd.toCharArray());
TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
tmf.init(clientTrustKeyStore);
SSLContext sslContext = SSLContext.getInstance("TLSv1");
sslContext.init(null, tmf.getTrustManagers(), null);*/
client = new Socket(hostIp, hostPort);
ps = new DataOutputStream(client.getOutputStream());
}
catch (UnknownHostException e)
{
System.out.println("Error setting up socket connection: unknown host at " + hostIp + ":" + hostPort);
}
catch (IOException e)
{
System.out.println("Error setting up socket connection: " + e);
}catch (Exception e)
{
System.out.println("Error setting up socket connection: " + e);
}
}
public static void main(String[] args)
{
for (int i = 0; i < 1; i++)
{
SocketClient client1 = new SocketClient("task", "error", "task",
"IN_TIME=2018-03-05 01:01:01#@%index=and_socket_test#@%key1={\"k1_test1\":\"tttttt\",\"k2_test2\":2,\"key2\":{\"key1_1\":\"hahahaaaa\",\"t2\":3}}#@%key2={\"k2_test1\":\"hahahaaaa\",\"k2_test2\":3}#@%HOST_NO=10.10.10.220#@%TASK_ID=132#@%DATA_ID=1#@%ihos-_obj=key1,key2", "1");
client1.start();
}
}
}
2.服务端
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import javax.net.ssl.SSLServerSocket;
import javax.net.ssl.SSLServerSocketFactory;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import util.AppConfigReader;
import util.Auth;
public class MDAPSocketServer implements Runnable
{
private Log log = LogFactory.getLog(this.getClass());
private ServerSocket serverSocket;
private ThreadPoolExecutor threadPool;
public MDAPSocketServer()
{
this.init();
}
public void init()
{
try
{
if(MDAPConstant.SSL_PATH != null && !MDAPConstant.SSL_PATH.equals("")){
SSLServerSocketFactory serverSocketFactory = Auth.getSSLContext().getServerSocketFactory();
SSLServerSocket serverSocket = (SSLServerSocket) serverSocketFactory.createServerSocket(MDAPConstant.PORT);
// 要求客户端身份验证
//serverSocket.setNeedClientAuth(MDAPConstant.SSL_CLIENT_AUTH);
this.serverSocket = serverSocket;
}else{
serverSocket = new ServerSocket(MDAPConstant.PORT);
}
this.threadPool = new ThreadPoolExecutor(MDAPConstant.THREADNUMMIN,
MDAPConstant.THREADNUMMAX, MDAPConstant.THREADIDLETIME,
TimeUnit.MILLISECONDS, new SynchronousQueue<Runnable>(),
new ThreadPoolExecutor.CallerRunsPolicy());
threadPool.allowCoreThreadTimeOut(true);
String keyvalues = AppConfigReader.getProperty( "keyvalues",
"ResId#FileName#GroupName#LogText#FormatetLog#LogTime#ResType");
String temp[] = keyvalues.split("#");
for (int i = 0; i < temp.length; i++)
{
MDAPConstant.KEYVALUEMAP.put(String.valueOf(i + 1), temp[i]);
}
} catch (Exception e)
{
log.error("初始化socket异常", e);
}
}
public static void main(String[] args)
{
MDAPSocketServer socketServer = new MDAPSocketServer();
MDAPHeartThread mdapHeartThread = new MDAPHeartThread();
mdapHeartThread.start();
socketServer.run();
}
public void run()
{
while (true)
{
Socket socket = null;
boolean enter = false;
try
{
socket = serverSocket.accept();
String socketIp = socket.getInetAddress().toString();
String AllowIPList = AppConfigReader.getProperty("AllowIPList",
"/127.0.0.1");
String Allow = AppConfigReader.getProperty("Allow", "true");
if (Allow.equalsIgnoreCase("true")
&& AllowIPList.contains(socketIp))
{
enter = true;
} else if (!Allow.equalsIgnoreCase("true"))
{
enter = true;
}
log.debug("ip enter:" + enter);
if (enter)
{
threadPool
.execute(new MDAPServerThread(socket, threadPool));
log.info("Enter Thread,start...."
+ "THE CURRENT NUMBER OF THREADS IN THE POOL:"
+ threadPool.getPoolSize());
} else
{
log.info(socketIp + " IS UNALLOWED IP, CLOSE SOCKET");
if (socket != null)
{
socket.close();
}
}
} catch (Exception e)
{
log.error("socket service() Exception: " + e);
if (socket != null)
{
try
{
socket.close();
} catch (IOException e1)
{
log.error("socket.close() IOException: " + e1);
}
}
if (serverSocket != null)
{
try
{
serverSocket.close();
} catch (IOException e1)
{
log.error("serverSocket.close() IOException: " + e1);
}
}
if (!threadPool.isShutdown())
{
threadPool.shutdown();
log.error("threadPool shutdown");
}
break;
}
}
}
}