一.引言
要掌握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;
}
}
}
}
1790
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
