精华内容
下载资源
问答
  • 1:golang mysql时,Prepare报错:dial tcp 127.0.0.1:3306: getsockopt: connection refused' ...2:mysql最大连接数和最大空闲连接数测试 测试程序: package main import ( "fmt" "database/sql" _"githu...


    1:golang mysql时,Prepare报错:dial tcp 127.0.0.1:3306: getsockopt: connection refused' 
    解决办法:查看mysql初始化时候的用户名密码是否正确

    2:mysql最大连接数和最大空闲连接数测试
    测试程序:
    package main

    import (
      "fmt"
      "database/sql"
      _"github.com/go-sql-driver/mysql" //下划线为只引入,不调用其里面的任何函数,用到了里面的init函数进行驱动初始化
      "errors"
      "time"
    )

    var db *sql.DB
    func initDB() (*sql.DB, error) {
        connectStr := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?timeout=%dms&readTimeout=%dms&writeTimeout=%dms&charset=utf8", "用户名", "密码", "hostip", 端口, "库名", 1000, 500, 500)//后面三个分别为连接超时,读超时,写超时
        db, err := sql.Open("mysql", connectStr)
        if err != nil {
            fmt.Println("open mysql err:", err)
            return nil, err
        }
        if db == nil {
            fmt.Println("mysql connection err:")
            return nil, errors.New("Mysql Connection error")
        }
        db.SetMaxOpenConns(20)
        db.SetMaxIdleConns(0)
        db.Ping()
        return db, nil
    }

    func execSql() {
            var connection_id int
            err := db.QueryRow("select CONNECTION_ID()").Scan(&connection_id)
            if err != nil {
                    fmt.Println("query connection id failed:", err)
                    return
            }

            fmt.Println("connection id:", connection_id)
    }

    func UpdateStatus(status int, length float64) error {
        stat, err := db.Prepare(fmt.Sprintf("update %s set `status` = ?, `length` = ?, `finish_time` = ? where `requestId` = ?", "saas_video_req_list"))
        fmt.Println("stat:", stat)
        if err != nil {
            fmt.Println("prepareerr:", err)
            return err
        }
        defer stat.Close()
        requestId := "8888888888888888888"
        _, errExec := stat.Exec(status, length, time.Now().Format("2006-01-02 15:04:05"), requestId)
        if errExec != nil {
            fmt.Println("execerr:", errExec)
            return errExec
        }
        fmt.Println(length)
        return nil
    }

    func main() {

        var err error
        if db, err = initDB(); err != nil {
            fmt.Println("init db err:", err)
        }

        for i:=0; i< 15000; i++ {
            go UpdateStatus(2, float64(i))
            //execSql()

            //time.Sleep(time.Second*1)
        }
        time.Sleep(time.Second*10)
    }

    测试case1:测试连接泄露的情况
    步骤1:查看一下mysql中设置的最大连接数
    mysql> show variables like '%max_connections%';
    +-----------------+-------+
    | Variable_name   | Value |
    +-----------------+-------+
    | max_connections | 10000 |
    +-----------------+-------+
    1 row in set (0.00 sec)

    mysql>

    可以看到最大连接数为10000,所以将调用UpdateStatus函数的地方设置为15000个,并且注释掉函数中的defer stat.Close()一行,手动让连接数泄露,即我打开连接之后不关闭。即便打开之后关闭,同时打开的也不能超过数据库中的最大连接数,否则还是报如下信息。

    可以看到在执行mysql建立新的连接的时候,会出现错误信息:
    prepareerr: Error 1461: Can't create more than max_prepared_stmt_count statements (current value: 16382)
    prepareerr: Error 1461: Can't create more than max_prepared_stmt_count statements (current value: 16382)
    prepareerr: Error 1461: Can't create more than max_prepared_stmt_count statements (current value: 16382)
    execerr: Error 1461: Can't create more than max_prepared_stmt_count statements (current value: 16382)
    execerr: Error 1461: Can't create more than max_prepared_stmt_count statements (current value: 16382)
    prepareerr: Error 1461: Can't create more than max_prepared_stmt_count statements (current value: 16382)
    execerr: Error 1461: Can't create more than max_prepared_stmt_count statements (current value: 16382)

    结论:1:在有连接泄露的情况下,如果当时同时连接的个数超过了数据库中的最大连接数,则会出现再进来的mysql执行失败的情况。很危险,如果线上同时出现的连接数超过的mysql设置的最大的连接数,则后面的mysql语句会执行失败。
          2:将main函数中的for循环改成小于10000时,即使不执行defer stat.Close(),也不会出现上面的mysql的错误信息。因为即便全不关,也不会超过10000,等超时时间(这个怎么看超时时间?)后,会自动关闭。
          3:将for循环改成2000,最大连接数为100(如果此值大于mysql的最大连接数,一样会出现连接数过多的错误),多次执行,不执行defer stat.Close()代码,也不会出现连接超过最大连接数的情况,说明连接数应该是会自动关闭,出了函数作用域或者程序结束的时候,连接会自动关闭。但是还是强烈建议手动关闭,因为如果线上线程数和机器数比较多,同时达到了最大连接数,一样会出事故(超时时间应该和initDB里面设置的超时时间没关系,超时时间的设置为去链接数据库的超时时间,参考链接:https://www.cnblogs.com/lanyangsh/p/11749270.html。)

    测试case2:测试SetMaxOpenConns函数功能
    步骤一:将最大连接数SetMaxOpenConns的参数设置为2,最大空闲连接数SetMaxIdleConns参数设置为0。在执行Exec会出现阻塞的情况,即如果要创建10个连接,目前最大连接数为2,则需要2的最大连接数空闲出来之后,才能给后一个连接使用。不会报错,只会阻塞。

    例如如下代码中:如果设置最大连接数为1,第二个query语句会阻塞,第二个打印打印不出来,除非调研close先关闭第一个query

    func querySql() {

        db.Query("select * from saas_video_req_list")

        fmt.Println("111111")

        _, err := db.Query("select * from saas_video_req_list") //此操作将一直阻塞

        fmt.Println("queryerr:", err)

    }

    但是调用Prepare却不会??按道理Prepare也会占有连接数。但是却没有阻塞?

         
    测试case3:将最大连接数SetMaxOpenConns的参数设置为2,最大空闲连接数SetMaxIdleConns参数设置为0。调用execSql()时,可以看到每次打印的connection_id都不相同。

    结论:如果不设置最大空闲连接数,则每次连接都创建新的connectid,可以通过打印的connection_id不同解释该结论
          
    测试case4:将最大连接数SetMaxOpenConns的参数设置为10,最大空闲连接数SetMaxIdleConns参数设置为2。每隔1s调用execSql()时,可以看到每次打印的connection_id相同的2个。如果调用过快,最大空闲连接数不够用,同样会创建新的连接。

    结论:如果连接不用了,最大空闲连接数还有空闲,则放入最大空闲连接数,以备下次使用。

    case4的测试结果:

     

    综上:

    现象1:当程序中的最大连接数的值大于数据库中最大连接数的值时,如果程序中存在没有close连接的情况,程序执行一段时间后会出现最大连接数过多的错误。

    现象2:当程序中的最大连接数的值小于于数据库中最大连接数的值时,即使程序中存在没有close连接的情况,也不会出现最大连接数过多的情况(应该是大于程序中设置的最大连接数的连接会自动释放?)

    1:程序中养成手动Close的习惯。即使全部Close,但是程序中同时连接数大于mysql的连接数,一样出现最大连接数错误,解决参看下面一条。

    2:设置程序中的最大连接数小于mysql的最大连接数。这样连接数过多会阻塞在程序中,不会影响mysql。

    3:设置最大空闲连接数,可以重复利用连接。

     

    常见的几种错误和解决办法:

    错误1:如果设置的最大连接数过大,有可能会报prepareerr: dial tcp 10.141.0.234:3306: socket: too many open files,表示你超过了机器可以创建的最大文件描述符,

    解决办法:使用ulimit -n 65535修改一下可以创建的最大文件描述符。

    错误2:Error 1040: Too many connections这个错误,则是你程序设置的最大连接数超过了数据库的最大连接数。

    解决办法:增大数据库最大连接数,或者减少程序设置的最大连接数,一般程序中设置的最大连接数没必要太大。

    错误3:Error 1461: Can't create more than max_prepared_stmt_count statements (current value: 16382)

    解决办法:检查程序中是否有连接泄露,比如prepare了没有close这种。或者没有泄露的情况下,同时连接数据库的操作是不是超过了数据库的最大连接数。


    参考连接:https://blog.csdn.net/lanyang123456/article/details/101947421

    展开全文
  • 本文介绍golang 中连接MySQL时,如何设置最大连接数。 文中例子连接MySQL用的package是github.com/go-sql-driver/mysql. 设置最大连接数的接口是 func (db *DB) SetMaxOpenConns(n int) 设置连接MySQL可以...

    本文介绍golang 中连接MySQL时,如何设置最大连接数和最大空闲连接数。

    关于最大连接数和最大空闲连接数,是定义在golang标准库中database/sql的。

    文中例子连接MySQL用的SQL driver package是github.com/go-sql-driver/mysql.

    设置最大连接数的接口是

    func (db *DB) SetMaxOpenConns(n int) 
    

    设置连接MySQL可以打开的最大连接数。

    如果n <= 0,表示打开的连接数没有限制。

    默认为0,也就是不限制连接数。

    另一个与连接数相关的参数是MaxIdleConns,表示最大空闲连接数。

    如果MaxIdleConns 大于0,且大于MaxOpenConns,那么将调整MaxIdleConns等于MaxOpenConns,有多余的连接时会关闭多余的连接。

    设置最大空闲连接数的接口是:

    func (db *DB) SetMaxIdleConns(n int)
    

    如果n<=0,表示不使用空闲连接池,即一个连接如果不使用,不会放入空闲连接池。因此,这种方式不会复用连接,每次执行SQL语句,都会重新建立新的连接。

    默认的最大空闲连接数为2:
    const defaultMaxIdleConns = 2

    关于打开的连接和空闲的连接之间的关系,补充一下:

    打开的连接 = 正在使用的连接(inuse) + 处于空闲状态的连接(idle)
    

    下面对最大连接数和最大空闲连接数做下测试和验证。

    1.最大连接数测试

    首先设置最大打开的连接数为1,接着开启20个goroutine,每个goroutine执行sql语句,打印执行sql使用的连接的connection id。并执行耗时的sql语句占用连接,观察其他需要执行SQL的goroutine的执行情况。

    例子代码如下:

    package main
    
    import (
            "database/sql"
            "log"
    
            _ "github.com/go-sql-driver/mysql"
    )
    
    var DB *sql.DB
    var dataBase = "root:Aa123456@tcp(127.0.0.1:3306)/?loc=Local&parseTime=true"
    
    func Init() {
            var err error
            DB, err = sql.Open("mysql", dataBase)
            if err != nil {
                    log.Fatalln("open db fail:", err)
            }
    
            DB.SetMaxOpenConns(1)
    
            err = DB.Ping()
            if err != nil {
                    log.Fatalln("ping db fail:", err)
            }
    }
    
    func main() {
            Init()
            
            //开启20个goroutine
            for i:=0; i < 20; i++ {
                    go one_worker(i)
            }
            
            select {
            }
    
    }
    
    func one_worker(i int) {
            var connection_id int
            err := DB.QueryRow("select CONNECTION_ID()").Scan(&connection_id)
            if err != nil {
                    log.Println("query connection id failed:", err)
                    return
            }
    
            log.Println("worker:", i, ", connection id:", connection_id)
    
            var result int
            err = DB.QueryRow("select sleep(10)").Scan(&result)
            if err != nil {
                    log.Println("query sleep connection id faild:", err)
                    return
            }
    
    }
    

    output

    2019/10/02 18:14:25 worker: 2 , connection id: 55
    2019/10/02 18:14:25 worker: 17 , connection id: 55
    2019/10/02 18:14:25 worker: 11 , connection id: 55
    2019/10/02 18:14:35 worker: 3 , connection id: 55
    2019/10/02 18:14:45 worker: 0 , connection id: 55
    2019/10/02 18:14:45 worker: 4 , connection id: 55
    2019/10/02 18:14:45 worker: 5 , connection id: 55
    2019/10/02 18:15:05 worker: 7 , connection id: 55
    2019/10/02 18:15:25 worker: 15 , connection id: 55
    2019/10/02 18:15:25 worker: 6 , connection id: 55
    2019/10/02 18:15:35 worker: 13 , connection id: 55
    2019/10/02 18:15:45 worker: 19 , connection id: 55
    2019/10/02 18:15:45 worker: 10 , connection id: 55
    2019/10/02 18:15:45 worker: 12 , connection id: 55
    2019/10/02 18:15:55 worker: 14 , connection id: 55
    2019/10/02 18:16:15 worker: 8 , connection id: 55
    2019/10/02 18:16:35 worker: 18 , connection id: 55
    2019/10/02 18:16:35 worker: 1 , connection id: 55
    2019/10/02 18:17:05 worker: 16 , connection id: 55
    2019/10/02 18:17:35 worker: 9 , connection id: 55
    

    使用show processlist查看连接

    mysql> show processlist;
    +----+------+-----------------+------+---------+------+------------+------------------+
    | Id | User | Host            | db   | Command | Time | State      | Info             |
    +----+------+-----------------+------+---------+------+------------+------------------+
    | 20 | root | localhost       | NULL | Query   |    0 | starting   | show processlist |
    | 55 | root | localhost:59518 | NULL | Query   |    5 | User sleep | select sleep(10) |
    +----+------+-----------------+------+---------+------+------------+------------------+
    2 rows in set (0.00 sec)
    

    使用netstat 查看连接

    netstat -an | grep 3306
    tcp4       0      0  127.0.0.1.3306         127.0.0.1.59518        ESTABLISHED
    tcp4       0      0  127.0.0.1.59518        127.0.0.1.3306         ESTABLISHED
    tcp46      0      0  *.3306                 *.*                    LISTEN
    

    从结果可以看到,20个goroutine轮流使用同一个连接(connection id 为55)执行sql语句。

    当连接被占用时,其他尝试使用连接的goroutine会被阻塞。直到连接使用完后,其他goroutine才可以使用连接。

    即使多个goroutine在执行SQL,也没有创建多个连接。

    因此,最大连接数设置生效。

    有些读者可能会问,没有看到设置最大空闲连接数,此时最大空间连接数是多少?

    前面已经提到,默认的最大空闲连接数是2.

    下面再来测试下最大空间连接数。

    2.最大空闲连接数测试

    下面例子中,设置最大连接数为1,最大空闲连接数为0.

    并且每隔3s执行一条SQL语句。

    代码如下:

    package main
    
    import (
            "database/sql"
            "log"
            "time"
    
            _ "github.com/go-sql-driver/mysql"
    
    )
    
    var DB *sql.DB
    var dataBase = "root:Aa123456@tcp(127.0.0.1:3306)/?loc=Local&parseTime=true"
    
    func mysqlInit() {
            var err error
            DB, err = sql.Open("mysql", dataBase)
            if err != nil {
                    log.Fatalln("open db fail:", err)
            }
    
            DB.SetMaxOpenConns(1)
            DB.SetMaxIdleConns(0)
    
            err = DB.Ping()
            if err != nil {
                    log.Fatalln("ping db fail:", err)
            }
    }
    
    func main() {
            mysqlInit()
    
            for {
                    execSql()
                    time.Sleep(3*time.Second)
            }
    }
    
    
    func execSql() {
            var connection_id int
            err := DB.QueryRow("select CONNECTION_ID()").Scan(&connection_id)
            if err != nil {
                    log.Println("query connection id failed:", err)
                    return
            }
    
            log.Println("connection id:", connection_id)
    }
    

    output:

    2019/10/13 23:06:00 connection id: 26
    2019/10/13 23:06:03 connection id: 27
    2019/10/13 23:06:06 connection id: 28
    2019/10/13 23:06:09 connection id: 29
    2019/10/13 23:06:12 connection id: 30
    2019/10/13 23:06:15 connection id: 31
    2019/10/13 23:06:18 connection id: 32
    2019/10/13 23:06:21 connection id: 33
    2019/10/13 23:06:24 connection id: 34
    2019/10/13 23:06:27 connection id: 35
    2019/10/13 23:06:30 connection id: 36
    2019/10/13 23:06:33 connection id: 37
    2019/10/13 23:06:36 connection id: 38
    

    从结果中可以看出,每次执行SQL使用的连接connection id都不同。

    设置最大空闲连接数为0,每次执行SQL后,连接不会放入空闲连接池,而是会被关闭,下次执行SQL时,会重新建立新的连接。

    3.参考

    Connection pool and timeouts

    Golang MySQL 连接和连接池

    展开全文
  • 最大连接数与每ip连接数的限制

    千次阅读 2019-01-16 21:22:30
    一、最大连接数的限制 概念 这是指服务器可以同时接收的最大连接数,防止服务器压力过大而在应用层进行的限制。 实现 总体思路:将当前连接数保存于变量num_clients变量中,然后与配置项numble_max_clients进行...

    一、最大连接数的限制

    概念

    这是指服务器可以同时接收的最大连接数,防止服务器压力过大而在应用层进行的限制。

    实现

    总体思路:将当前连接数保存于变量num_clients变量中,然后与配置项numble_max_clients进行比较,如果超过了就不让登录,当一个客户登录的时候num_clents加1,当一个客户退出的时候,num_clients减1。

    1.一旦服务器端与客户端经过三次握手建立连接之后,服务端就需要创建进程为其服务,此时,将连接数加1。

    //来了一个新的客户端,需要创建子进程出来
    ++s_children;
    //当前连接数等于子进程数
    sess.num_clients = s_children;

    2.然后在负责服务的子进程中进行最大连接数的判断

    如果当前连接数超过了最大连接数,那么就要退出当前子进程。

    //连接数的判定
    void check_limits(session_t *sess)
    {
    	//最大连接数配置项是否开启并且当前连接数超过了最大连接数
    	if (tunable_max_clients > 0 && sess->num_clients > tunable_max_clients) {
    		ftp_reply(sess, FTP_TOO_MANY_USERS, 
    			"There are too many connected users, please try later.");
    
    		//退出当前子进程
    		exit(EXIT_FAILURE);
    	}
    
        //最大连接数没有超过上限的情况下,再检查ip的连接数是否超过上限
    	if (tunable_max_per_ip > 0 && sess->num_this_ip > tunable_max_per_ip) {
    		ftp_reply(sess, FTP_IP_LIMIT, 
    			"There are too many connections from your internet address.");
    
    		exit(EXIT_FAILURE);
    	}
    }

    3.负责服务客户端的子进程退出连接后,父进程进行后续处理。

    父进程是专门用于处理客户端连接的,父进程会注册SIGCHLD信号,在信号函数中将连接数进行减一操作。

    //子进程退出时候的信号处理函数
    signal(SIGCHLD, handle_sigchld);
    void handle_sigchld(int sig)
    {
    	// 当一个客户端退出的时候,那么该客户端对应ip的连接数要减1,
    	// 处理过程是这样的,首先是客户端退出的时候,
    	// 父进程需要知道这个客户端的ip,这可以通过在s_pid_ip_hash查找得到,
    	
    
    	pid_t pid;
    	while ((pid = waitpid(-1, NULL, WNOHANG)) > 0) {
    		--s_children;
    		//通过pid找到ip
    		unsigned int *ip = hash_lookup_entry(s_pid_ip_hash, &pid, sizeof(pid));
    		if (ip == NULL) {
    			continue;
    		}
    
    		drop_ip_count(ip);
    		//进程退出,进程和ip的表项就没有意义了
    		hash_free_entry(s_pid_ip_hash, &pid, sizeof(pid));
    	}
    
    }

    二、每IP连接数的限制

    概念

    是在说某个IP能够连接的最大个数。如果达到了每IP的最大连接数的数量,即使没有达到总的最大连接数的限制,那么也会中断当前连接。

    实现

    维护两个哈希表

    static hash_t *s_ip_count_hash   ip与对应连接数的哈希表

    static hash_t *s_pid_ip_hash        进程与ip对应的哈希函数表

    将当前ip的连接数保存在变量num_this_ip中,然后与配置项tumable_max_per_ip进行比较,如果超过了就不让登录,当一个客户登录的时候,要在s_ip_count_hash这个哈希表中更新对应的表项,即该ip对应的连接数要加1,如果这个表项还不存在,要在表中添加一条记录,并将ip对应的连接数置1,当一个客户端退出的时候,那么该客户端对应ip的连接数减1,处理过程是这样的,首先是客户端退出的时候,父进程需要知道这个客户的ip,这可以通过在s_pid_ip_hash这个哈希表中查找得到,得到了ip进而我们就可以在s_ip_count_hash表中找到对应的连接数,进而进行减1操作。

    因为子进程的退出的时候,父进程要减少该进程对应ip的连接数,但是父进程只能知道是哪个进程退出了,不能知道是哪个ip的连接数需要减一,所以进程与ip对应的哈希函数表是必要的。

    1.建立两个哈希表

    //创建hash表,256是桶的个数,hash_fun是哈希函数
    s_ip_count_hash = hash_alloc(256, hash_func);
    s_pid_ip_hash = hash_alloc(256, hash_func);
    //哈希函数
    unsigned int hash_func(unsigned int buckets, void *key)
    {
    	unsigned int *number = (unsigned int*)key;//void*转换为unsigned int*
    
    	//返回桶号
    	return (*number) % buckets;
    }

    2.连接建立之后,s_ip_count_hash的更新

    当客户端的一个连接过来之后,可以由accept得到对等方的地址,然后对ip和连接数的哈希表进行更新操作。如果之前有这个ip,连接数加1;如果之前没有这个ip,插入一个ip和连接数为1的表项。

    //返回当前ip的连接数,进行加1操作
    unsigned int handle_ip_count(void *ip)
    {
    	// 当一个客户登录的时候,要在s_ip_count_hash更新这个表中的对应表项,
    	// 即该ip对应的连接数要加1,如果这个表项还不存在,要在表中添加一条记录,
    	// 并且将ip对应的连接数置1。
    
    	unsigned int count;
    	unsigned int *p_count = (unsigned int *)hash_lookup_entry(s_ip_count_hash,
    		ip, sizeof(unsigned int));
    	//表明该ip是第一次连接
    	if (p_count == NULL) {
    		count = 1;
    		//插入一个表项
    		hash_add_entry(s_ip_count_hash, ip, sizeof(unsigned int),
    			&count, sizeof(unsigned int));
    	}
    	//表项已经存在,更新对应的连接数
    	else {
    		count = *p_count;
    		++count;
    		*p_count = count;
    	}
    
    	return count;
    }

    3.连接建立之后,s_pid_ip_hash的更新

    插入进程和ip的表项,这是在父进程中进行的

    //添加进程和ip的对应关系,这里的进程是子进程
    hash_add_entry(s_pid_ip_hash, &pid, sizeof(pid),
    		&ip, sizeof(unsigned int));

    4.在子进程中进行连接数的判断

    先判断总的最大连接数,如果超过最大连接数就要退出当前子进程;再判断是否超过每ip的最大连接数,如果超过最大连接数就要退出当前子进程。

    //连接数的判定
    void check_limits(session_t *sess)
    {
    	//最大连接数配置项是否开启并且当前连接数超过了最大连接数
    	if (tunable_max_clients > 0 && sess->num_clients > tunable_max_clients) {
    		ftp_reply(sess, FTP_TOO_MANY_USERS, 
    			"There are too many connected users, please try later.");
    
    		//退出当前子进程
    		exit(EXIT_FAILURE);
    	}
    
        //最大连接数没有超过上限的情况下,再检查ip的连接数是否超过上限
    	if (tunable_max_per_ip > 0 && sess->num_this_ip > tunable_max_per_ip) {
    		ftp_reply(sess, FTP_IP_LIMIT, 
    			"There are too many connections from your internet address.");
    
    		exit(EXIT_FAILURE);
    	}
    }

    5.子进程退出之后,父进程进入sigchld信号处理函数

    首先在哈希表s_pid_ip_hash中根据进程号获得ip

    void handle_sigchld(int sig)
    {
    	// 当一个客户端退出的时候,那么该客户端对应ip的连接数要减1,
    	// 处理过程是这样的,首先是客户端退出的时候,
    	// 父进程需要知道这个客户端的ip,这可以通过在s_pid_ip_hash查找得到,
    	
    
    	pid_t pid;
    	while ((pid = waitpid(-1, NULL, WNOHANG)) > 0) {
    		--s_children;
    		//通过pid找到ip
    		unsigned int *ip = hash_lookup_entry(s_pid_ip_hash, &pid, sizeof(pid));
    		if (ip == NULL) {
    			continue;
    		}
    
    		drop_ip_count(ip);
    		//进程退出,进程和ip的表项就没有意义了
    		hash_free_entry(s_pid_ip_hash, &pid, sizeof(pid));
    	}
    
    }

    然后将该ip的连接数减1,如果ip数减为0,那么将该ip和连接数的对应表项删除。

    //减1操作
    void drop_ip_count(void *ip)
    {
    	// 得到了ip进而我们就可以在s_ip_count_hash表中找到对应的连接数,进而进行减1操作。
    
    	unsigned int count;
    	unsigned int *p_count = (unsigned int *)hash_lookup_entry(s_ip_count_hash,
    		ip, sizeof(unsigned int));
    	if (p_count == NULL) {
    		return;
    	}
    
    	count = *p_count;
    	if (count <= 0) {
    		return;
    	}
    	--count;
    	*p_count = count;
    
    	if (count == 0) {
    		//可以删除表项了
    		hash_free_entry(s_ip_count_hash, ip, sizeof(unsigned int));
    	}
    }

    进程退出之后,进程和ip的表项也就没有意义了,删除。

     

    展开全文
  • 数据库最大连接数

    千次阅读 2020-09-16 17:08:30
    1、数据库默认的最大连接数? 最大默认连接数:100 2、查询数据库最大连接数 show variables like '%max_connections%'; 3、修改数据库最大连接数 set GLOBAL max_connections = 1000; 基本上设置最大链接数为...

    1、数据库默认的最大连接数?

    最大默认连接数:100

    2、查询数据库最大连接数

                show variables like '%max_connections%';
    

    3、修改数据库最大连接数

                set GLOBAL max_connections = 1000;
    

    基本上设置最大链接数为1000就足够了!

    展开全文
  • 为了确保服务不会被过多的http长连接压垮,我们需要对tomcat设定个最大连接数,超过这个连接数的请求会拒绝,让其负载到其它机器。达到保护自己的同时起到连接数负载均衡的作用。 动手去做 一开始根据故障todoList...
  • 查看nginx的最大连接数 (1) 控制 Nginx 单个进程允许的最大连接数的参数为 worker_connections ,这个参数要根据服务器性能和内存使用量来调整 (2) 进程的最大连接数受 Linux 系统进程的最大打开文件数限制,只有...
  • 1、查看最大连接数 show variables like '%max_connections%'; 2、修改最大连接数 set GLOBAL max_connections = 200; 以下的文章主要是向大家介绍的是MySQL最大连接数的修改,我们大家都知道MySQL最大连接数的...
  • oracle 查看连接数及修改最大连接数

    千次阅读 2019-10-10 17:56:26
    username --连接用户名 program --应用程序名 machine --机器名 osuser --操作系统用户 logon_time --登录时间 STATUS --session状态( Achtive:正执行SQL语句,Inactive:等待操作.Killed:被...
  • MySQL修改最大连接数

    千次阅读 2019-01-06 14:57:06
    修改最大连接数 方法一: set GLOBAL max_connections=512; 这种方法在重启服务后会失效 方法二: 修改mysql配置文件my.cnf,在[mysqld]段中添加或修改max_connections值: max_connections=512 ...
  • linux修改mysql最大连接数

    千次阅读 2019-05-29 20:43:21
    第一步:进入mysql安装目录 /usr/bin cd /usr/bin 第二步:进入mysql mysql -uroot -p 第三步:查看mysql最大连接...第四步:在文件etc/my.cnf中设置Mysql 最大连接数 vi /etc/my.cnf 第五步:重启mysql sy...
  • mysql数据库的默认的最大连接数

    千次阅读 2019-08-13 22:16:53
    MySQL查看最大连接数和修改最大连接数 1、查看最大连接数 show variables like '%max_connections%'; 2、修改最大连接数 set GLOBAL max_connections = 200;   大家都知道MySQL最大连接数的默认值是100, 这个...
  • 服务器最大连接数问题

    万次阅读 2018-04-06 17:10:32
    服务器进程会有一个最大连接数,如果达到最大连接数,server端报错: listener accept fail: accept tcp [::]:6080: accept4: too many open files 此时,client端报错: dial tcp 172.20.152.87:...
  • 【MySQL】——mysql最大连接数

    千次阅读 2020-05-14 11:16:01
    一、前言 项目中可能会遇到MySQL: ERROR 1040: Too many ... Mysql的max_connections参数用来设置最大连接(用户)。每个连接MYSQL的用户均算作一个连接,max_connections的默认值为100。这个数值对于...
  • ##redis客户端连接数 redis通过监听一个TCP端口或socket的方式接收来自客户端的连接, 当与客户端建立连接后,redis内部会进行如下操作: (1)客户端socket会被设置为非阻塞模式,因为redis在网络时间处理上...
  • 修改达梦数据库最大连接数

    千次阅读 2021-03-03 17:35:40
    查询当前最大连接数 select SF_GET_PARA_VALUE(2,‘MAX_SESSIONS’); 修改最大连接 ALTER SYSTEM SET 'MAX_SESSIONS' =1000 spfile 重启达梦 再次查询 select SF_GET_PARA_VALUE(2,‘MAX_SESSIONS’);
  • 查看Oracle最大连接数和当前连接数

    千次阅读 2019-04-19 10:23:32
    查看Oracle最大连接数和当前连接数 在查看数据的连接情况很有用,写完程序一边测试代码一边查看数据库连接的释放情况有助于分析优化出一个健壮的系统程序来。 1、查看当前的数据库连接数 select count(*) from v$...
  • 一、设置最大连接数 下面的T-SQL 语句可以配置SQL Server 允许的并发用户连接的最大数目。 exec sp_configure ‘show advanced options’, 1 exec sp_configure ‘user connections’, 100 第一句用以表示显示sp_...
  • MySQL查看最大连接数和修改最大连接数 1、查看最大连接数 show variables like '%max_connections%'; 2、修改最大连接数 set GLOBAL max_connections = 200;  以下的文章主要是向大家介绍的是MySQL最大...
  • tomcat 的最大连接数

    万次阅读 2018-04-17 19:16:43
    前提说明为了确保服务不会被过多的http长连接压垮,我们需要对tomcat设定个最大连接数,超过这个连接数的请求会拒绝,让其负载到其它机器。达到保护自己的同时起到连接数负载均衡的作用。动手去做一开始根据故障...
  • 突破netty单机最大连接数

    千次阅读 2018-11-01 09:15:32
    在linux系统里面,单个进程打开的句柄数是非常有限的,一条TCP连接就对应一个文件句柄,而对于我们应用程序来说,一个服务端默认建立的连接数是有限制的。 如下图所示,通常一个客户端去除一些被占用的端口之后,...
  • mongodb最大连接数最大连接数修改

    千次阅读 2018-09-03 13:15:42
    配置文件中有个参数:设置最大连接数 net.maxIncomingConnections Type: integer Default: 65536 The maximum number of simultaneous connections that mongos...
  • RabbitMQ——最大连接数

    千次阅读 2019-08-30 11:03:11
    连接数最多为829,连接数的具体计算方式为: 连接数=(文件句柄数-100)*0.9,计算后的值取整再减2。 例如:(1024-100)*0.9=831.6,取整831再减2得到829。 真正使用时,1024可能无法满足实际需求。这个时候,...
  • MySQL查看最大连接数和修改最大连接数 1、查看最大连接数 show variables like '%max_connections%'; 2、修改最大连接数 set GLOBAL max_connections = 200;  以下的文章主要是向大家介绍的是MySQL最大连接数的...
  • nginx 设置最大连接数

    千次阅读 2019-11-19 11:38:56
    # 一个进程允许处理的最大连接数 worker_connections 1024; 2.一个进程最大连接数怎么计算 查看系统级的最大限制和查看用户级的限制(一般是1024,向阿里云华为云这种云主机一般是65535) [root@localhost ...
  • 1、设置最大连接数 ​ 修改mysql客户端最大连接数可以通过两种方式,一种是使用命令设置,另一种是直接修改my.cnf文件,本文写作基于mysql5.7。 $ mysql -V mysql Ver 14.14 Distrib 5.7.30, for Linux (x86_64) ...
  • tomcat优化之增加Tomcat最大连接数

    千次阅读 2019-06-13 16:51:54
    我在做完一个XXX项目后,测试时发现并发数量增加到一定程度就会很卡,于是我想到了是不是tomcat最大连接数设置有限制.果不其然,配置文件中最大值才500,于是我更改了最大连接数,根据业务我修改了连接数为1500,完美的...
  • tomcat默认最大连接数与调整

    千次阅读 2020-02-15 22:19:40
    一般来说我们都是用tomcat默认的配置做基础的本地开发,测试及生产肯定不用tomcat啦,正式一点的企业肯定换大型容器了,当然不排除还是用tomcat或者它的集群的,言归正传,tomcat的连接数相关配置及修改干货如下: ...
  • MySQL查询最大连接数

    千次阅读 2018-06-06 11:30:09
    show variables like '%max_connections%'; 
  • 最近有个项目要用 etcd ,同时会有很多服务来连 etcd ,但是没搞清楚 etcd 的最大连接数是多少,总是心里虚,虽然可以压测。 首先试了一下,测试机器上可以创建多少个连接,大概 879 个左右。但是为什么是 879 个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 939,956
精华内容 375,982
关键字:

最大连接数