SQL Server con CPU al 100%: diagnóstico y solución

Mar 29, 2026 | SQL Server, Performance / SQL Tuning | 0 Comentarios

El CPU de tu SQL Server está muy alto y no sabés por dónde empezar. Antes de reiniciar nada, hay un proceso claro para encontrar la causa real y bajarlo — sin tocar lo que no hay que tocar.

En esta guía y video te muestro exactamente lo que hago en mis auditorías cuando me llaman por este problema.

Video explicativo paso a paso:

¿Por qué el CPU está tan alto? Las causas más frecuentes

El consumo de CPU es solo un sintoma, debemos detectar la enfermedad las cuales pueden ser:

  • Pocos recursos: Servidores o servicios en azure que tienen muy pocos recursos
  • Configuración de la instancia: MAXDOP o umbral de paralelismo mal configurados — esta es una de las causas más comunes y más fácil de corregir.
  • Falta de índices: A mayor consumo de I/O por mayor consumo de CPU
  • Problemas de diseño: Funciones en los WHERE, Order BY sin TOP, SELECT * sin sentido, conversiones implícitas, etc.
  • Mantenimiento: Estadísticas desactualizadas generan malos planes
  • Parameter sniffing: Planes compilados en cache de forma ineficiente

Paso 1 – Confirmar que SQL Server es el problema

Antes de tomar alguna medida como optimizar consultas o cambiar parámetros de la instancia, debemos estar muy seguros que el problema de consumo de CPU es de nuestro motor y no de otra aplicación (antivirus, agendes u otras aplicaciones).

Si tenés acceso al servidor, revisá el Resource Monitor o el Performance Monitor. O ejecutá esta consulta directamente en SSMS

DECLARE @ts_now bigint = (SELECT ms_ticks FROM sys.dm_os_sys_info WITH (NOLOCK)); 

SELECT TOP(60) SQLProcessUtilization AS [SQL Server Process CPU Utilization], 
               SystemIdle AS [System Idle Process], 
               100 - SystemIdle - SQLProcessUtilization AS [Other Process CPU Utilization], 
               DATEADD(ms, -1 * (@ts_now - [timestamp]), GETDATE()) AS [Event Time] 
FROM (SELECT record.value('(./Record/@id)[1]', 'int') AS record_id, 
              record.value('(./Record/SchedulerMonitorEvent/SystemHealth/SystemIdle)[1]', 'int') 
                      AS [SystemIdle], 
              record.value('(./Record/SchedulerMonitorEvent/SystemHealth/ProcessUtilization)[1]', 'int') 
                      AS [SQLProcessUtilization], [timestamp] 
         FROM (SELECT [timestamp], CONVERT(xml, record) AS [record] 
                      FROM sys.dm_os_ring_buffers WITH (NOLOCK)
                      WHERE ring_buffer_type = N'RING_BUFFER_SCHEDULER_MONITOR' 
                      AND record LIKE N'%<SystemHealth>%') AS x) AS y 
ORDER BY record_id DESC OPTION (RECOMPILE);

Lo que te muestra: el % de CPU que está usando SQL Server o Azure SQL versus el resto del sistema, con historial de los últimos 60 minutos. Si SQL Server está por encima del 80% de forma sostenida, el problema es del motor.

Paso 2 – Revisar los Waits: encontrar la causa raíz

Lo que yo hago primero es revisar los Waits (Tiempos de espera del motor) y buscar si aparece en los primeros lugares Waits como: CXPACKET, CXCONSUMER, THREADPOOL, SOS_SCHEDULER_YIELD .

WITH [Waits] 
AS (SELECT wait_type, wait_time_ms/ 1000.0 AS [WaitS],
          (wait_time_ms - signal_wait_time_ms) / 1000.0 AS [ResourceS],
           signal_wait_time_ms / 1000.0 AS [SignalS],
           waiting_tasks_count AS [WaitCount],
           100.0 *  wait_time_ms / SUM (wait_time_ms) OVER() AS [Percentage],
           ROW_NUMBER() OVER(ORDER BY wait_time_ms DESC) AS [RowNum]
    FROM sys.dm_os_wait_stats WITH (NOLOCK)
    WHERE [wait_type] NOT IN (
	    N'AZURE_IMDS_VERSIONS',
        N'BROKER_EVENTHANDLER', N'BROKER_RECEIVE_WAITFOR', N'BROKER_TASK_STOP',
		N'BROKER_TO_FLUSH', N'BROKER_TRANSMITTER', N'CHECKPOINT_QUEUE',
        N'CHKPT', N'CLR_AUTO_EVENT', N'CLR_MANUAL_EVENT', N'CLR_SEMAPHORE', N'CXCONSUMER',
        N'DBMIRROR_DBM_EVENT', N'DBMIRROR_EVENTS_QUEUE', N'DBMIRROR_WORKER_QUEUE',
		N'DBMIRRORING_CMD', N'DIRTY_PAGE_POLL', N'DISPATCHER_QUEUE_SEMAPHORE',
        N'EXECSYNC', N'FSAGENT', N'FT_IFTS_SCHEDULER_IDLE_WAIT', N'FT_IFTSHC_MUTEX',
        N'HADR_CLUSAPI_CALL', N'HADR_FILESTREAM_IOMGR_IOCOMPLETION', N'HADR_LOGCAPTURE_WAIT', 
		N'HADR_NOTIFICATION_DEQUEUE', N'HADR_TIMER_TASK', N'HADR_WORK_QUEUE',
        N'KSOURCE_WAKEUP', N'LAZYWRITER_SLEEP', N'LOGMGR_QUEUE', 
		N'MEMORY_ALLOCATION_EXT', N'ONDEMAND_TASK_QUEUE',
		N'PARALLEL_REDO_DRAIN_WORKER', N'PARALLEL_REDO_LOG_CACHE', N'PARALLEL_REDO_TRAN_LIST',
		N'PARALLEL_REDO_WORKER_SYNC', N'PARALLEL_REDO_WORKER_WAIT_WORK',
		N'PREEMPTIVE_HADR_LEASE_MECHANISM', N'PREEMPTIVE_SP_SERVER_DIAGNOSTICS',
		N'PREEMPTIVE_OS_LIBRARYOPS', N'PREEMPTIVE_OS_COMOPS', N'PREEMPTIVE_OS_CRYPTOPS',
		N'PREEMPTIVE_OS_PIPEOPS', N'PREEMPTIVE_OS_AUTHENTICATIONOPS',
		N'PREEMPTIVE_OS_GENERICOPS', N'PREEMPTIVE_OS_VERIFYTRUST',
		N'PREEMPTIVE_OS_DELETESECURITYCONTEXT', N'PREEMPTIVE_OS_REPORTEVENT',
		N'PREEMPTIVE_OS_FILEOPS', N'PREEMPTIVE_OS_DEVICEOPS', N'PREEMPTIVE_OS_QUERYREGISTRY',
		N'PREEMPTIVE_OS_WRITEFILE', N'PREEMPTIVE_OS_WRITEFILEGATHER',
		N'PREEMPTIVE_XE_CALLBACKEXECUTE', N'PREEMPTIVE_XE_DISPATCHER',
		N'PREEMPTIVE_XE_GETTARGETSTATE', N'PREEMPTIVE_XE_SESSIONCOMMIT',
		N'PREEMPTIVE_XE_TARGETINIT', N'PREEMPTIVE_XE_TARGETFINALIZE',
		N'POPULATE_LOCK_ORDINALS',
        N'PWAIT_ALL_COMPONENTS_INITIALIZED', N'PWAIT_DIRECTLOGCONSUMER_GETNEXT',
		N'PWAIT_EXTENSIBILITY_CLEANUP_TASK',
		N'QDS_PERSIST_TASK_MAIN_LOOP_SLEEP', N'QDS_ASYNC_QUEUE',
        N'QDS_CLEANUP_STALE_QUERIES_TASK_MAIN_LOOP_SLEEP', N'REQUEST_FOR_DEADLOCK_SEARCH',
		N'RESOURCE_QUEUE', N'SERVER_IDLE_CHECK', N'SLEEP_BPOOL_FLUSH', N'SLEEP_DBSTARTUP',
		N'SLEEP_DCOMSTARTUP', N'SLEEP_MASTERDBREADY', N'SLEEP_MASTERMDREADY',
        N'SLEEP_MASTERUPGRADED', N'SLEEP_MSDBSTARTUP', N'SLEEP_SYSTEMTASK', N'SLEEP_TASK',
        N'SLEEP_TEMPDBSTARTUP', N'SNI_HTTP_ACCEPT', N'SOS_WORK_DISPATCHER',
		N'SP_SERVER_DIAGNOSTICS_SLEEP', N'SOS_WORKER_MIGRATION', N'VDI_CLIENT_OTHER',
		N'SQLTRACE_BUFFER_FLUSH', N'SQLTRACE_INCREMENTAL_FLUSH_SLEEP', N'SQLTRACE_WAIT_ENTRIES',
		N'STARTUP_DEPENDENCY_MANAGER',
		N'WAIT_FOR_RESULTS', N'WAITFOR', N'WAITFOR_TASKSHUTDOWN', N'WAIT_XTP_HOST_WAIT',
		N'WAIT_XTP_OFFLINE_CKPT_NEW_LOG', N'WAIT_XTP_CKPT_CLOSE', N'WAIT_XTP_RECOVERY',
		N'XE_BUFFERMGR_ALLPROCESSED_EVENT', N'XE_DISPATCHER_JOIN',
        N'XE_DISPATCHER_WAIT', N'XE_LIVE_TARGET_TVF', N'XE_TIMER_EVENT')
    AND waiting_tasks_count > 0)
SELECT
    MAX (W1.wait_type) AS [WaitType],
	CAST (MAX (W1.Percentage) AS DECIMAL (5,2)) AS [Wait Percentage]
FROM Waits AS W1
INNER JOIN Waits AS W2
ON W2.RowNum <= W1.RowNum
GROUP BY W1.RowNum, W1.wait_type
HAVING SUM (W2.Percentage) - MAX (W1.Percentage) < 99 -- percentage threshold
OPTION (RECOMPILE);
Resultado de Wait Stats en SQL Server mostrando CXPACKET como espera dominante

En producción me encuentro con que el 60% de los casos de CPU alto tienen CXPACKET arriba — y se resuelven en 10 minutos ajustando dos parámetros (cost threshold for parallelism) y Max Degree Of Parallellism .

Paso 3 – Ajustar el paralelismo (MAXDOP y umbral)

Si confirmamos que el problema viene por paralelismo lo que debemos hacer primero es revisar como lo tenemos configurado para luego ajustarlo

Configuración de cost threshold for parallelism en SQL Server Management Studio

El valor por defecto es 5, un número totalmente ridículo y que viene desde hace varios años

Cuidado: ajustar el MAXDOP es simple porque se hace por buenas prácticas y según las guias de Microsoft, pero el umbral no es un valor muchas veces fácil de definir.

Si recomiendo que este por encima de 50 pero muchas veces no alcanza ni con eso, debes ajustar y medir.

Cambiar algunos de estos dos parámetros NO requieren reinício de la instancia

Paso 4 – Identificar las consultas que están comiendo CPU ahora

Aca es un punto clave, detectar que cosas están comiendo el CPU de nuestro motor.

¿Qué está consumiendo CPU en este momento?

Hay várias formas de verlo como (Monitor de actividad, querys internas o reportes desde el SSMS) yo prefiero usar el famoso script sp_whoisactive el cual me da mucha información valiosa, si no lo tenes instalado te lo recomiendo de verdad.

Entonces uso este código de preferencia y miro los que mas CPU me están ahora consumiendo

exec sp_whoisactive @sort_order = '[CPU] DESC'
Resultado de sp_whoisactive mostrando consultas ordenadas por consumo de CPU descendente

¿Qué consultas consumen CPU de forma recurrente?

Bueno aca es muy importante tener el Query Store activo en cada una de tus bases de datos, sin el también se puede hacer pero francamente vas a trabajar mucho mas porque necesitas poner un Evento Extendido

Yo lo uso mucho al QS y lo que hago es analizar en las bases diferentes rangos de tiempos para ver que procesos y consultas se están comiendo mi CPU

Para habilitarlo es muy simple y si no lo tenes te recomiendo que primero lo activemos y luego dejes esperar por lo menos medio dia para tener buenos datos

Habilitación de Query Store en SQL Server Management Studio desde propiedades de base de datos
Query Store de SQL Server mostrando las consultas con mayor consumo de CPU en el período

Yo aca juego con los tiempos (el QS te muestra la última hora pero lo podes cambiar desde configuraciones )

Configuración de rango de tiempo en Query Store para análisis de CPU histórico

SQL Server con CPU al 100%: diagnóstico y solución

Lo que nadie te dice sobre el CPU al 100%

Cuando el CPU al 100% aparece en sistemas críticos, un DBA especializado en SQL Server puede diagnosticar la causa sin reiniciar a ciegas.

El error más común que veo en empresas es este: el DBA detecta el problema, mata la consulta culpable, y listo — hasta la próxima vez. El CPU baja por unas horas y vuelve a subir.

El problema no es la consulta. El problema es que el entorno está configurado para que esa consulta se comporte así.

Sin ajustar el MAXDOP, sin habilitar Query Store, sin revisar los índices — el incendio se apaga hoy y se vuelve a prender mañana.

Lo que yo hago con mis clientes es atacar la emergencia y dejar el entorno configurado para que no vuelva a pasar.

Son cosas distintas y hay que hacer las dos.

Preguntas frecuentes

¿Cómo sé si el problema de CPU es de SQL Server o de otra aplicación?

Ejecutá la query contra sys.dm_os_ring_buffers que está en el Paso 1. Te muestra el % de CPU del proceso de SQL Server separado del resto del sistema. Si SQL Server está por debajo del 50% y el total del servidor está al 100%, el problema es de otra aplicación.

¿Qué valor de MAXDOP debo usar?

Depende de la cantidad de cores y del tipo de carga. Como regla general: en servidores con hasta 8 cores, MAXDOP = número de cores. En servidores con más de 8 cores, MAXDOP entre 4 y 8. Pero siempre hay que medirlo con Wait Stats antes y después del cambio.

¿Qué umbral de paralelismo debo usar?

Hoy en día, como mínimo 50, pero cada instancia es diferente: tengo clientes con valores de 200, 400 y más.

¿El Query Store impacta en el rendimiento?

Mínimamente — entre 1% y 3% de overhead según Microsoft. En todos los clientes que administro está habilitado.

¿Puedo bajar el CPU sin reiniciar SQL Server?

Sí. Todos los cambios de esta guía (ajuste de MAXDOP y del umbral de paralelismo) se aplican sin reiniciar el servicio.

¿Tu SQL Server tiene el CPU al 100% y no encontrás la causa?

En Triggerdb Consulting hacemos auditorías e implementación de las mejoras sobre rendimiento en SQL Server y Azure SQL — analizamos Waits, configuración, consultas críticas e índices, te entregamos un informe , un plan de mejora priorizado y te acompañamos a implementarlo en tu entorno productivo.

Si el problema es urgente, también podemos ayudarte o armar un abono mensual de soporte y monitoreo.

Agendemos una llamada de 15 minutos si te interesa Formulario .

Compartir 

¿Tu SQL Server está lento o consume más de lo que debería?

Encontramos la causa real (consultas, índices, configuración, storage) y te damos un plan concreto.

Maxi Accotto

Maxi Accotto

Experto en Microsoft Data & IA

Experto en Microsoft SQL Server, Power BI, Fabric e IA, con más de 25 años de experiencia.
Orador en eventos tecnológicos y líder de comunidades, compartiendo conocimiento.

Fue Microsoft MVP durante 14 años (2005–2019).

Conocé más sobre Maxi →