周末跟朋友讨论了一些 TCP 的问题，在查阅《Linux 服务器高性能编程》这本书的时候，发现书上写了这么一句话：

书上说，处于 TIME_WAIT 状态的连接，在收到相同四元组的 SYN 后，会回 RST 报文，对方收到后就会断开连接。

书中作者只是提了这么一句话，没有给予源码或者抓包图的证据。

起初，我看到也觉得这个逻辑也挺符合常理的，但是当我自己去啃了 TCP 源码后，发现并不是这样的。

所以，今天就来讨论下这个问题，「在 TCP 正常挥手过程中，处于 TIME_WAIT 状态的连接，收到相同四元组的 SYN 后会发生什么？」

问题现象如下图，左边是服务端，右边是客户端：

先说结论

在跟大家分析 TCP 源码前，我先跟大家直接说下结论。

针对这个问题，关键是要看 SYN 的「序列号和时间戳」是否合法，因为处于 TIME_WAIT 状态的连接收到 SYN 后，会判断 SYN 的「序列号和时间戳」是否合法，然后根据判断结果的不同做不同的处理。

先跟大家说明下， 什么是「合法」的 SYN？

• 合法 SYN：客户端的 SYN 的「序列号」比服务端「期望下一个收到的序列号」要大，并且 SYN 的「时间戳」比服务端「最后收到的报文的时间戳」要大。
• 非法 SYN：客户端的 SYN 的「序列号」比服务端「期望下一个收到的序列号」要小，或者 SYN 的「时间戳」比服务端「最后收到的报文的时间戳」要小。

上面 SYN 合法判断是基于双方都开启了 TCP 时间戳机制的场景，如果双方都没有开启 TCP 时间戳机制，则 SYN 合法判断如下：

• 合法 SYN：客户端的 SYN 的「序列号」比服务端「期望下一个收到的序列号」要大。
• 非法 SYN：客户端的 SYN 的「序列号」比服务端「期望下一个收到的序列号」要小。

收到合法 SYN

如果处于 TIME_WAIT 状态的连接收到「合法的 SYN 」后，就会重用此四元组连接，跳过 2MSL 而转变为 SYN_RECV 状态，接着就能进行建立连接过程。

用下图作为例子，双方都启用了 TCP 时间戳机制，TSval 是发送报文时的时间戳：

上图中，在收到第三次挥手的 FIN 报文时，会记录该报文的 TSval （21），用 ts_recent 变量保存。然后会计算下一次期望收到的序列号，本次例子下一次期望收到的序列号就是 301，用 rcv_nxt 变量保存。

处于 TIME_WAIT 状态的连接收到 SYN 后，因为 SYN 的 seq（400） 大于 rcv_nxt（301），并且 SYN 的 TSval（30） 大于 ts_recent（21），所以是一个「合法的 SYN」，于是就会重用此四元组连接，跳过 2MSL 而转变为 SYN_RECV 状态，接着就能进行建立连接过程。

收到非法的 SYN

如果处于 TIME_WAIT 状态的连接收到「非法的 SYN 」后，就会再回复一个第四次挥手的 ACK 报文，客户端收到后，发现并不是自己期望收到确认号（ack num），就回 RST 报文给服务端。

用下图作为例子，双方都启用了 TCP 时间戳机制，TSval 是发送报文时的时间戳：

上图中，在收到第三次挥手的 FIN 报文时，会记录该报文的 TSval （21），用 ts_recent 变量保存。然后会计算下一次期望收到的序列号，本次例子下一次期望收到的序列号就是 301，用 rcv_nxt 变量保存。

处于 TIME_WAIT 状态的连接收到 SYN 后，因为 SYN 的 seq（200） 小于 rcv_nxt（301），所以是一个「非法的 SYN」，就会再回复一个与第四次挥手一样的 ACK 报文，客户端收到后，发现并不是自己期望收到确认号，就回 RST 报文给服务端。

客户端等待一段时间还是没收到 SYN + ACK 后，就会超时重传 SYN 报文，重传次数达到最大值后，就会断开连接。

PS：这里先埋一个疑问，处于 TIME_WAIT 状态的连接，收到 RST 会断开连接吗？

源码分析

下面源码分析是基于 Linux 4.2 版本的内核代码。

Linux 内核在收到 TCP 报文后，会执行 tcp_v4_rcv 函数，在该函数和 TIME_WAIT 状态相关的主要代码如下：

int tcp_v4_rcv(struct sk_buff *skb)
{
  struct sock *sk;
 ...
  //收到报文后，会调用此函数，查找对应的 sock
 sk = __inet_lookup_skb(&tcp_hashinfo, skb, __tcp_hdrlen(th), th->source,
          th->dest, sdif, &refcounted);
 if (!sk)
  goto no_tcp_socket;

process:
  //如果连接的状态为 time_wait，会跳转到 do_time_wait
 if (sk->sk_state == TCP_TIME_WAIT)
  goto do_time_wait;

...

do_time_wait:
  ...
  //由tcp_timewait_state_process函数处理在 time_wait 状态收到的报文
 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
    // 如果是TCP_TW_SYN，那么允许此 SYN 重建连接
    // 即允许TIM_WAIT状态跃迁到SYN_RECV
    case TCP_TW_SYN: {
      struct sock *sk2 = inet_lookup_listener(....);
      if (sk2) {
          ....
          goto process;
      }
    }
    // 如果是TCP_TW_ACK，那么，返回记忆中的ACK
    case TCP_TW_ACK:
      tcp_v4_timewait_ack(sk, skb);
      break;
    // 如果是TCP_TW_RST直接发送RESET包
    case TCP_TW_RST:
      tcp_v4_send_reset(sk, skb);
      inet_twsk_deschedule_put(inet_twsk(sk));
      goto discard_it;
     // 如果是TCP_TW_SUCCESS则直接丢弃此包，不做任何响应
    case TCP_TW_SUCCESS:;
 }
 goto discard_it;
}

该代码的过程：

1. 接收到报文后，会调用 __inet_lookup_skb() 函数查找对应的 sock 结构；
2. 如果连接的状态是 TIME_WAIT，会跳转到 do_time_wait 处理；
3. 由 tcp_timewait_state_process() 函数来处理收到的报文，处理后根据返回值来做相应的处理。

先跟大家说下，如果收到的 SYN 是合法的，tcp_timewait_state_process() 函数就会返回 TCP_TW_SYN，然后重用此连接。如果收到的 SYN 是非法的，tcp_timewait_state_process() 函数就会返回 TCP_TW_ACK，然后会回上次发过的 ACK。

接下来，看 tcp_timewait_state_process() 函数是如何判断 SYN 包的。

enum tcp_tw_status
tcp_timewait_state_process(struct inet_timewait_sock *tw, struct sk_buff *skb,
      const struct tcphdr *th)
{
 ...
  //paws_reject 为 false，表示没有发生时间戳回绕
  //paws_reject 为 true，表示发生了时间戳回绕
 bool paws_reject = false;

 tmp_opt.saw_tstamp = 0;
  //TCP头中有选项且旧连接开启了时间戳选项
 if (th->doff > (sizeof(*th) >> 2) && tcptw->tw_ts_recent_stamp) { 
  //解析选项
    tcp_parse_options(twsk_net(tw), skb, &tmp_opt, 0, NULL);

  if (tmp_opt.saw_tstamp) {
   ...
      //检查收到的报文的时间戳是否发生了时间戳回绕
   paws_reject = tcp_paws_reject(&tmp_opt, th->rst);
  }
 }

....

  //是SYN包、没有RST、没有ACK、时间戳没有回绕，并且序列号也没有回绕，
 if (th->syn && !th->rst && !th->ack && !paws_reject &&
     (after(TCP_SKB_CB(skb)->seq, tcptw->tw_rcv_nxt) ||
      (tmp_opt.saw_tstamp && //新连接开启了时间戳
       (s32)(tcptw->tw_ts_recent - tmp_opt.rcv_tsval) < 0))) { //时间戳没有回绕
    // 初始化序列号
    u32 isn = tcptw->tw_snd_nxt + 65535 + 2; 
    if (isn == 0)
      isn++;
    TCP_SKB_CB(skb)->tcp_tw_isn = isn;
    return TCP_TW_SYN; //允许重用TIME_WAIT四元组重新建立连接
 }


 if (!th->rst) {
    // 如果时间戳回绕，或者报文里包含ack，则将 TIMEWAIT 状态的持续时间重新延长
  if (paws_reject || th->ack)
    inet_twsk_schedule(tw, &tcp_death_row, TCP_TIMEWAIT_LEN,
        TCP_TIMEWAIT_LEN);

     // 返回TCP_TW_ACK, 发送上一次的 ACK
    return TCP_TW_ACK;
 }
 inet_twsk_put(tw);
 return TCP_TW_SUCCESS;
}

如果双方启用了 TCP 时间戳机制，就会通过 tcp_paws_reject() 函数来判断时间戳是否发生了回绕，也就是「当前收到的报文的时间戳」是否大于「上一次收到的报文的时间戳」：

• 如果大于，就说明没有发生时间戳绕回，函数返回 false。
• 如果小于，就说明发生了时间戳回绕，函数返回 true。

从源码可以看到，当收到 SYN 包后，如果该 SYN 包的时间戳没有发生回绕，也就是时间戳是递增的，并且 SYN 包的序列号也没有发生回绕，也就是 SYN 的序列号「大于」下一次期望收到的序列号。就会初始化一个序列号，然后返回 TCP_TW_SYN，接着就重用该连接，也就跳过 2MSL 而转变为 SYN_RECV 状态，接着就能进行建立连接过程。

如果双方都没有启用 TCP 时间戳机制，就只需要判断 SYN 包的序列号有没有发生回绕，如果 SYN 的序列号大于下一次期望收到的序列号，就可以跳过 2MSL，重用该连接。

如果 SYN 包是非法的，就会返回 TCP_TW_ACK，接着就会发送与上一次一样的 ACK 给对方。

在 TIME_WAIT 状态，收到 RST 会断开连接吗？

在前面我留了一个疑问，处于 TIME_WAIT 状态的连接，收到 RST 会断开连接吗？

会不会断开，关键看 net.ipv4.tcp_rfc1337 这个内核参数（默认情况是为 0）：

• 如果这个参数设置为 0， 收到 RST 报文会提前结束 TIME_WAIT 状态，释放连接。
• 如果这个参数设置为 1， 就会丢掉 RST 报文。

源码处理如下：

enum tcp_tw_status
tcp_timewait_state_process(struct inet_timewait_sock *tw, struct sk_buff *skb,
      const struct tcphdr *th)
{
....
  //rst报文的时间戳没有发生回绕
 if (!paws_reject &&
     (TCP_SKB_CB(skb)->seq == tcptw->tw_rcv_nxt &&
      (TCP_SKB_CB(skb)->seq == TCP_SKB_CB(skb)->end_seq || th->rst))) {

      //处理rst报文
      if (th->rst) {
        //不开启这个选项，当收到 RST 时会立即回收tw，但这样做是有风险的
        if (twsk_net(tw)->ipv4.sysctl_tcp_rfc1337 == 0) {
          kill:
          //删除tw定时器，并释放tw
          inet_twsk_deschedule_put(tw);
          return TCP_TW_SUCCESS;
        }
      } else {
        //将 TIMEWAIT 状态的持续时间重新延长
        inet_twsk_reschedule(tw, TCP_TIMEWAIT_LEN);
      }

      ...
      return TCP_TW_SUCCESS;
    }
}

TIME_WAIT 状态收到 RST 报文而释放连接，这样等于跳过 2MSL 时间，这么做还是有风险。

sysctl_tcp_rfc1337 这个参数是在 rfc 1337 文档提出来的，目的是避免因为 TIME_WAIT 状态收到 RST 报文而跳过 2MSL 的时间，文档里也给出跳过 2MSL 时间会有什么潜在问题。

TIME_WAIT 状态之所以要持续 2MSL 时间，主要有两个目的：

• 防止历史连接中的数据，被后面相同四元组的连接错误的接收；
• 保证「被动关闭连接」的一方，能被正确的关闭；

详细的为什么要设计 TIME_WAIT 状态，我在这篇有详细说明：如果 TIME_WAIT 状态持续时间过短或者没有，会有什么问题？

虽然 TIME_WAIT 状态持续的时间是有一点长，显得很不友好，但是它被设计来就是用来避免发生乱七八糟的事情。

《UNIX网络编程》一书中却说道：TIME_WAIT 是我们的朋友，它是有助于我们的，不要试图避免这个状态，而是应该弄清楚它。

所以，我个人觉得将 net.ipv4.tcp_rfc1337 设置为 1 会比较安全。

总结

在 TCP 正常挥手过程中，处于 TIME_WAIT 状态的连接，收到相同四元组的 SYN 后会发生什么？

如果双方开启了时间戳机制：

• 如果客户端的 SYN 的「序列号」比服务端「期望下一个收到的序列号」要大，并且SYN 的「时间戳」比服务端「最后收到的报文的时间戳」要大。那么就会重用该四元组连接，跳过 2MSL 而转变为 SYN_RECV 状态，接着就能进行建立连接过程。
• 如果客户端的 SYN 的「序列号」比服务端「期望下一个收到的序列号」要小，或者SYN 的「时间戳」比服务端「最后收到的报文的时间戳」要小。那么就会再回复一个第四次挥手的 ACK 报文，客户端收到后，发现并不是自己期望收到确认号，就回 RST 报文给服务端。

在 TIME_WAIT 状态，收到 RST 会断开连接吗？

• 如果 net.ipv4.tcp_rfc1337 参数为 0，则提前结束 TIME_WAIT 状态，释放连接。
• 如果 net.ipv4.tcp_rfc1337 参数为 1，则会丢掉该 RST 报文。

完！

1. 线程状态图

这是线程的7状态模型图，常见的7大状态之间的转换关系也在上面。多线程之间的通信主要用到4个方法，wait（）、wait（long time）、notify（）、notifyAll（），其他方法在多线程基础中都有介绍。

1. wait（）：作用是使当前线程从调用处中断并且释放锁转入等待队列，直到收到notify或者notifyAll的通知才能从等待队列转入锁池队列，没有收到停止会一直死等。

2. wait（long time）：相比wait多了一个等待的时间time，如果经过time(毫秒)时间后没有收到notify或者notifyAll的通知，自动从等待队列转入锁池队列。

3. notify（）：随机从等待队列中通知一个持有相同锁的一个线程，如果没有持有相同锁的wait线程那么指令忽略无效。注意是持有相同锁，并且是随机没有固定的，顺序这一点在生产者消费者模型中很重要，会造成假死的状态。

4. notifyAll（）：通知等待队列中的持有相同锁的所有线程，让这些线程转入锁池队列。如果没有持有相同锁的wait线程那么指令忽略无效。

5. wait的两个方法都需要注意中断的问题，wait中断是从语句处中断并且释放锁，当再次获得锁时是从中断处继续向下执行。

6. notify 和 notifyAll方法通知是延迟通知，必须等待当前线程体执行完所有的同步方法/代码块中的语句退出释放锁才通知wait线程。

7. 这四个方法都必须在获得锁的情况下才能调用，否则会出现非法监视状态异常。

2. 基本使用

2.1、wait立即释放锁 与 notify/notifyAll延迟通知

class MyService{
    private Object  obj = new Object();
    public void waitfun(){
        try{
            synchronized (obj){
                System.out.println("begin   wait: " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
                obj.wait();
                System.out.println("end     wait: " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
            }
        } catch (Exception e){
            e.printStackTrace();
        }
    }
    public void notifyfun(){
        try{
            synchronized (obj){
                System.out.println("begin notify: " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
                obj.notify();
                System.out.println("end   notity: " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
            }
        } catch (Exception e){
            e.printStackTrace();
        }
    }
}

class ThreadA extends Thread{
    private MyService myService;
    public ThreadA(String name, MyService myService) {
        super(name);
        this.myService = myService;
    }

    @Override
    public void run() {
        myService.waitfun();
    }
}

class ThreadB extends Thread{
    private MyService myService;
    public ThreadB(String name, MyService myService) {
        super(name);
        this.myService = myService;
    }

    @Override
    public void run() {
        myService.notifyfun();
    }
}

public class Demo {

    public static void main(String[] args) throws InterruptedException {
        MyService myService = new MyService();
        ThreadA a = new ThreadA("Thread", myService);
        a.start();
        

        Thread.sleep(1000);
        ThreadB b = new ThreadB("Thread", myService);
        b.start();
    }
}

分析：a线程调用wait方法进行中断，立即释放锁；main线程睡眠1000ms后，b线程启动获得对象锁开始通知，然后执行.notify语句，最后输出了通知完毕；执行完了b线程同步方法/代码块里的所有语句才进行通知，a线程收到通知进行执行，从中断处继续向下执行最后得到上图结果。

2.2、wait(long time)的自动唤醒

class Service{ }

class ServiceA extends Thread{
    private Service service;

    public ServiceA(String name, Service service) {
        super(name);
        this.service = service;
    }

    @Override
    public void run() {
        try{
            synchronized (service){
                System.out.println("begin   wait: " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
                service.wait(5000);
                System.out.println("end     wait: " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
            }
            System.out.println(Thread.currentThread().getName()+"等待5000ms后自动唤醒!");
        } catch (Exception e){
            e.printStackTrace();
        }
    }
}

class ServiceB extends Thread{
    private Service service;

    public ServiceB(String name, Service service) {
        super(name);
        this.service = service;
    }

    @Override
    public void run() {
        try{
            synchronized (service){
                System.out.println("begin   wait: " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
                System.out.println("end     wait: " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
            }
        } catch (Exception e){
            e.printStackTrace();
        }
    }
}
public class Demo01 {
    public static void main(String[] args) throws InterruptedException {
        Service service = new Service();

        ServiceA a = new ServiceA("ThreadA",service);
        ServiceB b = new ServiceB("ThreadB",service);

        a.start();
        Thread.sleep(100);
        b.start();
    }
}

方法主体中并没有对wait的线程进行唤醒停止，但是经过time秒后A线程自动唤醒了。wait(long time)方法在经过time（毫秒）之后的等待即使没有收到 通知 会自动从等待队列转入锁池队列。

2.3、提前唤醒，处于wait（long time）的线程如果正处在time等待的时间内提前收到通知会直接进入锁池队列，time时间提前失效。

class Service{ }

class ServiceA extends Thread{
    private Service service;

    public ServiceA(String name, Service service) {
        super(name);
        this.service = service;
    }

    @Override
    public void run() {
        try{
            long begin = 0;
            long end = 0;
            synchronized (service){
                begin = System.currentTimeMillis();
                System.out.println("begin   wait: " + Thread.currentThread().getName() + " " + begin);
                service.wait(8000);
                end = System.currentTimeMillis();
                System.out.println("end     wait: " + Thread.currentThread().getName() + " " + end);
            }
            System.out.println(Thread.currentThread().getName() + "等待" + (end-begin) + "ms后唤醒!");
        } catch (Exception e){
            e.printStackTrace();
        }
    }
}

class ServiceB extends Thread{
    private Service service;

    public ServiceB(String name, Service service) {
        super(name);
        this.service = service;
    }

    @Override
    public void run() {
        try{
            synchronized (service){
                System.out.println("begin   wait: " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
                service.notify();
                System.out.println("end     wait: " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
            }
        } catch (Exception e){
            e.printStackTrace();
        }
    }
}

public class Demo01 {
    public static void main(String[] args) throws InterruptedException {
        Service service = new Service();
        ServiceA a = new ServiceA("ThreadA",service);
        ServiceB b = new ServiceB("ThreadB",service);

        a.start();
        Thread.sleep(1000);
        b.start();
    }
}

2.5、单一通知：notify方法随机的从等待队列中唤醒一个持有相同锁的线程进入锁池队列争抢同步锁，如果没有持有相同锁的wait的线程则notify指令无效。

class MyService{
    private Object  obj = new Object();
    public void waitfun(){
        try{
            synchronized (obj){
                System.out.println("begin   wait: " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
                obj.wait();
                System.out.println("end     wait: " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
            }
        } catch (Exception e){
            e.printStackTrace();
        }
    }
    public void notifyfun(){
        try{
            synchronized (obj){
                System.out.println("begin notify: " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
                obj.notify();
                System.out.println("end   notity: " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
            }
        } catch (Exception e){
            e.printStackTrace();
        }
    }
}

class ThreadA extends Thread{
    private MyService myService;
    public ThreadA(String name, MyService myService) {
        super(name);
        this.myService = myService;
    }

    @Override
    public void run() {
        myService.waitfun();
    }
}

class ThreadB extends Thread{
    private MyService myService;
    public ThreadB(String name, MyService myService) {
        super(name);
        this.myService = myService;
    }

    @Override
    public void run() {
        myService.notifyfun();
    }
}

public class notifyone {

    public static void main(String[] args) throws InterruptedException {
        MyService myService = new MyService();
        for(int i = 1;i <= 5;i++){
            new ThreadA("Thread"+i, myService).start();
        }

        Thread.sleep(1000);
        for(int i = 6;i <= 12;i++){
            new ThreadB("Thread"+i,myService).start();
            Thread.sleep(500);
        }
    }
}

2.6、全部通知：notifyAll方法将等待队列中所有的持有相同锁的线程唤醒进入锁池队列争抢同步锁。

/*
    notifyAll全部通知，通知顺序是随机的
    由JVM决定，并没有固定顺序
 */

class MyService1{
    private Object obj = new Object();
    public void waitfun(){
        try{
            synchronized (obj){
                System.out.println("begin   wait: " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
                obj.wait();
                System.out.println("end     wait: " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
            }
        } catch (Exception e){
            e.printStackTrace();
        }
    }
    public void notifyfun(){
        try{
            synchronized (obj){
                System.out.println("begin notify: " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
                obj.notifyAll();
                System.out.println("end   notity: " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
            }
        } catch (Exception e){
            e.printStackTrace();
        }
    }
}

class ThreadA1 extends Thread{
    private MyService1 myService;
    public ThreadA1(String name, MyService1 myService) {
        super(name);
        this.myService = myService;
    }

    @Override
    public void run() {
        myService.waitfun();
    }
}

class ThreadB1 extends Thread{
    private MyService1 myService;
    public ThreadB1(String name, MyService1 myService) {
        super(name);
        this.myService = myService;
    }

    @Override
    public void run() {
        myService.notifyfun();
    }
}


public class notifyall {
    public static void main(String[] args) throws InterruptedException {

        MyService1 myService = new MyService1();
        for(int i = 1;i <= 5;i++){
            new ThreadA1("ThreadA"+i,myService).start();
        }
        Thread.sleep(5000);

        new ThreadB1("noticeThread",myService).start();
    }
}

3. 异常释放锁

学习synchronized时，有几种情况当同步方法 / 块中遇到异常会提前结束线程体。

• sleep + interrupt：这两个方法没有先后顺序，无论哪个先执行，发生异常时线程体提前中止。

• 手动制造异常：当执行到某个程度的时候，如果想提前结束直接利用throw new Exception()。

• 使用stop方法直接摧毁线程，这个方法已经废弃了不推荐使用。

• 使用return 提前结束线程体的运行，但是这种方法并不是异常。

3.1、手动制造异常提前终止

import java.util.ArrayList;
class MyList{
    volatile private ArrayList<String> list = new ArrayList<>();            //保证可见性

    public void add(){
        list.add("123");
    }

    public int size(){
        return list.size();
    }
}
class MyService{

    private MyList list = new MyList();
    private Object obj = new Object();

    public void waitMethod(){
        try{
            synchronized (obj){
                if (list.size() != 5){
                    System.out.println("begin wait : "+ Thread.currentThread().getName() + " " + System.currentTimeMillis());
                    obj.wait();
                    System.out.println("end   wait : "+ Thread.currentThread().getName() + " " + System.currentTimeMillis());
                }
            }
        } catch (Exception e){
            e.printStackTrace();
        }
    }

    public void notifyMethod(){
        try{
            synchronized (obj){
                for(int i = 1;i <= 10;i++){
                    list.add();
                    System.out.println("add添加了" + i +"个元素.");
                    if(list.size() == 5){
                        obj.notify();
                        throw new Exception();		//没有异常list中将会有10个元素，制造异常则只有5个
                        System.out.println("发出通知，等我执行完再执行.");		//不会执行
                    }
                }
            }
        }catch (Exception e){
         //   e.printStackTrace();
        }
    }
}

class ThreadA extends Thread{

    private MyService myService;

    public ThreadA(MyService myService) {
        this.myService = myService;
    }

    @Override
    public void run() {
        myService.notifyMethod();
    }
}
class ThreadB extends Thread{

    private MyService myService;

    public ThreadB(MyService myService) {
        this.myService = myService;
    }

    @Override
    public void run() {
        myService.waitMethod();
    }
}

public class Test01 {
    public static void main(String[] args) throws InterruptedException {
        MyService myService = new MyService();
        ThreadA a = new ThreadA(myService);
        a.setName("ThreadA");
        ThreadB b = new ThreadB(myService);
        b.setName("ThreadB");
        b.start();
        Thread.sleep(1000);
        a.start();
    }
}

3.2、wait + interrupt方法提前终止线程

class A{
    private Object obj;

    public A(Object object) {
        this.obj = object;
    }

    public void method(){
        synchronized (obj){
            System.out.println("begin wait : "+ Thread.currentThread().getName() + " " + System.currentTimeMillis());
            try {
                obj.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("end   wait : "+ Thread.currentThread().getName() + " " + System.currentTimeMillis());
        }
    }
}

class MyThread extends Thread{
    private A a;

    public MyThread(A a) {
        this.a = a;
    }

    @Override
    public void run() {
        a.method();
    }
}
public class Test02 {
    public static void main(String[] args) throws InterruptedException {
        Object object = new Object();

        A a = new A(object);

        MyThread myThread = new MyThread(a);
        myThread.start();

        Thread.sleep(5000);
        myThread.interrupt();
    }
}

4. 总结

1. sleep睡眠是抱锁睡眠，不会进入等待队列而是进入阻塞状态。如上图

2. wait（）方法会立即释放锁中断，进入等待队列。唤醒后仍然需要去争抢获得同步锁才能继续从中断处向下执行。

3. wait（long time）方法会在time毫秒后自动唤醒，如果提前遇到通知会提前进入等待队列。

4. notify / notifyAll 通知是随机顺序通知的，并没有固定的顺序进行通知具体的某个线程。并且只通知持有相同锁的wait线程。

5. 灵活使用异常能够帮助线程体的提前终止。

这个知识点在写代码上，感觉还是挺重要的，打算总结一下吧。
打算从以下5个方面去总结。
一：TIME_WAIT状态是什么
首先，这个是TCP状态转换图里面的某个状态。这个可以参考unix网络编程。

从图中可以看出，在一个客户端与服务器通信的过程当中，主动关闭的一方会进入这个状态。
二：TIME_WAIT状态怎么出现的
好了，其实第一点已经说明了，这个状态是怎么出现的了，就是，主动关闭的一方会进入这个状态。

#include <stdio.h>
#include <ctype.h>
#include <unistd.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

#define SERV_PORT 9000  //本服务器要监听的端口号，一般1024以下的端口很多都是属于周知端口，所以我们一般采用1024之后的数字做端口号

int main(int argc, char *const *argv)
{    
    //这些演示代码的写法都是固定套路，一般都这么写

    //服务器的socket套接字【文件描述符】
    int listenfd = socket(AF_INET, SOCK_STREAM, 0);    //创建服务器的socket，大家可以暂时不用管这里的参数是什么，知道这个函数大概做什么就行

    struct sockaddr_in serv_addr;                  //服务器的地址结构体
    memset(&serv_addr,0,sizeof(serv_addr));
    
    //设置本服务器要监听的地址和端口，这样客户端才能连接到该地址和端口并发送数据
    serv_addr.sin_family = AF_INET;                //选择协议族为IPV4
    serv_addr.sin_port = htons(SERV_PORT);         //绑定我们自定义的端口号，客户端程序和我们服务器程序通讯时，就要往这个端口连接和传送数据
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); //监听本地所有的IP地址；INADDR_ANY表示的是一个服务器上所有的网卡（服务器可能不止一个网卡）多个本地ip地址都进行绑定端口号，进行侦听。

    int result;
    result = bind(listenfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));//绑定服务器地址结构体
    if(result  == -1)
    {
        char *perrorinfo = strerror(errno); 
        printf("bind返回的值为%d,错误码为:%d，错误信息为:%s;\n",result,errno,perrorinfo);
        return -1;
    }
    result = listen(listenfd, 32);     //参数2表示服务器可以积压的未处理完的连入请求总个数，客户端来一个未连入的请求，请求数+1，连入请求完成，c/s之间进入正常通讯后，请求数-1
    if(result == -1)
    {        
        char *perrorinfo = strerror(errno); 
        printf("listen返回的值为%d,错误码为:%d，错误信息为:%s;\n",result,errno,perrorinfo);
        return -1;
    }

    int connfd;
    const char *pcontent = "I sent sth to client!\n"; //指向常量字符串区的指针
    for(;;)
    {
        //卡在这里，等客户单连接，客户端连入后，该函数走下去【注意这里返回的是一个新的socket——connfd，后续本服务器就用connfd和客户端之间收发数据，而原有的lisenfd依旧用于继续监听其他连接】        
        connfd = accept(listenfd, (struct sockaddr*)NULL, NULL);

        //发送数据包给客户端
        write(connfd,pcontent,strlen(pcontent)); //注意第一个参数是accept返回的connfd套接字
        printf("本服务器给客户端发送了一串字符~~~~~~~~~~~!\n");
        
        //只给客户端发送一个信息，然后直接关闭套接字连接；
        close(connfd); 
    } //end for
    close(listenfd);     //实际本简单范例走不到这里，这句暂时看起来没啥用
    return 0;
}

使用以上程序作为服务端，然后用telnet作为客户端，发起连接，这个时候，根据程序说明，会马上关闭这个连接，然后，我们用netstat命令观察可以看到除了有一个端口处于监听状态意外，还有的就是出现了TIME_WAIT这个状态了。
三：TIME_WAIT状态出现了有什么影响
感觉第二点出现的情况，如果我们马上关闭这个服务端程序，然后又重新启动，这个时候你会发现这个程序启动失败失败的原因是bind error了，提示地址已复用，也就是同一个地址和端口只能同时绑定一次。我们试想，如果在服务端处理大量连接的时候，某个时候，服务端挂掉了，这个时候由于TIME_WAIT状态的存在，导致程序运行不起来，那不坏菜了，服务端还怎么提供服务？？
四：为什么要有TIME_WAIT状态
我们再来谈谈为什么需要这个状态？什么，居然要有这个状态？？第三点不是说有这个状态会有不好的情况吗？当然，先别急，既然这个状态的出现就有他出现的道理，对于第三点出现时会有一些影响，当然，我们也是可以避免的，我们在第五点去谈这个问题。

为什么要有这个状态，参考了unix网络编程当中谈到的两点。
一：:可靠地实现TCP全双工的终止。

这句话怎么理解呢？我们知道tcp是全双工的，
我们看上面的图，在左边，
如果没有TIME_WAIT这个状态，
那么服务端便会从FIN_WAIT2这个状态->CLOSED状态，
这两个状态的转变有什么影响吗？我们看上图，
如果服务端最后一次发送的ack包，
由于某种原因丢了，客户端没有收到，
那么根据tcp的特性，客户端会再次发送FIN包，
如果此时服务端处于TIME_WAIT状态，
就会重发这个ack包，如果此时服务端处于CLOSED状态，
无论客户端有没有收到ack包，
因为这个连接已经关闭了，所以服务端也就不会重发最
后一个ack包了，这种断开就是不太友好的，
如果有了TIME_WAIT状态，那么便有助于可靠
的实现TCP全双工连接的终止。

二：允许老的重复的TCP数据包在网络中消逝（丢弃）。

怎么理解这句话呢？这个要结合TIME_WAIT
为什么要存在的时间是1-4min有关了，
根据资料说明，一个数据包在网络上存
活的时间大概是1-4min，我们还是从反
面来想这个问题，如果没有这个状态，
那么在服务端发送最后一次ack包以后，
服务端会马上处于CLOSE状态，然后，
假设这个时候有一个新的客户端连进来，
假设这个新的客户端的IP,PORT与之前
的一个客户端是一样的，没有TIME_WAIT状态，
最后一个ack的包可能就会发到这个新的连接
上来。。。。。。如果有TIME_WAIT状态，
即使有人伪造一个相同IP和PORT的连接，
也不会让这个包发到刚刚建立起来的连接上。

五：如何避免TIME_WAIT状态
使用套接字选项可以避免这个状态的产生，从而可以让服务端程序在出现异常时可以快速的重启，恢复运行。
setsockopt，这个函数一般位于socket与bind之间，如果想探讨为什么一般位于这两个函数之间的，可以网上搜索。

#include <stdio.h>
#include <ctype.h>
#include <unistd.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

#define SERV_PORT 9000  //本服务器要监听的端口号，一般1024以下的端口很多都是属于周知端口，所以我们一般采用1024之后的数字做端口号

int main(int argc, char *const *argv)
{    
    //这些演示代码的写法都是固定套路，一般都这么写

    //服务器的socket套接字【文件描述符】
    int listenfd = socket(AF_INET, SOCK_STREAM, 0);    //创建服务器的socket，大家可以暂时不用管这里的参数是什么，知道这个函数大概做什么就行

    struct sockaddr_in serv_addr;                  //服务器的地址结构体
    memset(&serv_addr,0,sizeof(serv_addr));
    
    //设置本服务器要监听的地址和端口，这样客户端才能连接到该地址和端口并发送数据
    serv_addr.sin_family = AF_INET;                //选择协议族为IPV4
    serv_addr.sin_port = htons(SERV_PORT);         //绑定我们自定义的端口号，客户端程序和我们服务器程序通讯时，就要往这个端口连接和传送数据
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); //监听本地所有的IP地址；INADDR_ANY表示的是一个服务器上所有的网卡（服务器可能不止一个网卡）多个本地ip地址都进行绑定端口号，进行侦听。


    //setsockopt（）:设置一些套接字参数选项；
    //参数2：是表示级别，和参数3配套使用，也就是说，参数3如果确定了，参数2就确定了;
    //参数3：允许重用本地地址
    int  reuseaddr=1; //开启
    if(setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR, (const void *) &reuseaddr,sizeof(reuseaddr)) == -1)
    {
         char *perrorinfo = strerror(errno); 
        printf("setsockopt(SO_REUSEADDR)返回值为%d,错误码为:%d，错误信息为:%s;\n",-1,errno,perrorinfo);
    }

    int result;
    result = bind(listenfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));//绑定服务器地址结构体
    if(result  == -1)
    {
        char *perrorinfo = strerror(errno); 
        printf("bind返回的值为%d,错误码为:%d，错误信息为:%s;\n",result,errno,perrorinfo);
        return -1;
    }
    result = listen(listenfd, 32);     //参数2表示服务器可以积压的未处理完的连入请求总个数，客户端来一个未连入的请求，请求数+1，连入请求完成，c/s之间进入正常通讯后，请求数-1
    if(result == -1)
    {        
        char *perrorinfo = strerror(errno); 
        printf("listen返回的值为%d,错误码为:%d，错误信息为:%s;\n",result,errno,perrorinfo);
        return -1;
    }
    int connfd;
    const char *pcontent = "I sent sth to client!\n"; //指向常量字符串区的指针
    for(;;)
    {
        //卡在这里，等客户单连接，客户端连入后，该函数走下去【注意这里返回的是一个新的socket——connfd，后续本服务器就用connfd和客户端之间收发数据，而原有的lisenfd依旧用于继续监听其他连接】        
        connfd = accept(listenfd, (struct sockaddr*)NULL, NULL);

        //发送数据包给客户端
        write(connfd,pcontent,strlen(pcontent)); //注意第一个参数是accept返回的connfd套接字
        printf("本服务器给客户端发送了一串字符~~~~~~~~~~~!\n");
        
        //只给客户端发送一个信息，然后直接关闭套接字连接；
        close(connfd); 
    } //end for
    close(listenfd);     //实际本简单范例走不到这里，这句暂时看起来没啥用
    return 0;
}

可以使用以上程序配合telnet进行测试。