socket链接---多线程 线程池---TCP/IP半包、粘包、分包

                     客户端socket请求链接Serversocket的请求链接，按照请求顺序进入客户端链接请求队列(队列的容量是由操做系统完成的)，ServerSocket的构造函数中的backlog就是用来指定请求队列的长度。 这个值会失效的三种状况：大于操做系统默认值|小于等于0|没有设置。 （见下面）html

                 serversocket中的accept方法，会从客户端链接请求队列（先进先出）中取出一个请求链接的请求，生成一个用于通讯的socket。只有当serversocket的accept方法成功返回时，才代表客户端与服务端创建了链接。java

　　socket链接是Java中进行通讯的基本方式，也是效率最高的方式，虽然他有http等让是进行http请求，可是若是是进行tcp、下载等通讯，仍是使用socket更好。Java中封装了很是完美的socket机制，使用也很是简单。主要包括socket和serversocket。算法

　　socket的使用很是简单，主要包括的构造方法有：socket(),socket(string host,string port),socket(Inetaddress address,int port)等，很是明白了，经过传入host和port进行socket的请求，当在建立相应的套接字实例的时候，会自动去对相应的ip和port进行链接，只有当链接成功，才表示相应的套接字创建成功，才能够进行相应的I/O操做。经过getOutputStream和getInputStream获取相应的输入输出流，进行相应的I/O操做，可是有一个是比较特别的，getChannel用来获取SocketChannel，他之因此特别是由于他属于java.nio.channels下面的类，其继承于java.nio.channels.SelectableChannel，就是说在进行nio非阻塞式的请求链接时，他很是有用，具体参见http://www.cnblogs.com/likwo/archive/2010/06/29/1767814.html。可能有些人会问，对于能够经过设置服务器链接的timeout来防止过多的阻塞，可是若是对于超过timeout，socket通常是抛出超时异常，这样就算对异常进行了处理，也将会重新创建socket链接，浪费消费 重建的资源。例如QQ聊天，当你打开一个聊天面板，好久不说话的时候，并不会自动为你断开socket链接，而是一直处于阻塞状态，直到你发送了新的信息，再进行处理，所以nio的阻塞方式会更好些。shell

　　对于serversocket也比较简单，经常使用的只有四个构造函数：数据库

l  ServerSocket()throws IOException 
l  ServerSocket(int port) throws IOException 
l  ServerSocket(int port, int backlog) throws IOException 
l  ServerSocket(int port, int backlog, InetAddress bindAddr) throws IOException  编程

分别对这几个构造进行简单的解释：windows

第一个无参构造，只是建立一个serversocket实例，可是不进行任何端口的监听，你还必须经过bind方法进行端口的绑定，好处就是在绑定以前能够进行相应属性的设置，例如so_reuseaddress等；设计模式

第二个构造函数须要一个端口(1024-65535)，通常不使用0-1023之间的，这个属于系统占用的预留端口，可是若是你传入的端口号为0，则会默认使用匿名端口，就是系统随机分配一个端口，进行暂时通讯，这个匿名方式，通常状况下不使用；浏览器

第三个构造函数须要一个端口，和一个backlog(监听对列大小)，serversocket进行某端口的监听，当有多个链接请求是，每一个请求默认都会放入一个请求队列里，若是你没有设置这个值，则默认为操做系统的值，根据不一样的系统有所不一样，例如40等，有几种状况，这个值将会失效：大于操做系统默认值|小于等于0|没有设置。若是设置了，而没有及时对队列进行处理，则会报ConnectException异常；缓存

第四个构造函数除了具备端口、队列大小外，还具备一个参数是ip地址，就是进行相应ip地址的绑定。固然，这个进行的是服务器ip地址的绑定，不会限制客户端的ip访问。当一台服务器存在多个网卡的时候，就须要经过这个参数来设置客户端访问的ip。

服务器socket的关闭，经过使用close进行关闭，使用isclosed进行判断，还能够进行端口的绑定判断。

对于服务器close方法，须要有一点进行说明：调用close方法以后，操做系统并不会当即进行端口的释放，依旧会对旧端口占用一段时间，以防止客户端发送的数据有延迟现象。所以有时候，就算你进行了close方法的调用，进行了端口的释放，可是若是你当即进行同一个端口的链接时，依旧会包端口占用异常，这个是能够理解的。

serversocket经过使用accept方法进行客户端请求的处理，每当请求队列里有客户端请求时，serversocket就会从队列顶端取一个socket请求进行处理，生成一个socket来负责与客户端通讯。若是一个时间只能处理一个socket，当有多个客户端请求时，则必需要排队处理，等待全部前面的socket处理完，这是个极其痛苦，而且不合理的过程。所以，引入了线程的概念。

　二  socket与多线程　

            为了实现客户端请求的快速相应和快速处理，据是高并发，则必须使用多线程机制。主题思想是：serversocket经过accept创建一个socket，而后起一个线程，把这个socket扔给新建的线程进行处理，而serversocket所在的主线程，则继续去监听端口，以此实现多线程通讯。通常有三种方式：

　　一、每个socket请求就创建一个线程。这个是最简单的方式，大体代码以下：

• public void service() {   
•   while (true) {   
•     Socket socket=null;   
•     try {   
•       socket = serverSocket.accept();                                            //接收客户链接   
•       Thread workThread=new Thread(new Handler(socket));            //建立一个工做线程   
•       workThread.start();                                                            //启动工做线程   
•     }catch (IOException e) {   
•        e.printStackTrace();   
•     }   
•   }   
• } 

　　上面的方式很是简单，可以处理基本的多线程问题，当数据量不大时，应该没有什么问题，可是若是数据量过大时，就会出现严重的性能，甚至是宕机问题。其缺点主要有以下几个：

　　a:每一个socket请求，创建一个链接，当每一个都是进行简短的通讯时，则异常的耗费系统创建、销毁线程资源。

　　b:若是创建线程太多，每一个线程都会占用必定的系统内存，这样将致使内存溢出。

　　c:频繁地对线程进行创建 销毁，会致使操做系统进行频繁的cpu切换线程切换，这样也会很是耗费系统资源。

二、本身实现线程池。

　　本身写线程池，可以对线程池的工做原理以及工做状况，更加的了解和控制，可是因为线程池必然涉及到多线程问题，所以为了防止出现死锁、线程泄漏、并发错误、任务过载等问题，须要性能很是好的机制，通常不推荐我的现实。若是非要实现，能够经过使用linkedlist<runnable>的数据结构来实现一个多线程队列。下面，仍是主要推荐jdk已经帮你实现的线程池。

三、使用jdk自带的线程池。jar包是：java.util.concurrent

　　这个jar包都是一些并发编程会常用到的工具类，主要有阻塞队列，原子操做的map以及线程池等。其基本包括Executor、ExecutorService接口和Executors类，两个接口定义了执行线程的方法，而Executors则定义了管理线程池的方法，主要能够建立的经常使用线程池有：

newSingleThreadScheduledExecutor() 建立一个能够延迟执行和定时执行的单线程线程池

newSingleThreadExecutor() 建立一个运行单线程的线程池               new LinkedBlockingQueue<Runnable>()) --任务队列

newScheduledThreadPool(int corePoolSize)  建立一个能够延迟执行和定时执行的线程池，设定线程数，经常使用来代替Timer（定时器)

newFixedThreadPool(int nThreads)  建立一个固定线程数的线程池    new LinkedBlockingQueue<Runnable>()) --任务队列

newCachedThreadPool() 建立一个带有缓冲区的线程池                             new SynchronousQueue<Runnable>()

而后经过生成的线程池的execute方法进行线程的执行，具体能够百度下哈哈

使用线程池有如下几点风险：

一、死锁。任何多线程都不可避免的问题。可是对于线程池可能会存在另外一种死锁：就是线程池中的线程都在等待一个资源，而这个资源须要执行A后获得，而因为线程池没有可用的线程，致使A没法执行，故而也会发生死锁。

二、系统资源不足。多线程一定须要大量的内存资源，可能出现内存泄漏问题。

三、并发错误。

四、线程泄漏。就是全部的线程池中的线程都在等待输入资源，或者都抛出了异常而没有捕获，则会致使线程池中全部的线程假死。

五、线程过载。运行线程过多，致使过载，这个能够经过设置线程池的大小来进行必定成功的避免。

至于如何避免，主要是要在使用多线程时要当心，同时不要使用destroy despause 等操做，尽可能使用sleep notify wait等操做，在这里不详细说明了。

二 补充：JDK1.5中线程池的简单使用(java.util.concurrent.ThreadPoolExecutor)    

在多线程大师Doug Lea的贡献下，在JDK1.5中加入了许多对并发特性的支持，例如：线程池。这里介绍的就是1.5种的线程池的简单使用方法。

1、简介 

线程池类为 java.util.concurrent.ThreadPoolExecutor，经常使用构造方法为：

 ThreadPoolExecutor(int corePoolSize,
                    int maximumPoolSize,
                    long keepAliveTime, TimeUnit unit,
                    BlockingQueue<Runnable> workQueue,
                    RejectedExecutionHandler handler)

• corePoolSize
  线程池维护线程的最少数量
• maximumPoolSiz
  线程池维护线程的最大数量
• keepAliveTime
  线程池维护线程所容许的空闲时间
• unit
  线程池维护线程所容许的空闲时间的单位
• workQueue
  线程池所使用的缓冲队列
• handler
  线程池对拒绝任务的处理策略

一个任务经过 execute(Runnable)方法被添加到线程池，任务就是一个 Runnable类型的对象，任务的执行方法就是 Runnable类型对象的run()方法。 

当一个任务经过execute(Runnable)方法欲添加到线程池时：

• 若是此时线程池中的数量小于corePoolSize，即便线程池中的线程都处于空闲状态，也要建立新的线程来处理被添加的任务。
• 若是此时线程池中的数量等于 corePoolSize，可是缓冲队列 workQueue未满，那么任务被放入缓冲队列。
• 若是此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，而且线程池中的数量小于maximumPoolSize，建新的线程来处理被添加的任务。
• 若是此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，而且线程池中的数量等于maximumPoolSize，那么经过 handler所指定的策略来处理此任务。

也就是：处理任务的优先级为： 
核心线程corePoolSize、任务队列workQueue、最大线程maximumPoolSize，若是三者都满了，使用handler处理被拒绝的任务。 

当线程池中的线程数量大于 corePoolSize时，若是某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池能够动态的调整池中的线程数。 

unit可选的参数为java.util.concurrent.TimeUnit中的几个静态属性： 
NANOSECONDS、MICROSECONDS、MILLISECONDS、SECONDS。 

workQueue我经常使用的是：java.util.concurrent.ArrayBlockingQueue 

handler有四个选择：

• ThreadPoolExecutor.AbortPolicy() 
  抛出java.util.concurrent.RejectedExecutionException异常
• ThreadPoolExecutor.CallerRunsPolicy() 
  由调用者执行这个任务
• ThreadPoolExecutor.DiscardOldestPolicy() 
  抛弃旧的任务
• ThreadPoolExecutor.DiscardPolicy() 
  抛弃当前的任务

 

2、通常用法举例

 package cn.simplelife.exercise;
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 public class TestThreadPool {
     private static int produceTaskSleepTime = 2;
     public static void main(String[] args) {
         //构造一个线程池
         ThreadPoolExecutor producerPool = new ThreadPoolExecutor(2, 4, 0, TimeUnit.SECONDS, new ArrayBlockingQueue(3), new ThreadPoolExecutor.DiscardOldestPolicy());
         //每隔produceTaskSleepTime的时间向线程池派送一个任务。
         int i=1;
         while(true){
             try {
                 Thread.sleep(produceTaskSleepTime);
                 String task = "task@ " + i;
                 System.out.println("put " + task);
                 producerPool.execute(new ThreadPoolTask(task));
                 i++;
             } catch (Exception e) {
                 e.printStackTrace();
             }
         }
     }
 }

 package cn.simplelife.exercise;
 import java.io.Serializable;
 /**
  * 线程池执行的任务
  * @author hdpan
  */
 public class ThreadPoolTask implements Runnable,Serializable{
     //JDK1.5中，每一个实现Serializable接口的类都推荐声明这样的一个ID
     private static final long serialVersionUID = 0;
     private static int consumeTaskSleepTime = 2000;
     private Object threadPoolTaskData;
     ThreadPoolTask(Object tasks){
         this.threadPoolTaskData = tasks;
     }
     //每一个任务的执行过程，如今是什么都没作，除了print和sleep，:)
     public void run(){
         System.out.println("start .."+threadPoolTaskData);
         try {
             //便于观察现象，等待一段时间
             Thread.sleep(consumeTaskSleepTime);
         } catch (Exception e) {
             e.printStackTrace();
         }
         threadPoolTaskData = null;
     }
 }

 

 

 对这两段程序的说明：

1. 在这段程序中，一个任务就是一个Runnable类型的对象，也就是一个ThreadPoolTask类型的对象。
2. 通常来讲任务除了处理方式外，还须要处理的数据，处理的数据经过构造方法传给任务。
3. 在这段程序中，main()方法至关于一个残忍的领导，他派发出许多任务，丢给一个叫 threadPool的不辞辛苦的小组来作。
   
   • 这个小组里面队员至少有两个，若是他们两个忙不过来， 任务就被放到任务列表里面。
   • 若是积压的任务过多，多到任务列表都装不下(超过3个)的时候，就雇佣新的队员来帮忙。可是基于成本的考虑，不能雇佣太多的队员， 至多只能雇佣 4个。
   • 若是四个队员都在忙时，再有新的任务， 这个小组就处理不了了，任务就会被经过一种策略来处理，咱们的处理方式是不停的派发， 直到接受这个任务为止(更残忍！呵呵)。
   • 由于队员工做是须要成本的，若是工做很闲，闲到 3SECONDS都没有新的任务了，那么有的队员就会被解雇了，可是，为了小组的正常运转，即便工做再闲，小组的队员也不能少于两个。
4. 经过调整 produceTaskSleepTime和 consumeTaskSleepTime的大小来实现对派发任务和处理任务的速度的控制， 改变这两个值就能够观察不一样速率下程序的工做状况。
5. 经过调整4中所指的数据，再加上调整任务丢弃策略， 换上其余三种策略，就能够看出不一样策略下的不一样处理方式。
6. 对于其余的使用方法，参看jdk的帮助，很容易理解和使用。

三TCP/IP，http，socket，长链接，短链接

TCP/IP是个协议组，可分为三个层次：网络层、传输层和应用层。 

   在网络层有: IP协议、ICMP协议、ARP协议、RARP协议和BOOTP协议。 
   在传输层中有:TCP协议与UDP协议。 
   在应用层有:   TCP包括FTP、HTTP、TELNET、SMTP等协议 
                      UDP包括DNS(域名系统协议)、SNMP（简单网络管理协议）、TFTP（小型文件传输协议/简单文件传输协议）等协议 

发送接收方式 

一、异步  
报文发送和接收是分开的，相互独立的，互不影响。这种方式又分两种状况： 
(1)异步双工：接收和发送在同一个程序中，由两个不一样的子进程分别负责发送和接收 
(2)异步单工：接收和发送是用两个不一样的程序来完成。 
二、同步  
报文发送和接收是同步进行，既报文发送后等待接收返回报文。 同步方式通常须要考虑超时问题，即报文发出去后不能无限等待，须要设定超时时间，超过该时间发送方再也不等待读返回报文，直接通知超时返回。   

Socket是什么 

     Socket是应用层与TCP/IP协议族通讯的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来讲，一组简单的接口就是所有，让Socket去组织数据，以符合指定的协议。

Socket 通讯示例

主机 A 的应用程序要能和主机 B 的应用程序通讯，必须经过 Socket 创建链接，而创建 Socket 链接必须须要底层 TCP/IP 协议来创建 TCP 链接。创建 TCP 链接须要底层 IP 协议来寻址网络中的主机。咱们知道网络层使用的 IP 协议能够帮助咱们根据 IP 地址来找到目标主机，可是一台主机上可能运行着多个应用程序，如何才能与指定的应用程序通讯就要经过 TCP 或 UPD 的地址也就是端口号来指定。这样就能够经过一个 Socket 实例惟一表明一个主机上的一个应用程序的通讯链路了。

四socket的半包，粘包与分包的问题

      首先看两个概念：  短链接--长链接

短链接：  

链接->传输数据->关闭链接  
HTTP是无状态的，浏览器和服务器每进行一次HTTP操做，就创建一次链接，但任务结束就中断链接。  
也能够这样说：短链接是指SOCKET链接后发送后接收完数据后立刻断开链接。  

长链接：  

链接->传输数据->保持链接 -> 传输数据-> 。。。 ->关闭链接。  
长链接指创建SOCKET链接后无论是否使用都保持链接，但安全性较差。