How to fix ERROR 2006 (HY000): MySQL server has gone away in MySQL

# Linux - check service
sudo systemctl status mysql

# macOS - check if running
brew services list | grep mysql

# Windows - check Services
sc query MySQL80

# Or check if port is listening
sudo netstat -tulpn | grep 3306
sudo ss -tulpn | grep 3306

# Linux
sudo systemctl start mysql

# macOS with Homebrew
brew services start mysql

# Windows service
net start MySQL80

# Or direct command
mysqld_safe &

# Test simple connection
mysql -u root -p -h localhost -e "SELECT 1;"

# If this succeeds, server is responsive
# If it fails, check error logs:
tail -f /var/log/mysql/error.log

# View MySQL error log for crashes
tail -100 /var/log/mysql/error.log | grep -i "crash|start|ready"

# Check system logs for MySQL events
sudo journalctl -u mysql -n 50 --no-pager

mysql -u root -p -e "SHOW VARIABLES LIKE '%timeout%';"

+-----------+--------+
| Variable_name       | Value  |
+-----------+--------+
| connect_timeout     | 10     |
| interactive_timeout | 28800  |
| net_read_timeout    | 30     |
| net_write_timeout   | 60     |
| wait_timeout        | 28800  |
+-----------+--------+

# Edit my.cnf or mysqld.cnf
sudo nano /etc/mysql/my.cnf
# or
sudo nano /etc/mysql/mysql.conf.d/mysqld.cnf

[mysqld]
wait_timeout = 864000
interactive_timeout = 864000
net_read_timeout = 30
net_write_timeout = 60

C:\ProgramData\MySQL\MySQL Server 8.0\my.ini

# Linux
sudo systemctl restart mysql

# macOS
brew services restart mysql

# Windows
net stop MySQL80
net start MySQL80

# Connect as root
mysql -u root -p -e "SET GLOBAL wait_timeout = 864000; SET GLOBAL interactive_timeout = 864000;"

# Verify changes
mysql -u root -p -e "SHOW VARIABLES LIKE '%timeout%';"

mysql -u root -p -e "SHOW VARIABLES LIKE 'max_allowed_packet';"

sudo nano /etc/mysql/mysql.conf.d/mysqld.cnf

C:\ProgramData\MySQL\MySQL Server 8.0\my.ini

[mysqld]
max_allowed_packet = 256M

[mysqldump]
max_allowed_packet = 256M

[mysql]
max_allowed_packet = 256M

# Linux
sudo systemctl restart mysql

# macOS
brew services restart mysql

# Windows
net stop MySQL80
net start MySQL80

mysql -u root -p -e "SET GLOBAL max_allowed_packet = 268435456;"  # 256MB

# Verify
mysql -u root -p -e "SHOW VARIABLES LIKE 'max_allowed_packet';"

; In php.ini
mysql.max_allowed_packet = 256M

<?php
// Check if connection is alive before executing query
if (!$mysqli->ping()) {
    // Reconnect if connection was lost
    $mysqli->close();
    $mysqli = new mysqli("localhost", "user", "password", "database");
    if ($mysqli->connect_error) {
        die('Connect Error (' . $mysqli->connect_errno . ') ' . $mysqli->connect_error);
    }
}

// Now safe to execute query
$result = $mysqli->query("SELECT * FROM table");
?>

import mysql.connector
from mysql.connector import Error

def get_db_connection():
    try:
        connection = mysql.connector.connect(
            host='localhost',
            user='user',
            password='password',
            database='database',
            autocommit=True
        )
        return connection
    except Error as e:
        print(f"Error: {e}")
        return None

# Before each query, check connection
connection = get_db_connection()
if not connection.is_connected():
    connection = get_db_connection()

cursor = connection.cursor()
cursor.execute("SELECT 1")

const mysql = require('mysql2/promise');

const pool = mysql.createPool({
  host: 'localhost',
  user: 'user',
  password: 'password',
  database: 'database',
  waitForConnections: true,
  connectionLimit: 10,
  queueLimit: 0,
  enableKeepAlive: true,
  keepAliveInitialDelayMs: 0
});

// Query with automatic reconnection
async function executeQuery(sql) {
  let connection;
  try {
    connection = await pool.getConnection();
    const [rows] = await connection.execute(sql);
    return rows;
  } catch (error) {
    console.error('Query failed:', error);
    throw error;
  } finally {
    if (connection) {
      connection.release();
    }
  }
}

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;

HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:mysql://localhost:3306/database");
config.setUsername("user");
config.setPassword("password");
config.setMaximumPoolSize(10);
config.setMaxLifetime(1800000); // 30 minutes
config.setIdleTimeout(600000);   // 10 minutes

HikariDataSource dataSource = new HikariDataSource(config);

// Get connection (automatically managed)
try (Connection conn = dataSource.getConnection()) {
    // Execute query
}

# Ping MySQL server
ping mysql_server_hostname

# Check if port 3306 is reachable
nc -zv mysql_server_hostname 3306
telnet mysql_server_hostname 3306

# For remote connections, test from client
mysql -h mysql_server_hostname -u user -p -e "SELECT 1;"

# Establish SSH tunnel on port 3307
ssh -L 3307:localhost:3306 user@mysql_server_hostname

# Connect through tunnel
mysql -h localhost -P 3307 -u user -p

$mysqli = new mysqli("localhost", "user", "password", "database");
$mysqli->options(MYSQLI_OPT_CONNECT_TIMEOUT, 10);
$mysqli->options(MYSQLI_OPT_READ_TIMEOUT, 30);
$mysqli->options(MYSQLI_OPT_WRITE_TIMEOUT, 30);

connection = mysql.connector.connect(
    host='localhost',
    user='user',
    password='password',
    database='database',
    connection_timeout=10,
    autocommit=True
)

# Linux - check firewall rules for MySQL
sudo iptables -L -n | grep 3306
sudo ufw status | grep 3306

# macOS - check pf rules
sudo pfctl -s rules | grep 3306

# Check all mounted filesystems
df -h

# Check specifically MySQL data directory
du -sh /var/lib/mysql
du -sh /var/lib/mysql/*

# Look for nearly-full partitions (>90% full)
df -h | awk '$5 > 80 { print "WARNING: " $0 }'

# Find large files
find /var/lib/mysql -size +1G -type f

# Check binary logs (can grow large)
ls -lh /var/log/mysql/*

# Archive old binary logs
# First check retention settings
mysql -u root -p -e "SHOW BINARY LOGS;"
mysql -u root -p -e "SHOW VARIABLES LIKE 'expire_logs_days';"

# Purge old binary logs (e.g., older than 7 days)
mysql -u root -p -e "PURGE BINARY LOGS BEFORE DATE_SUB(NOW(), INTERVAL 7 DAY);"

# Check memory usage
free -h

# Check MySQL memory usage specifically
ps aux | grep mysqld | head -1
# Or
top -b -n 1 | grep mysqld

# Check if OOM killer is active
grep -i "out of memory" /var/log/syslog
dmesg | grep -i "killed process"

# Get MySQL PID
pgrep mysqld

# Check open files and limits
# If mysqld PID is 1234:
cat /proc/1234/limits

# May need to increase max_connections or other limits
mysql -u root -p -e "SHOW VARIABLES LIKE 'max_connections';"
mysql -u root -p -e "SHOW VARIABLES LIKE 'table_open_cache';"

# Use iostat to watch disk I/O
iostat -x 1

# Use top to watch processes
top

# Use htop for better interface
htop

tail -100 /var/log/mysql/error.log | grep -i "error|warning|unable"

# Check all tables in database
mysql -u root -p -e "CHECK TABLE database_name.*;"

# Or check individual table
mysql -u root -p database_name -e "CHECK TABLE table_name;"

# Check with extended option for more thorough check
mysql -u root -p database_name -e "CHECK TABLE table_name EXTENDED;"

# Check multiple tables
mysql -u root -p database_name -e "CHECK TABLE table1, table2, table3;"

Table: database.table_name  Op: check  Status: error

# Repair single table
mysql -u root -p database_name -e "REPAIR TABLE table_name;"

# Repair with options
mysql -u root -p database_name -e "REPAIR TABLE table_name QUICK;"
mysql -u root -p database_name -e "REPAIR TABLE table_name EXTENDED;"

# Repair multiple tables
mysql -u root -p database_name -e "REPAIR TABLE table1, table2, table3;"

# Stop MySQL first
sudo systemctl stop mysql

# Check table
myisamchk /var/lib/mysql/database_name/table_name.MYI

# Repair table
myisamchk -r /var/lib/mysql/database_name/table_name.MYI

# Restart MySQL
sudo systemctl start mysql

# After repair, optimize the table
mysql -u root -p database_name -e "OPTIMIZE TABLE table_name;"

# Check again to confirm
mysql -u root -p database_name -e "CHECK TABLE table_name;"

# Set recovery mode and restart
mysql -u root -p -e "SET GLOBAL innodb_force_recovery = 4;"

# Restart MySQL to rebuild tables
sudo systemctl restart mysql

# Then reset recovery mode
mysql -u root -p -e "SET GLOBAL innodb_force_recovery = 0;"

<?php
// WRONG - reusing parent connection in child process
$mysqli = new mysqli("localhost", "user", "password", "database");

foreach ($items as $item) {
    $pid = pcntl_fork();
    if ($pid == 0) {
        // Child process reusing parent's connection
        $result = $mysqli->query("SELECT * FROM table");
        exit();
    }
}

// CORRECT - establish new connection in child
foreach ($items as $item) {
    $pid = pcntl_fork();
    if ($pid == 0) {
        // Child process gets its own connection
        $child_db = new mysqli("localhost", "user", "password", "database");
        $result = $child_db->query("SELECT * FROM table");
        $child_db->close();
        exit();
    }
}

# WRONG - reusing connection across processes
import mysql.connector
from multiprocessing import Pool

db = mysql.connector.connect(
    host="localhost",
    user="user",
    password="password",
    database="database"
)

def process_item(item):
    cursor = db.cursor()  # Reused connection across processes
    cursor.execute("SELECT * FROM table")
    return cursor.fetchall()

# CORRECT - each process gets its own connection
def process_item_correct(item):
    db_local = mysql.connector.connect(
        host="localhost",
        user="user",
        password="password",
        database="database"
    )
    cursor = db_local.cursor()
    cursor.execute("SELECT * FROM table")
    result = cursor.fetchall()
    db_local.close()
    return result

if __name__ == '__main__':
    with Pool(processes=4) as pool:
        results = pool.map(process_item_correct, items)

// WRONG - sharing connection pool across threads
const pool = mysql.createPool({ /* config */ });

worker.on('message', async (msg) => {
    const conn = await pool.getConnection();
    // This can cause issues with connection state
});

// CORRECT - each worker gets its own pool
const { Worker } = require('worker_threads');

const worker = new Worker('./worker.js');
// Worker creates its own pool internally