精华内容
下载资源
问答
  • 今天查看数据库错误日志,发现有InnoDB: Warning: a long semaphore wait: 报错: 解决办法: 原来Linux内核信号量默认设置太小,造成大量等待, 默认 # cat /proc/sys/kernel/sem 250 32000 32 ...

    mysqldump导入大量数据,error log报这个错


    今天查看数据库错误日志,发现有InnoDB: Warning: a long semaphore wait:  报错:

    解决办法:

    原来Linux内核信号量默认设置太小,造成大量等待, 
    默认 
    # cat /proc/sys/kernel/sem 
    250     32000   32      128 
    说明: 
    第一列,表示每个信号集中的最大信号量数目。 
    第二列,表示系统范围内的最大信号量总数目。 
    第三列,表示每个信号发生时的最大系统操作数目。 
    第四列,表示系统范围内的最大信号集总数目。


    将第三列调大一点,参考网上的数据 
    echo "kernel.sem=250 32000 100 128″>>/etc/sysctl.conf 
    然后sysctl -p 
    重启MySQL

    错误不再出现,问题即可解决


    具体详细的报错如下,详细的对比参考:

    InnoDB: Warning: a long semaphore wait:                                                                                 

      813 --Thread 139957495039744 has waited at btr0cur.cc line 545 for 241.00 seconds the semaphore:
      814 X-lock (wait_ex) on RW-latch at 0x7f4a60043da8 created in file dict0dict.cc line 2341
      815 a writer (thread id 139957495039744) has reserved it in mode  wait exclusive
      816 number of readers 2, waiters flag 1, lock_word: fffffffffffffffe
      817 Last time read locked in file btr0cur.cc line 554

      818 Last time write locked in file /root/mysql-5.6.10/storage/innobase/btr/btr0cur.cc line 545
      819 InnoDB: ###### Starts InnoDB Monitor for 30 secs to print diagnostic info:
      820 InnoDB: Pending preads 109, pwrites 0
      821 
      822 =====================================
      823 2014-04-21 18:27:21 7f4899a00700 INNODB MONITOR OUTPUT
      824 =====================================
      825 Per second averages calculated from the last 57 seconds
      826 -----------------
      827 BACKGROUND THREAD
      828 -----------------
      829 srv_master_thread loops: 704 srv_active, 0 srv_shutdown, 184 srv_idle
    cndb012.5405.zr.sh.gcimg.net.err [RO]                                                                       812,1           6%


    [root@cndb012 mysql]# cat /proc/sys/kernel/sem                                                                     
    250     32000   32      128
    [root@cndb012 mysql]# vim cndb012.5405.zr.sh.gcimg.net.err


      805 2014-04-21 18:04:55 16100 [Note] Slave I/O thread exiting, read up to log 'mysql-bin.000124', position 61975299
      812 InnoDB: Warning: a long semaphore wait:
      813 --Thread 139957495039744 has waited at btr0cur.cc line 545 for 241.00 seconds the semaphore:
      814 X-lock (wait_ex) on RW-latch at 0x7f4a60043da8 created in file dict0dict.cc line 2341
      815 a writer (thread id 139957495039744) has reserved it in mode  wait exclusive
      816 number of readers 2, waiters flag 1, lock_word: fffffffffffffffe
      817 Last time read locked in file btr0cur.cc line 554
      818 Last time write locked in file /root/mysql-5.6.10/storage/innobase/btr/btr0cur.cc line 545
      819 InnoDB: ###### Starts InnoDB Monitor for 30 secs to print diagnostic info:
      820 InnoDB: Pending preads 109, pwrites 0
      821 
      822 =====================================
      823 2014-04-21 18:27:21 7f4899a00700 INNODB MONITOR OUTPUT
      824 =====================================
      825 Per second averages calculated from the last 57 seconds
      826 -----------------
      827 BACKGROUND THREAD
      828 -----------------
      829 srv_master_thread loops: 704 srv_active, 0 srv_shutdown, 184 srv_idle
      830 srv_master_thread log flush and writes: 887
      831 ----------
      832 SEMAPHORES
      833 ----------
      834 OS WAIT ARRAY INFO: reservation count 75098
      835 --Thread 139948735776512 has waited at row0sel.cc line 3048 for 0.00 seconds the semaphore:
      836 S-lock on RW-latch at 0x7f48aa6535c0 created in file buf0buf.cc line 994
      837 a writer (thread id 139957491046144) has reserved it in mode  exclusive
      838 number of readers 0, waiters flag 1, lock_word: 0
      839 Last time read locked in file not yet reserved line 0
      840 Last time write locked in file /root/mysql-5.6.10/storage/innobase/buf/buf0buf.cc line 3466
      841 --Thread 139949644658432 has waited at row0sel.cc line 4111 for 1.00 seconds the semaphore:
      842 S-lock on RW-latch at 0x7f49d1bd1ec0 created in file buf0buf.cc line 994
      843 a writer (thread id 139948734711552) has reserved it in mode  exclusive
      844 number of readers 0, waiters flag 1, lock_word: 0
      845 Last time read locked in file not yet reserved line 0
      846 Last time write locked in file /root/mysql-5.6.10/storage/innobase/buf/buf0buf.cc line 3466
      847 --Thread 139949722711808 has waited at btr0cur.cc line 554 for 77.00 seconds the semaphore:
      848 S-lock on RW-latch at 0x7f4a60043da8 created in file dict0dict.cc line 2341
      849 a writer (thread id 139957495039744) has reserved it in mode  wait exclusive
      850 number of readers 2, waiters flag 1, lock_word: fffffffffffffffe                                                        
      851 Last time read locked in file btr0cur.cc line 554
      852 Last time write locked in file /root/mysql-5.6.10/storage/innobase/btr/btr0cur.cc line 545
      853 --Thread 139945323890432 has waited at btr0cur.cc line 554 for 77.00 seconds the semaphore:
      854 S-lock on RW-latch at 0x7f4a60043da8 created in file dict0dict.cc line 2341
      855 a writer (thread id 139957495039744) has reserved it in mode  wait exclusive
      856 number of readers 2, waiters flag 1, lock_word: fffffffffffffffe

      857 Last time read locked in file btr0cur.cc line 554




    本文转自 liqius 51CTO博客,原文链接:http://blog.51cto.com/szgb17/1919482,如需转载请自行联系原作者

    展开全文
  • wait(long timeout)

    2017-11-11 23:57:08
    - 类型:class方法public final void wait(long timeout) throws InterruptedException在其他线程调用此对象的 notify() 方法或 notifyAll() 方法,或者超过指定的时间量前,导致当前线程等待。当前线

    学习javaApi第十天

    java.lang.Object
    - jdk版本:1.0
    - 类型:class


    方法

    public final void wait(long timeout)
                    throws InterruptedException

    在其他线程调用此对象的 notify() 方法或 notifyAll() 方法,或者超过指定的时间量前,导致当前线程等待。

    当前线程必须拥有此对象监视器。

    此方法导致当前线程(称之为 T)将其自身放置在对象的等待集中,然后放弃此对象上的所有同步要求。出于线程调度目的,在发生以下四种情况之一前,线程 T 被禁用,且处于休眠状态:

    • 其他某个线程调用此对象的 notify 方法,并且线程 T 碰巧被任选为被唤醒的线程。
    • 其他某个线程调用此对象的 notifyAll 方法。
    • 其他某个线程中断线程 T。
    • 大约已经到达指定的实际时间。但是,如果 timeout 为零,则不考虑实际时间,在获得通知前该线程将一直等待。

    然后,从对象的等待集中删除线程 T,并重新进行线程调度。然后,该线程以常规方式与其他线程竞争,以获得在该对象上同步的权利;一旦获得对该对象的控制权,该对象上的所有其同步声明都将被恢复到以前的状态,这就是调用 wait 方法时的情况。然后,线程 T 从 wait 方法的调用中返回。所以,从 wait 方法返回时,该对象和线程 T 的同步状态与调用 wait 方法时的情况完全相同。

    在没有被通知、中断或超时的情况下,线程还可以唤醒一个所谓的虚假唤醒 (spurious wakeup)。虽然这种情况在实践中很少发生,但是应用程序必须通过以下方式防止其发生,即对应该导致该线程被提醒的条件进行测试,如果不满足该条件,则继续等待。换句话说,等待应总是发生在循环中,如下面的示例:

    synchronized (obj) {
    while (<condition does not hold>)
    obj.wait(timeout);
    ... // Perform action appropriate to condition
         }

    (有关这一主题的更多信息,请参阅 Doug Lea 撰写的 Concurrent Programming in Java (Second Edition) (Addison-Wesley, 2000) 中的第 3.2.3 节或 Joshua Bloch 撰写的 Effective Java Programming Language Guide (Addison-Wesley, 2001) 中的第 50 项。
    如果当前线程在等待之前或在等待时被任何线程中断,则会抛出 InterruptedException。在按上述形式恢复此对象的锁定状态时才会抛出此异常。

    注意,由于 wait 方法将当前线程放入了对象的等待集中,所以它只能解除此对象的锁定;可以同步当前线程的任何其他对象在线程等待时仍处于锁定状态。

    此方法只应由作为此对象监视器的所有者的线程来调用。有关线程能够成为监视器所有者的方法的描述,请参阅 notify 方法。


    参数:
    timeout - 要等待的最长时间(以毫秒为单位)。

    抛出:
    IllegalArgumentException - 如果超时值为负。
    IllegalMonitorStateException - 如果当前线程不是此对象监视器的所有者。
    InterruptedException - 如果在当前线程等待通知之前或者正在等待通知时,任何线程中断了当前线程。在抛出此异常时,当前线程的 中断状态 被清除。

    相关方法:
    notify(), notifyAll()

    展开全文
  • RLock的tryLock方法 ...public boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException; 1、当调用 rLock.tryLock(0,30,TimeUnit.SECONDS)时 源码: ...

     RLock的tryLock方法

    public boolean tryLock();
    public boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException;
    

    1、当调用

    rLock.tryLock(0,30,TimeUnit.SECONDS)时

    源码:

    @Override
        public boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException {
            long time = unit.toMillis(waitTime);
            long current = System.currentTimeMillis();
            final long threadId = Thread.currentThread().getId();
            // 尝试获取锁,并返回剩余超时时间
            Long ttl = tryAcquire(leaseTime, unit, threadId);
            // lock acquired
            // 如果ttl为空则说明锁未被其他客户端持有
            if (ttl == null) {
                return true;
            }
            // 检查是否超过等待时间 超过则返回false
            time -= (System.currentTimeMillis() - current);
            if (time <= 0) {
                acquireFailed(threadId);
                return false;
            }
            
            current = System.currentTimeMillis();
            // 当前线程进行订阅
            final RFuture<RedissonLockEntry> subscribeFuture = subscribe(threadId);
            if (!await(subscribeFuture, time, TimeUnit.MILLISECONDS)) {
                if (!subscribeFuture.cancel(false)) {
                    subscribeFuture.addListener(new FutureListener<RedissonLockEntry>() {
                        @Override
                        public void operationComplete(Future<RedissonLockEntry> future) throws Exception {
                            if (subscribeFuture.isSuccess()) {
                                unsubscribe(subscribeFuture, threadId);
                            }
                        }
                    });
                }
                acquireFailed(threadId);
                return false;
            }
    
            try {
                time -= (System.currentTimeMillis() - current);
                if (time <= 0) {
                    acquireFailed(threadId);
                    return false;
                }
                // 在等待时间内 重复尝试获取锁 直到超过等待时间或成功获取锁
                while (true) {
                    long currentTime = System.currentTimeMillis();
                    ttl = tryAcquire(leaseTime, unit, threadId);
                    // lock acquired
                    if (ttl == null) {
                        return true;
                    }
    
                    time -= (System.currentTimeMillis() - currentTime);
                    if (time <= 0) {
                        acquireFailed(threadId);
                        return false;
                    }
    
                    // waiting for message
                    currentTime = System.currentTimeMillis();
                    if (ttl >= 0 && ttl < time) {
                        getEntry(threadId).getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);
                    } else {
                        getEntry(threadId).getLatch().tryAcquire(time, TimeUnit.MILLISECONDS);
                    }
    
                    time -= (System.currentTimeMillis() - currentTime);
                    if (time <= 0) {
                        acquireFailed(threadId);
                        return false;
                    }
                }
            } finally {
                unsubscribe(subscribeFuture, threadId);
            }
    //        return get(tryLockAsync(waitTime, leaseTime, unit));
        }
    private Long tryAcquire(long leaseTime, TimeUnit unit, long threadId) {
        return get(tryAcquireAsync(leaseTime, unit, threadId));
    } 
    private <T> RFuture<Long> tryAcquireAsync(long leaseTime, TimeUnit unit, final long threadId) {
        if (leaseTime != -1) {
            //注意最后一个参数
            return tryLockInnerAsync(leaseTime, unit, threadId, RedisCommands.EVAL_LONG);
        }
        RFuture<Long> ttlRemainingFuture = tryLockInnerAsync(LOCK_EXPIRATION_INTERVAL_SECONDS, TimeUnit.SECONDS, threadId, RedisCommands.EVAL_LONG);
        ttlRemainingFuture.addListener(new FutureListener<Long>() {
            @Override
            public void operationComplete(Future<Long> future) throws Exception {
                if (!future.isSuccess()) {
                    return;
                }
    
                Long ttlRemaining = future.getNow();
                // lock acquired
                if (ttlRemaining == null) {
                    scheduleExpirationRenewal(threadId);
                }
            }
        });
        return ttlRemainingFuture;
    }
    <T> RFuture<T> tryLockInnerAsync(long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand<T> command) {
        internalLockLeaseTime = unit.toMillis(leaseTime);
    
        return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, command,
                  "if (redis.call('exists', KEYS[1]) == 0) then " +
                      "redis.call('hset', KEYS[1], ARGV[2], 1); " +
                      "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                      "return nil; " +
                  "end; " +
                  "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
                      "redis.call('hincrby', KEYS[1], ARGV[2], 1); " +
                      "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                      "return nil; " +
                  "end; " +
                  "return redis.call('pttl', KEYS[1]);",
                    Collections.<Object>singletonList(getName()), internalLockLeaseTime, getLockName(threadId));
    }
    private void scheduleExpirationRenewal(final long threadId) {
        if (expirationRenewalMap.containsKey(getEntryName())) {
            return;
        }
        //新建定时任务,每隔1/3过期时间则刷新过期时间
        Timeout task = commandExecutor.getConnectionManager().newTimeout(new TimerTask() {
            @Override
            public void run(Timeout timeout) throws Exception {
                
                RFuture<Boolean> future = commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
                        "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
                            "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                            "return 1; " +
                        "end; " +
                        "return 0;",
                          Collections.<Object>singletonList(getName()), internalLockLeaseTime, getLockName(threadId));
                
                future.addListener(new FutureListener<Boolean>() {
                    @Override
                    public void operationComplete(Future<Boolean> future) throws Exception {
                        expirationRenewalMap.remove(getEntryName());
                        if (!future.isSuccess()) {
                            log.error("Can't update lock " + getName() + " expiration", future.cause());
                            return;
                        }
                        
                        if (future.getNow()) {
                            // reschedule itself
                            scheduleExpirationRenewal(threadId);
                        }
                    }
                });
            }
        }, internalLockLeaseTime / 3, TimeUnit.MILLISECONDS);
        // 如果传入key对应的value已经存在,就返回存在的value,不进行替换。如果不存在,就添加key和value,返回null
        if (expirationRenewalMap.putIfAbsent(getEntryName(), task) != null) {
            task.cancel();
        }
    }

     

    lua脚本解释:

    --检查key是否被占用了,如果没有则设置超时时间和唯一标识,初始化value=1
    if (redis.call('exists', KEYS[1]) == 0) then
      redis.call('hset', KEYS[1], ARGV[2], 1);
      redis.call('pexpire', KEYS[1], ARGV[1]);
      return nil; 
    end; 
    --如果锁重入,需要判断锁的key field 都一致情况下 value 加一 
    if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then 
      redis.call('hincrby', KEYS[1], ARGV[2], 1);
      --锁重入重新设置超时时间  
      redis.call('pexpire', KEYS[1], ARGV[1]); 
      return nil; 
    end;
    --返回剩余的过期时间
    return redis.call('pttl', KEYS[1]);
    
    参数:
    
    KEYS[1](getName()) :需要加锁的key
    
    ARGV[1](internalLockLeaseTime) :锁的超时时间,防止死锁
    
    ARGV[2](getLockName(threadId)) :锁的唯一标识, id(UUID.randomUUID()) + “:” + threadId
    
    

    如上lua脚本等同于在redis控制台执行

    exists lbhTestLock

    hset lbhTestLock 32131231:21 1

    pexpire lbhTestLock 3000

     

     

    展开全文
  • * wait(long timeout) * @author WanAkiko * */ public class OverrideWait { public static void main(String[] args) { Object obj = new Object(); // 创建唯一的锁对象 new Thread() { // 匿名内部...
    package practice;
    
    /**
     * wait(long timeout)
     * @author WanAkiko
     *
     */
    public class OverrideWait {
    
    	public static void main(String[] args) {
    		
    		Object obj = new Object(); // 创建唯一的锁对象
    		new Thread() { // 匿名内部类创建多线程
    			@Override
    			public void run() {
    				while (true) { // 无限次执行
    					synchronized (obj) { // 同步代码块
    						System.out.println("上阙:我且徐行,无规缚,倦即停。");
    						try {
    							obj.wait(3000); // 超时自动苏醒并进入到运行状态或阻塞状态
    						} catch (InterruptedException e) {
    							e.printStackTrace();
    						}
    						System.out.println("下阙:听风闻雨,无所欲,步自轻。\n");
    					}
    				}
    			}
    		}.start();
    
    	}
    
    }
    

    运行示例:
    在这里插入图片描述

    展开全文
  • 并发编程小知识 object.wait 和 object.wait(long timeout) 通常的理解 相同点: 都会在拥有锁的时候立即释放锁,线程会被系统挂起,失去cpu时间片,得不到调度。 不同点: 后者线程会在指定timeout的时间过去之后被...
  • wait(long timeout, int nanos)

    千次阅读 2017-11-12 16:39:55
    学习javaApi第十一天java.lang.Object - jdk版本:1.0 - 类型:class方法public final void wait(long timeout, int nanos) throws InterruptedException在其他线程调用此对象的 notify() 方法或 noti
  • sleep是Thread的静态native方法,可随时调用,会使当前线程休眠,并释放CPU资源,但不会释放对象...wait方法是Object的方法,只能在同步方法或同步代码块中使用,调用会进入休眠状态,并释放CPU资源与对象锁,需要我们调用n...
  • Java wait(long timeout)

    千次阅读 2015-01-23 10:49:07
    * Causes the current thread to wait until either another thread invokes the * {@link java.lang.Object#notify()} method or the * {@link java.lang.Object#notifyAll()} method for thi
  • 一.Object的wait(long timeout)方法 javaAPI中关于wait(long timeout)放的说明是这样的: 导致当前线程等待,直到其他线程调用此对象的java.lang.Object.notify()方法或java.lang.Object.notifyAll()方法,...
  • Linux上的TIME_WAIT和tcp_fin_timeout

    千次阅读 2018-04-17 09:29:37
    当Linux服务器的TIME_WAIT过多时, 通常会想到去修改参数降低TIME_WAIT时长, 以减少TIME_WAIT数量,但Linux并没有提供这样的接口, 除非重新编译内核。...#define TCP_TIMEWAIT_LEN (60*HZ) /* how long ...
  • 在使用了新版的 druid-1.2.5 以后,日志中一直在报 Error,内容是 discard long time none received connection. , jdbcUrl : 巴拉巴拉,但程序运行并没有受到影响,但看着一大片错误就浑身难受,我决定去他们的源码...
  • netstat -n | awk '/^tcp/ {++state[$NF]} END {for(key in state) print key,"\t",state[key]}' 会得到类似下面的结果,具体数字会有所不同: LAST_ACK 1 SYN_RECV 14 ...TIME_WAIT 1...
  • Lock的tryLock(long time, TimeUnit unit)方法

    千次阅读 2016-11-21 14:59:58
    tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的,只不过区别在于这个方法在拿不到锁时会等待一定的时间,在时间期限之内如果还拿不到锁,就返回false。如果一开始拿到锁或者在等待期间内拿到了锁,...
  • TCP TimeWait状态详解(比较全)

    千次阅读 2016-02-23 20:52:44
    TIME_WAIT状态 TCP要保证在所有可能的情况下使得所有的数据都...当关闭一个 socket 连接时,主动关闭一端的 socket 将进入TIME_WAIT状态,而被动关闭一方则转入CLOSED状态。 见图解。   当一个socket关
  • 在前文ReentrantLock-NonfairSync源码逐行深度分析中,已经分析了AQS加解锁,阻塞唤醒与CLH队列的使用,这里主要看看...public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException { return
  • 用druid 数据库链接,日志中一直在报 Error,内容是 discard long time none received connection. , jdbcUrl : 2原因 阿里他们给数据库设置的数据库空闲等待时间是60秒,mysql数据库到了空闲等待时间将关闭空闲...
  • java高并发包之awaitTermination(long timeout,TimeUnit unit)作用 解决方法: 方法awaitTermination(long timeout,TimeUnit unit)的作用就是查看在指定的时 间之间,线程池是否已经终止工作,如果:...
  • 一,wait() 和wait(long) 方法属性:wait(long) 为native方法,是Object类中,声明的;wait()方法时再Thread类中声明,其本质,调用的是Object的wait(long)方法,参数为0. 唤起方式:调用线程的notify和notifyall...
  • 在很多讲 waitlong timeout)的例子,都会用下面类似的代码: public class RunA implements Runnable { private Object lock; public RunA(Object lock) { this.lock = lock; } @Override public void...
  • return : 0:ok ETIMEDOUT: timeout EINVAL: cond ,mutex,abstime invalueble note: struct timeval{ long tv_sec://秒 long tv_used;//微秒 }
  • 在使用了新版的 druid 以后,日志中一直在报 Error,内容是 discard long time none received connection. , jdbcUrl : xxxxx,但程序运行并没有受到影响,但看着一大片错误就浑身难受,我决定去他们的源码里看看...
  • TCP中的TIME_WAIT状态详解

    千次阅读 2015-05-06 20:35:10
    linux和windows下TIME_WAIT过多的解决办法 如果使用了nginx代理,那么系统TIME_WAIT的数量会变得比较多,这是由于nginx代理使用了短连接的方式和后端交互的原因,使得nginx和后端的ESTABLISHED变得很少而TIME_WAIT...
  • linux和windows下TIME_WAIT过多的解决办法 如果使用了nginx代理,那么系统TIME_WAIT的数量会变得比较多,这是由于nginx代理使用了短链接的方式和后端交互的原因,使得nginx和后端的ESTABLISHED变得很少而TIME_WAIT...
  • Java wait()和wait(long seconds)即等待超时

    千次阅读 2019-04-13 21:51:50
    java中,同步代码(synchronized代码块)中,对象调用wait()放弃锁,使当前进程进入睡眠等待状态,必须由noyify()或者notifyAll()唤醒,而若是等待超时模式(wait(long seconds))下,则分为两种情况: 1、在等待...
  • is longer than the server configured value of 'wait_timeout'. You should consider either expiring and/or testing connection validity before use in your application, increasing the server configured ...
  • # Connection timeout variables #interactive_timeout: #参数含义:服务器关闭交互式连接前等待活动的秒数。交互式客户端定义为在mysql_...#wait_timeout: #参数含义:服务器关闭非交互连接之前等待活动的秒数。 #在
  • void java.lang.Object.wait(long timeout) throws InterruptedException Causes the current thread to wait until either another thread invokes the java.lang.Object.notify() method or the java.la
  • TCP断开连接时的2MSL的time_wait状态

    千次阅读 2015-09-13 21:51:22
    2MSL TIME_WAIT状态存在的理由: TIME_WAIT状态的存在有两个理由:(1)让4次握手关闭流程更加可靠;4次握手的最后一个ACK是是由主动关闭方发送出去的,若这个ACK丢失,被动关闭方会再次发一个FIN过来。若主动关闭...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 151,377
精华内容 60,550
关键字:

alongtimewait