Longda share space

Sharing

0%

连接处理

## 创建连接 主要代码在sql/mysqld.cc中(create_new_thread/create_thread_to_handle_connection)，精简后的代码如下：

1
2
3
4
5
6
7
8
9
static void create_new_thread(THD *thd) {
  NET *net=&thd->net;
  if (connection_count >= max_connections + 1 || abort_loop) { // 看看当前连接数是不是超过了系统配置允许的最大值，如果是就断开连接。
    close_connection(thd, ER_CON_COUNT_ERROR, 1);
    delete thd;
  }
  ++connection_count;
  thread_scheduler.add_connection(thd); // 将新连接加入到thread_scheduler的连接队列中。
}

## 创建连接处理线程 而thread_scheduler转而调用create_thread_to_handle_connection,精简后的代码如下：

1
2
3
4
5
6
7
8
9
void create_thread_to_handle_connection(THD *thd) {
  if (cached_thread_count > wake_thread) { //看当前工作线程缓存(thread_cache)中有否空余的线程
    thread_cache.append(thd);
    pthread_cond_signal(&COND_thread_cache); // 有的话则唤醒一个线程来用
  } else {
    threads.append(thd);
    pthread_create(&thd->real_id,&connection_attrib,   handle_one_connection,   (void*) thd))); //没有可用空闲线程则创建一个新的线程
  }
}


## 连接处理 连接使用handle_one_connection函数,精简代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
pthread_handler_t handle_one_connection(void *arg)
{
	thread_scheduler.init_new_connection_thread(); // 初始化线程预处理操作
  
	setup_connection_thread_globals(thd); //载入一些Session级变量
     
  for (;;) { 
          lex_start(thd); //初始化LEX词法解析器
          login_connection(thd); // 进行连接身份验证
          prepare_new_connection_state(thd); // 初始化线程Status,即show status看到的
          do_command(thd); // 处理命令
          end_connection(thd); //没事做了关闭连接,丢入线程池
     
  }
}


void do_handle_one_connection(THD *thd_arg)
{
  THD *thd= thd_arg;

  thd->thr_create_utime= my_micro_time();  // 更新thd 时间

   //// 初始化线程预处理操作
  if (MYSQL_CALLBACK_ELSE(thd->scheduler, init_new_connection_thread, (), 0))
  {
    close_connection(thd, ER_OUT_OF_RESOURCES);
    statistic_increment(aborted_connects,&LOCK_status);
    MYSQL_CALLBACK(thd->scheduler, end_thread, (thd, 0));
    return;
  }

  /*
    If a thread was created to handle this connection:
    increment slow_launch_threads counter if it took more than
    slow_launch_time seconds to create the thread.
  */
  if (thd->prior_thr_create_utime)
  {
    ulong launch_time= (ulong) (thd->thr_create_utime -
                                thd->prior_thr_create_utime);
    if (launch_time >= slow_launch_time*1000000L)
      statistic_increment(slow_launch_threads, &LOCK_status);
    thd->prior_thr_create_utime= 0;
  }

  /*
    handle_one_connection() is normally the only way a thread would
    start and would always be on the very high end of the stack ,
    therefore, the thread stack always starts at the address of the
    first local variable of handle_one_connection, which is thd. We
    need to know the start of the stack so that we could check for
    stack overruns.
  */
  thd->thread_stack= (char*) &thd;
  if (setup_connection_thread_globals(thd))
    return;


  for (;;)
  {
    bool rc;

    thd->ppi_thread= PPI_THREAD_CALL(create_thread)();
    thd->ppi_transaction=
      PPI_THREAD_CALL(get_transaction_context)(thd->ppi_thread);

    NET *net= &thd->net;
    mysql_socket_set_thread_owner(net->vio->mysql_socket);

    //// 准备connection
    rc= thd_prepare_connection(thd);
    if (rc)
      goto end_thread;

    while (thd_is_connection_alive(thd))
    {
      mysql_audit_release(thd);
      if (do_command(thd))
  break;
    }
    end_connection(thd);

end_thread:
    close_connection(thd);
    if (MYSQL_CALLBACK_ELSE(thd->scheduler, end_thread, (thd, 1), 0))
      return;                                 // Probably no-threads

    /*
      If end_thread() returns, we are either running with
      thread-handler=no-threads or this thread has been schedule to
      handle the next connection.
    */
    thd= current_thd;
    thd->thread_stack= (char*) &thd;
  }
}

thd_prepare_connection 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
bool thd_prepare_connection(THD *thd)
{
  bool rc;
  lex_start(thd);                //初始化LEX词法解析器
  rc= login_connection(thd);    //
  if (rc)
    return rc;

  MYSQL_CONNECTION_START(thd->thread_id, &thd->security_ctx->priv_user[0],
                         (char *) thd->security_ctx->host_or_ip);

  //關鍵這個函數
  prepare_new_connection_state(thd);
  return FALSE;
}

login_connection
    -- check_connection  -- 设置vio, 检查main_security_ctx, vio_keepalive, 申请thd->packet 内存, acl_authenticate
    -- autit log 开始
    -- thd->protocol->end_statement(); lex_end
    
// 初始化session的status
prepare_new_connection_state
    --