PostgreSQL教程FG174-PG后台工作进程：创建与运行管理

本文档风哥主要介绍PostgreSQL数据库后台工作进程的创建与运行管理，包括后台工作进程概念、开发方法、注册管理、监控配置等内容，风哥教程参考PostgreSQL官方文档Background Worker Processes、Writing Procedural Language Handlers等内容，适合高级开发人员在生产环境中使用。

Part01-基础概念与理论知识

1.1 PostgreSQL数据库后台工作进程概述

后台工作进程（Background Worker）是PostgreSQL提供的一种扩展机制，允许开发者创建在数据库服务器后台运行的进程。更多视频教程www.fgedu.net.cn。后台工作进程可以独立于客户端连接运行，执行定时任务、数据同步、监控告警等后台操作。PostgreSQL自身也使用后台工作进程实现自动清理（autovacuum）、WAL写入器等功能。

PostgreSQL数据库后台工作进程特点：

独立于客户端连接运行，不受会话影响
可以连接到数据库执行SQL操作
支持动态加载，无需重启数据库
可以配置启动时间和运行方式
支持信号处理，响应数据库状态变化

1.2 PostgreSQL数据库后台工作进程类型

后台工作进程分为两种类型：静态后台工作进程在数据库启动时加载，通过shared_preload_libraries配置；动态后台工作进程在运行时通过API注册启动。学习交流加群风哥微信: itpux-com。静态后台工作进程适合需要随数据库启动的核心功能，动态后台工作进程适合按需启动的任务。

1.3 PostgreSQL数据库后台工作进程架构

后台工作进程架构包括：进程管理器（postmaster）负责启动和监控后台工作进程；信号处理机制允许后台工作进程响应终止、重新加载配置等信号；共享内存用于后台工作进程与数据库主进程通信；SPI接口允许后台工作进程执行SQL操作。

— 查看当前运行的后台工作进程
SELECT
pid,
type,
state,
fgapplication_name,
backend_start
FROM pg_stat_activity
WHERE backend_type = ‘background worker’
ORDER BY backend_start;

— 查看后台工作进程配置
SHOW max_worker_processes;

— 输出结果
max_worker_processes
———————-
8
(1 row)

Part02-生产环境规划与建议

2.1 PostgreSQL数据库后台工作进程设计原则

后台工作进程设计原则：单一职责，每个后台工作进程只负责一个特定任务；资源控制，合理使用CPU、内存、I/O资源；错误处理，捕获异常并记录日志，避免进程崩溃；优雅退出，响应终止信号，正确释放资源；状态监控，记录运行状态便于监控。

2.2 PostgreSQL数据库后台工作进程安全配置

安全配置要点：限制后台工作进程数量，避免资源耗尽；使用专用数据库用户执行操作；限制后台工作进程的权限范围；记录所有操作日志便于审计。

2.3 PostgreSQL数据库后台工作进程监控方案

监控方案：监控进程运行状态，检测进程是否存活；监控资源使用情况，CPU、内存、I/O；监控任务执行情况，成功率和执行时间；配置告警机制，异常时及时通知。

风哥提示：后台工作进程是PostgreSQL的高级特性，使用不当可能导致系统不稳定。建议在开发前充分理解后台工作进程的工作原理，合理控制资源使用，并建立完善的监控机制。

Part03-生产环境项目实施方案

3.1 PostgreSQL数据库注册后台工作进程

3.1.1 静态注册后台工作进程

— 静态后台工作进程注册示例
— 在postgresql.conf中配置

— 配置shared_preload_libraries
shared_preload_libraries = ‘fgedu_bgworker’

— 配置自定义参数
fgedu_bgworker.enabled = true
fgedu_bgworker.interval = 60

— 重启PostgreSQL使配置生效
$ systemctl restart postgresql-18

— 输出结果
Job for postgresql-18.service canceled.

— 查看后台工作进程是否启动
SELECT pid, fgapplication_name, backend_start
FROM pg_stat_activity
WHERE fgapplication_name LIKE ‘fgedu%’;

— 输出结果
pid | fgapplication_name | backend_start
——-+——————+——————————-
5678 | fgedu_monitor | 2026-04-07 16:00:00.123456+08
(1 row)

3.1.2 动态注册后台工作进程

— 动态后台工作进程注册C代码示例
— fgedu_dynamic_bgworker.c

#include “postgres.h”
#include “fmgr.h”
#include “postmaster/bgworker.h”
#include “storage/ipc.h”
#include “storage/latch.h”
#include “executor/spi.h”

PG_MODULE_MAGIC;

/* 后台工作进程主函数 */
static void
fgedu_bgworker_main(Datum main_arg)
{
/* 初始化 */
pqsignal(SIGTERM, die);
BackgroundWorkerUnblockSignals();

/* 连接数据库 */
BackgroundWorkerInitializeConnection(“fgedudb”, “fgedu”, 0);

/* 主循环 */
while (true)
{
int rc;

/* 等待信号或超时 */
rc = WaitLatch(&MyProc->procLatch,
WL_LATCH_SET | WL_TIMEOUT | WL_POSTMASTER_DEATH,
60000L, /* 60秒超时 */
PG_WAIT_EXTENSION);

ResetLatch(&MyProc->procLatch);

/* 检查是否需要退出 */
if (rc & WL_POSTMASTER_DEATH)
proc_exit(1);

/* 执行任务 */
SPI_connect();

/* 执行SQL操作 */
SPI_exec(“INSERT INTO fgedu_bgworker_log(message, create_time) ”
“VALUES(‘heartbeat’, NOW())”, 0);

SPI_finish();
}
}

/* 注册后台工作进程 */
void
_PG_init(void)
{
BackgroundWorker worker;

/* 配置后台工作进程 */
memset(&worker, 0, sizeof(BackgroundWorker));
worker.bgw_flags = BGWORKER_SHMEM_ACCESS |
BGWORKER_BACKEND_DATABASE_CONNECTION;
worker.bgw_start_time = BgWorkerStart_RecoveryFinished;
worker.bgw_restart_time = 5; /* 崩溃后5秒重启 */
worker.bgw_main = fgedu_bgworker_main;
snprintf(worker.bgw_name, BGW_MAXLEN, “fgedu_monitor”);
snprintf(worker.bgw_type, BGW_MAXLEN, “fgedu_monitor”);

/* 注册后台工作进程 */
RegisterBackgroundWorker(&worker);
}

3.2 PostgreSQL数据库开发后台工作进程

3.2.1 完整的后台工作进程示例

— 完整的后台工作进程代码
— fgedu_monitor_bgworker.c

#include “postgres.h”
#include “fmgr.h”
#include “postmaster/bgworker.h”
#include “storage/ipc.h”
#include “storage/latch.h”
#include “executor/spi.h”
#include “utils/builtins.h”
#include “tcop/utility.h”

PG_MODULE_MAGIC;

/* 全局变量 */
static volatile sig_atomic_t got_sigterm = false;

/* 信号处理函数 */
static void
handle_sigterm(SIGNAL_ARGS)
{
int save_errno = errno;
got_sigterm = true;
SetLatch(MyLatch);
errno = save_errno;
}

/* 后台工作进程主函数 */
static void
fgedu_monitor_main(Datum main_arg)
{
StringInfoData buf;

/* 设置信号处理 */
pqsignal(SIGTERM, handle_sigterm);
BackgroundWorkerUnblockSignals();

/* 连接到数据库 */
BackgroundWorkerInitializeConnection(“fgedudb”, “fgedu”, 0);

elog(LOG, “fgedu_monitor: 后台工作进程启动”);

/* 主循环 */
while (!got_sigterm)
{
int rc;
int ret;

/* 等待 */
rc = WaitLatch(MyLatch,
WL_LATCH_SET | WL_TIMEOUT | WL_POSTMASTER_DEATH,
60000L,
PG_WAIT_EXTENSION);

ResetLatch(MyLatch);

CHECK_FOR_INTERRUPTS();

/* 检查postmaster是否退出 */
if (rc & WL_POSTMASTER_DEATH)
{
elog(LOG, “fgedu_monitor: Postmaster已退出”);
break;
}

/* 执行监控任务 */
SPI_connect();

/* 检查表空间使用情况 */
ret = SPI_execute(
“INSERT INTO fgedu_monitor_log ”
“SELECT tablespace, ”
” pg_size_pretty(pg_tablespace_size(tablespace)) as size, ”
” NOW() as check_time ”
“FROM pg_tablespace”,
false, 0);

if (ret != SPI_OK_INSERT)
elog(WARNING, “fgedu_monitor: 插入监控日志失败”);

/* 检查长时间运行的查询 */
ret = SPI_execute(
“INSERT INTO fgedu_long_query_log ”
“SELECT pid, query, state, now() – query_start as duration ”
“FROM pg_stat_activity ”
“WHERE state = ‘active’ ”
“AND now() – query_start > interval ‘5 minutes'”,
false, 0);

SPI_finish();

elog(LOG, “fgedu_monitor: 监控任务执行完成”);
}

elog(LOG, “fgedu_monitor: 后台工作进程退出”);
proc_exit(0);
}

/* 扩展初始化函数 */
void
_PG_init(void)
{
BackgroundWorker worker;

if (!process_shared_preload_libraries_in_progress)
return;

memset(&worker, 0, sizeof(BackgroundWorker));
worker.bgw_flags = BGWORKER_SHMEM_ACCESS |
BGWORKER_BACKEND_DATABASE_CONNECTION;
worker.bgw_start_time = BgWorkerStart_RecoveryFinished;
worker.bgw_restart_time = 10;
worker.bgw_main = fgedu_monitor_main;
snprintf(worker.bgw_name, BGW_MAXLEN, “fgedu_monitor”);
snprintf(worker.bgw_type, BGW_MAXLEN, “fgedu_monitor”);
worker.bgw_notify_pid = 0;

RegisterBackgroundWorker(&worker);
}

— Makefile
MODULES = fgedu_monitor_bgworker
EXTENSION = fgedu_monitor
DATA = fgedu_monitor–1.0.sql

PG_CONFIG = pg_config
PGXS := $(shell $(PG_CONFIG) –pgxs)
include $(PGXS)

— fgedu_monitor–1.0.sql
CREATE TABLE fgedu_monitor_log (
id SERIAL PRIMARY KEY,
tablespace VARCHAR(100),
size TEXT,
check_time TIMESTAMP DEFAULT NOW()
);

CREATE TABLE fgedu_long_query_log (
id SERIAL PRIMARY KEY,
pid INTEGER,
query TEXT,
state VARCHAR(50),
duration INTERVAL,
log_time TIMESTAMP DEFAULT NOW()
);

— 编译安装
$ make
$ make install

— 配置postgresql.conf
shared_preload_libraries = ‘fgedu_monitor_bgworker’

— 重启PostgreSQL
$ systemctl restart postgresql-18

— 查看日志
$ tail -f /postgresql/fgdata/log/postgresql-*.log

— 输出结果
2026-04-07 16:00:00.123 CST [12345] LOG: fgedu_monitor: 后台工作进程启动
2026-04-07 16:01:00.234 CST [12345] LOG: fgedu_monitor: 监控任务执行完成
2026-04-07 16:02:00.345 CST [12345] LOG: fgedu_monitor: 监控任务执行完成

3.3 PostgreSQL数据库管理后台工作进程

3.3.1 查看后台工作进程状态

— 查看所有后台工作进程
SELECT
pid,
datname,
usename,
fgapplication_name,
client_addr,
backend_start,
state,
query
FROM pg_stat_activity
WHERE backend_type = ‘background worker’
ORDER BY backend_start;

— 查看后台工作进程数量
SELECT COUNT(*) as bgworker_count
FROM pg_stat_activity
WHERE backend_type = ‘background worker’;

— 输出结果
bgworker_count
—————-
5
(1 row)

— 查看后台工作进程配置
SHOW max_worker_processes;
SHOW dynamic_shared_memory_type;

— 输出结果
max_worker_processes
———————-
8
(1 row)

dynamic_shared_memory_type
—————————
posix
(1 row)

3.3.2 终止后台工作进程

— 终止特定的后台工作进程
SELECT pg_terminate_backend(12345);

— 输出结果
pg_terminate_backend
———————-
t
(1 row)

— 取消后台工作进程的当前查询
SELECT pg_cancel_backend(12345);

— 输出结果
pg_cancel_backend
——————-
t
(1 row)

— 查看进程是否已终止
SELECT pid, fgapplication_name FROM pg_stat_activity WHERE pid = 12345;

— 输出结果
pid | fgapplication_name
—–+——————
(0 rows)

Part04-生产案例与实战讲解

4.1 PostgreSQL数据库监控任务后台进程实战

本案例演示如何开发一个监控任务后台工作进程，定期收集数据库性能指标。学习交流加群风哥QQ113257174。

— 创建监控数据表
CREATE TABLE fgedu_perf_metrics (
id SERIAL PRIMARY KEY,
metric_name VARCHAR(100),
metric_value NUMERIC(15,4),
metric_unit VARCHAR(50),
collect_time TIMESTAMP DEFAULT NOW()
);

CREATE INDEX idx_perf_metrics_time ON fgedu_perf_metrics(collect_time);

— 监控后台工作进程核心代码片段
static void
collect_metrics(void)
{
int ret;

/* 收集连接数 */
ret = SPI_execute(
“INSERT INTO fgedu_perf_metrics(metric_name, metric_value, metric_unit) ”
“SELECT ‘active_connections’, COUNT(*), ‘count’ ”
“FROM pg_stat_activity WHERE state = ‘active'”,
false, 0);

/* 收集事务数 */
ret = SPI_execute(
“INSERT INTO fgedu_perf_metrics(metric_name, metric_value, metric_unit) ”
“SELECT ‘xact_commit’, xact_commit::numeric, ‘count’ ”
“FROM pg_stat_database WHERE datname = current_database()”,
false, 0);

/* 收集缓存命中率 */
ret = SPI_execute(
“INSERT INTO fgedu_perf_metrics(metric_name, metric_value, metric_unit) ”
“SELECT ‘cache_hit_ratio’, ”
” CASE WHEN (blks_hit + blks_read) > 0 ”
” THEN blks_hit::numeric / (blks_hit + blks_read) * 100 ”
” ELSE 0 END, ‘percent’ ”
“FROM pg_stat_database WHERE datname = current_database()”,
false, 0);

/* 收集锁等待 */
ret = SPI_execute(
“INSERT INTO fgedu_perf_metrics(metric_name, metric_value, metric_unit) ”
“SELECT ‘lock_waits’, COUNT(*), ‘count’ ”
“FROM pg_locks WHERE NOT granted”,
false, 0);
}

— 查看收集的监控数据
SELECT
metric_name,
metric_value,
metric_unit,
collect_time
FROM fgedu_perf_metrics
WHERE collect_time > NOW() – INTERVAL ‘1 hour’
ORDER BY collect_time DESC
LIMIT 20;

4.2 PostgreSQL数据库数据同步后台进程实战

本案例演示如何开发一个数据同步后台工作进程，实现增量数据同步。更多学习教程公众号风哥教程itpux_com。

— 创建同步状态表
CREATE TABLE fgedu_sync_status (
id SERIAL PRIMARY KEY,
source_table VARCHAR(100),
target_table VARCHAR(100),
last_sync_time TIMESTAMP,
sync_count INTEGER DEFAULT 0,
status VARCHAR(20) DEFAULT ‘pending’,
error_message TEXT
);

— 创建同步日志表
CREATE TABLE fgedu_sync_log (
id SERIAL PRIMARY KEY,
sync_id INTEGER REFERENCES fgedu_sync_status(id),
operation VARCHAR(20),
record_count INTEGER,
sync_time TIMESTAMP DEFAULT NOW()
);

— 数据同步后台工作进程核心逻辑
static void
sync_data_task(void)
{
int ret;
StringInfoData query;

initStringInfo(&query);

/* 获取需要同步的表 */
ret = SPI_execute(
“SELECT id, source_table, target_table, last_sync_time ”
“FROM fgedu_sync_status WHERE status = ‘pending'”,
true, 0);

if (ret == SPI_OK_SELECT && SPI_processed > 0)
{
for (int i = 0; i < SPI_processed; i++) { HeapTuple tuple = SPI_tuptable->vals[i];
TupleDesc tupdesc = SPI_tuptable->tupdesc;
bool isnull;

int sync_id = DatumGetInt32(
SPI_getbinval(tuple, tupdesc, 1, &isnull));
char *source_table = SPI_getvalue(tuple, tupdesc, 2);
char *target_table = SPI_getvalue(tuple, tupdesc, 3);
char *last_sync = SPI_getvalue(tuple, tupdesc, 4);

/* 构建同步查询 */
resetStringInfo(&query);
if (last_sync && strlen(last_sync) > 0)
{
fgappendStringInfo(&query,
“INSERT INTO %s SELECT * FROM %s ”
“WHERE update_time > ‘%s'”,
target_table, source_table, last_sync);
}
else
{
fgappendStringInfo(&query,
“INSERT INTO %s SELECT * FROM %s”,
target_table, source_table);
}

/* 执行同步 */
ret = SPI_execute(query.data, false, 0);

/* 更新同步状态 */
if (ret == SPI_OK_INSERT)
{
fgappendStringInfo(&query,
“UPDATE fgedu_sync_status ”
“SET last_sync_time = NOW(), ”
” sync_count = sync_count + %ld, ”
” status = ‘completed’ ”
“WHERE id = %d”,
SPI_processed, sync_id);
SPI_execute(query.data, false, 0);
}
else
{
fgappendStringInfo(&query,
“UPDATE fgedu_sync_status ”
“SET status = ‘failed’, ”
” error_message = ‘Sync failed’ ”
“WHERE id = %d”,
sync_id);
SPI_execute(query.data, false, 0);
}

pfree(source_table);
pfree(target_table);
pfree(last_sync);
}
}

pfree(query.data);
}

— 配置同步任务
INSERT INTO fgedu_sync_status(source_table, target_table, status)
VALUES(‘fgedu_orders’, ‘fgedu_orders_backup’, ‘pending’);

— 查看同步状态
SELECT * FROM fgedu_sync_status;

4.3 PostgreSQL数据库日志清理后台进程实战

本案例演示如何开发一个日志清理后台工作进程，定期清理过期日志数据。from PostgreSQL视频:www.itpux.com。

— 创建日志清理配置表
CREATE TABLE fgedu_log_cleanup_config (
id SERIAL PRIMARY KEY,
table_name VARCHAR(100) NOT NULL,
time_column VARCHAR(100) NOT NULL DEFAULT ‘create_time’,
retention_days INTEGER NOT NULL DEFAULT 30,
batch_size INTEGER DEFAULT 1000,
enabled BOOLEAN DEFAULT TRUE
);

— 创建清理日志表
CREATE TABLE fgedu_cleanup_log (
id SERIAL PRIMARY KEY,
table_name VARCHAR(100),
deleted_rows INTEGER,
cleanup_time TIMESTAMP DEFAULT NOW()
);

— 插入清理配置
INSERT INTO fgedu_log_cleanup_config(table_name, time_column, retention_days, batch_size)
VALUES
(‘fgedu_audit_log’, ‘audit_time’, 90, 5000),
(‘fgedu_monitor_log’, ‘check_time’, 30, 10000),
(‘fgedu_perf_metrics’, ‘collect_time’, 7, 50000);

— 日志清理后台工作进程核心逻辑
static void
cleanup_logs_task(void)
{
int ret;
StringInfoData query;

initStringInfo(&query);

/* 获取清理配置 */
ret = SPI_execute(
“SELECT id, table_name, time_column, retention_days, batch_size ”
“FROM fgedu_log_cleanup_config WHERE enabled = true”,
true, 0);

if (ret == SPI_OK_SELECT && SPI_processed > 0)
{
for (int i = 0; i < SPI_processed; i++) { HeapTuple tuple = SPI_tuptable->vals[i];
TupleDesc tupdesc = SPI_tuptable->tupdesc;
bool isnull;
int64 total_deleted = 0;

int config_id = DatumGetInt32(
SPI_getbinval(tuple, tupdesc, 1, &isnull));
char *table_name = SPI_getvalue(tuple, tupdesc, 2);
char *time_column = SPI_getvalue(tuple, tupdesc, 3);
int retention_days = DatumGetInt32(
SPI_getbinval(tuple, tupdesc, 4, &isnull));
int batch_size = DatumGetInt32(
SPI_getbinval(tuple, tupdesc, 5, &isnull));

/* 分批删除 */
while (true)
{
resetStringInfo(&query);
fgappendStringInfo(&query,
“DELETE FROM %s ”
“WHERE %s < NOW() - INTERVAL '%d days' " "LIMIT %d", table_name, time_column, retention_days, batch_size); ret = SPI_execute(query.data, false, 0); if (ret == SPI_OK_DELETE && SPI_processed > 0)
{
total_deleted += SPI_processed;

/* 提交事务，避免长事务 */
SPI_finish();
SPI_connect();

/* 如果删除数量小于批次大小，说明已清理完毕 */
if (SPI_processed < batch_size) break; } else { break; } } /* 记录清理日志 */ if (total_deleted > 0)
{
resetStringInfo(&query);
fgappendStringInfo(&query,
“INSERT INTO fgedu_cleanup_log(table_name, deleted_rows) ”
“VALUES(‘%s’, %ld)”,
table_name, total_deleted);
SPI_execute(query.data, false, 0);
}

pfree(table_name);
pfree(time_column);
}
}

pfree(query.data);
}

— 查看清理日志
SELECT * FROM fgedu_cleanup_log ORDER BY cleanup_time DESC LIMIT 10;

Part05-风哥经验总结与分享

5.1 PostgreSQL数据库后台工作进程最佳实践

后台工作进程最佳实践：合理设置超时时间，避免长时间阻塞；使用分批处理处理大数据量；正确处理信号，实现优雅退出；记录详细日志便于问题排查；监控进程状态，及时发现异常。

后台工作进程开发检查清单：

正确设置信号处理函数
使用WaitLatch而不是sleep
检查postmaster是否存活
正确处理SPI连接和断开
避免内存泄漏
记录运行日志
实现优雅退出机制

5.2 PostgreSQL数据库后台工作进程调试技巧

调试技巧：使用elog输出调试信息到日志；检查postmaster日志查看进程状态；使用gdb附加到进程进行调试；检查共享内存状态。

5.3 PostgreSQL数据库后台工作进程常见问题

常见问题：进程崩溃后无法自动重启；内存泄漏导致系统内存耗尽；死锁导致进程阻塞；SPI连接失败导致无法执行SQL。

— 常见问题排查

— 问题1：后台工作进程未启动
— 检查配置
SHOW shared_preload_libraries;
SHOW max_worker_processes;

— 检查日志
$ grep “background worker” /postgresql/fgdata/log/postgresql-*.log

— 问题2：进程崩溃
— 检查崩溃日志
$ grep “FATAL\|PANIC” /postgresql/fgdata/log/postgresql-*.log

— 问题3：内存泄漏
— 监控进程内存使用
SELECT pid, fgapplication_name,
pg_size_pretty(pg_backend_memory_contexts.pid) as memory
FROM pg_stat_activity
WHERE backend_type = ‘background worker’;

— 问题4：SPI连接失败
— 检查数据库连接权限
SELECT * FROM pg_roles WHERE rolname = ‘fgedu’;

风哥提示：后台工作进程是PostgreSQL的高级特性，适合实现定时任务、数据同步、监控告警等后台功能。开发时要注意资源管理和错误处理，生产环境中要建立完善的监控机制，及时发现和处理异常情况。

本文由风哥教程整理发布,仅用于学习测试使用,转载注明出处:http://www.fgedu.net.cn/10327.html