java accept方法_Java中accept()阻塞是如何实现的

accept()执行后，会阻塞等待连接。我想知道底层是怎么实现阻塞的，于是一步步跟进去看，是在哪一步阻塞的。

于是我下载了OpenJDK8，一开始我的JDK是12.0.1，accept()在PlainSocketImpl.java中调用的是native方法，accept0()。我在OpenJDK8中找到了PlainSocketImpl.c文件，

但是没有找到accept0()方法。于是我重新下载了JDK1.8。现在在Oracle下载JDK要注册账号了。之后再跟进去看，发现这时候调用的还是accept0()方法，

但是文件是DualStackPlainSocketImpl.java而它的c文件，在OpenJDK中windows文件夹下，这里推荐一个好用的搜索文件的软件Everything。我的系统是win10，猜测如果是linux，可能就在其它文件夹下了。

果然我找到了accept0()方法。这里调用了accept函数。显然它定义在头文件中。

在系统中找到了头文件winsock2.h。

函数声明在这里。但是找不到对应的实现。想到linux中应该有类似开源的源码。

在一个博客上找到了linux中TCP accept的实现，这里我没那么严谨，取自己找到源码来读(暂时能力和精力有限哈)。https://blog.csdn.net/mrpre/article/details/82655834

其中重要的是这段代码。我以为底层是通过for(;;)实现的阻塞，但是对于每个进程for(;;)只会执行一次，那为什么这么写，主要是历史遗留原因，博主也有说明。那么阻塞是怎么实现的呢？最核心是schedule_timeout函数。于是又找到了源码。

注意上图中首先将进程加入到等待队列里面，并设置为可中断。schedule_timeout是理想的延迟方法。会让需要延迟的任务睡眠指定的时间。最核心的是schedule函数。

它的前后是设置定时器，和删除定时器。定时器到指定时间会唤醒进程，重新加入就绪队列。但是我们知道在每到指定时间的时候也可以唤醒进程，就是因为设置了可中断。

看来是schedule实现了阻塞。找来了它的源码。

signed long __sched schedule_timeout(signed long timeout)

{

struct timer_list timer;

unsigned long expire;

switch (timeout)

{

case MAX_SCHEDULE_TIMEOUT: //睡眠时间无限大，则不需要设置定时器。

/*

* These two special cases are useful to be comfortable

* in the caller. Nothing more. We could take

* MAX_SCHEDULE_TIMEOUT from one of the negative value

* but I' d like to return a valid offset (>=0) to allow

* the caller to do everything it want with the retval.

*/

schedule();

goto out;

default:

/*

* Another bit of PARANOID. Note that the retval will be

* 0 since no piece of kernel is supposed to do a check

* for a negative retval of schedule_timeout() (since it

* should never happens anyway). You just have the printk()

* that will tell you if something is gone wrong and where.

*/

if (timeout < 0) {

printk(KERN_ERR "schedule_timeout: wrong timeout "

"value %lx\n", timeout);

dump_stack();

current->state = TASK_RUNNING;

goto out;

}

}

expire = timeout + jiffies;

setup_timer_on_stack(&timer, process_timeout, (unsigned long)current);

__mod_timer(&timer, expire, false, TIMER_NOT_PINNED);

schedule();

del_singleshot_timer_sync(&timer);

/* Remove the timer from the object tracker */

destroy_timer_on_stack(&timer);

timeout = expire - jiffies;

out:

return timeout < 0 ? 0 : timeout;

}

内核版本2.6.39。schedule主要实现了进程调度。即让出当前进程的CPU，切换上下文。既然切换到其它进程执行了，而当前进程又进入了等待队列，不再会被调度。直到时间结束，或者中断来。这时候会从schedule返回。删除定时器。根据返回的timeout值判断是否大于0判断是睡眠到时间被唤醒，还是因为有连接了提前唤醒。

具体的代码细节没有进一步深究，然后理解可能也是错的。以后继续深入吧。

/*

* schedule() is the main scheduler function.

*/

asmlinkage void __sched schedule(void)

{

struct task_struct *prev, *next;

unsigned long *switch_count;

struct rq *rq;

int cpu;

need_resched:

preempt_disable(); //禁止内核抢占

cpu = smp_processor_id(); //获取当前CPU

rq = cpu_rq(cpu); //获取该CPU维护的运行队列(run queue)

rcu_note_context_switch(cpu); //更新全局状态，标识当前CPU发生上下文的切换。

prev = rq->curr; //运行队列中的curr指针赋予prev。

schedule_debug(prev);

if (sched_feat(HRTICK))

hrtick_clear(rq);

raw_spin_lock_irq(&rq->lock); //锁住该队列

switch_count = &prev->nivcsw; //记录当前进程的切换次数

if (prev->state && !(preempt_count() & PREEMPT_ACTIVE)) { //是否同时满足以下条件：1该进程处于停止状态，2该进程没有在内核态被抢占。

if (unlikely(signal_pending_state(prev->state, prev))) { //若不是非挂起信号，则将该进程状态设置成TASK_RUNNING

prev->state = TASK_RUNNING;

} else { //若为非挂起信号则将其从队列中移出

/*

* If a worker is going to sleep, notify and

* ask workqueue whether it wants to wake up a

* task to maintain concurrency. If so, wake

* up the task.

*/

if (prev->flags & PF_WQ_WORKER) {

struct task_struct *to_wakeup;

to_wakeup = wq_worker_sleeping(prev, cpu);

if (to_wakeup)

try_to_wake_up_local(to_wakeup);

}

deactivate_task(rq, prev, DEQUEUE_SLEEP); //从运行队列中移出

/*

* If we are going to sleep and we have plugged IO queued, make

* sure to submit it to avoid deadlocks.

*/

if (blk_needs_flush_plug(prev)) {

raw_spin_unlock(&rq->lock);

blk_schedule_flush_plug(prev);

raw_spin_lock(&rq->lock);

}

}

switch_count = &prev->nvcsw; //切换次数记录

}

pre_schedule(rq, prev);

if (unlikely(!rq->nr_running))

idle_balance(cpu, rq);

put_prev_task(rq, prev);

next = pick_next_task(rq); //挑选一个优先级最高的任务将其排进队列。

clear_tsk_need_resched(prev); //清除pre的TIF_NEED_RESCHED标志。

rq->skip_clock_update = 0;

if (likely(prev != next)) { //如果prev和next非同一个进程

rq->nr_switches++; //队列切换次数更新

rq->curr = next;

++*switch_count; //进程切换次数更新

context_switch(rq, prev, next); /* unlocks the rq */ //进程之间上下文切换

/*

* The context switch have flipped the stack from under us

* and restored the local variables which were saved when

* this task called schedule() in the past. prev == current

* is still correct, but it can be moved to another cpu/rq.

*/

cpu = smp_processor_id();

rq = cpu_rq(cpu);

} else //如果prev和next为同一进程，则不进行进程切换。

raw_spin_unlock_irq(&rq->lock);

post_schedule(rq);

preempt_enable_no_resched();

if (need_resched()) //如果该进程被其他进程设置了TIF_NEED_RESCHED标志，则函数重新执行进行调度

goto need_resched;

}