OCI编程高级篇（二十二） OCI多线程编程和示例代码

原创 已于 2025-08-13 17:36:00 修改 · 332 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据库 #oracle #数据库开发

于 2024-09-06 14:12:06 首次发布

访问www.tomcoding.com网站，学习Oracle内部数据结构，详细文档说明，下载Oracle的exp/imp，DUL，logminer，ASM工具的源代码，学习高技术含量的内容。

在前面我们介绍连接池时，用了单线程编写了一个实例，这不能体现出连接池的优势，连接池更应该用在多线程的环境中。我们介绍了多线程的函数后，今天就用多线程改写一下原来的例子。

还是先创建连接池，然后创建并启动4个线程，每个线程赋值一个数字，然后通过数据库的dual来取得数字，打印出来，用dual来取数目的是为了使用连接池的会话。示例代码如下。

#include "stdio.h"
#include "stdlib.h"
#include "stdint.h"
#include "memory.h"
#include "string.h"
#include "time.h"
#include "errno.h"

#include "oci.h"


/* 定义全局变量 */
OCIEnv          *envhp  = NULL;         /* OCI环境句柄 */
OCIError        *errhp  = NULL;         /* 错误句柄 */
OCICPool        *poolhp = NULL;         /* 连接池句柄 */

sb4             pool_name_len;          /* 连接池名称长度 */
char            *pool_name = NULL;      /* 连接池名称 */

struct {
    char        uname[32];              /* 认证用户名 */
    char        upwd[32];               /* 认证用户密码 */
} inputs;

/* 打印使用说明 */
static void usage(const char *prg)
{
    fprintf(stderr,
        "Usage: %s user/password\n\n"
        "  user      oracle user\n"
        "  password  user password\n"
        , prg
    );
}

/* 解析命令行参数 */
static int parse_inputs(int argc, char *argv[])
{
    char        *p;

    if (argc < 2) {
      usage(argv[0]);
      return (-1);
    }

    if ((p=strchr(argv[1], '/')) == NULL) {
      usage(argv[0]);
      return (-1);
    }

    *p++ = '\0';
    memset(&inputs, 0, sizeof(inputs));
    strncpy(inputs.uname, argv[1], 31);
    strncpy(inputs.upwd, p, 31);

    return (0);
}

static char ora_env[][16] =
{
  "ORACLE_HOME",
  "ORACLE_SID",
  ""
};

/* 检查程序运行的Oracle环境变量 */
static int check_ora_env(void)
{
    int         i;

    for (i=0; ora_env[i][0]; i++) {
        if (getenv(ora_env[i]) == NULL) {
            fprintf(stderr, "env %s not set.\n", ora_env[i]);
            return (-1);
        }
    }

    return (0);
}

/* 创建连接池函数 */
static int create_connection_pool(void)
{
    sword       rc;
    sb4         ec;
    ub4         conn_min;
    ub4         conn_max;
    ub4         conn_inc;
    OraText     errbuf[512];


    /* 创建OCI环境变量，要使用OCI_THREADED模式 */
    rc = OCIEnvCreate(
        &envhp,                 /* envhpp */
        OCI_THREADED,           /* mode */
        (void *)NULL,           /* ctxp */
        NULL,
        NULL,
        NULL,
        (size_t)0,
        (void **)NULL
    );

    if (rc != OCI_SUCCESS) {
        fprintf(stderr, "OCIEnvCreate() - allocate OCI env handle error !\n");
        return (-1);
    }

    /* 分配错误句柄 */
    rc = OCIHandleAlloc(
        (void *)envhp,
        (void **)&errhp,
        OCI_HTYPE_ERROR,
        0,
        (void **)NULL
    );

    if (rc != OCI_SUCCESS) {
        fprintf(stderr, "OCIHandleAlloc() - allocate OCI error handle error !\n");
        return (-1);
    }

    /* 分配连接池句柄 */
    rc = OCIHandleAlloc(
        (void *)envhp,
        (void **)&poolhp,
        OCI_HTYPE_CPOOL,
        (size_t)0,
        (void **)NULL
    );

    if (rc != OCI_SUCCESS) {
        fprintf(stderr, "OCIHandleAlloc() - allocate connection pool handle error !\n");
        return (-1);
    }

    /* 创建连接池 */
    conn_min = 3;
    conn_max = 5;
    conn_inc = 1;
    rc = OCIConnectionPoolCreate(
        envhp, errhp, poolhp,
        (OraText **)&pool_name, &pool_name_len,
        (const OraText *)"", 0,
        (ub4)conn_min, (ub4)conn_max, (ub4)conn_inc,
        (OraText *)inputs.uname, strlen(inputs.uname),
        (OraText *)inputs.upwd, strlen(inputs.upwd),
        OCI_DEFAULT
    );

    if (rc != OCI_SUCCESS) {
        OCIErrorGet(errhp, 1, NULL, &ec, errbuf, 512, OCI_HTYPE_ERROR);
        fprintf(stderr, "OCIConnectionPoolCreate() - [%d] %s\n", ec, errbuf);
        return (-1);
    }

    return (0);
}

/* 销毁连接池函数 */
static int destroy_connection_pool(void)
{
    sword       rc;
    sb4         ec;
    OraText     errbuf[512];


    /* 销毁连接池 */
    if (poolhp != NULL) {
        rc = OCIConnectionPoolDestroy(poolhp, errhp, OCI_DEFAULT);

        if (rc != OCI_SUCCESS) {
            OCIErrorGet(errhp, 1, NULL, &ec, errbuf, 512, OCI_HTYPE_ERROR);
            fprintf(stderr, "OCIConnectionPoolDestroy() - [%d] %s\n", ec, errbuf);
            return (-1);
        }

        /* 释放连接池句柄 */
        rc = OCIHandleFree((void *)poolhp, OCI_HTYPE_CPOOL);

        if (rc != OCI_SUCCESS) {
            fprintf(stderr, "OCIHandleFree() - free connection pool handle error !\n");
            return (-1);
        }
    }

    /* 释放错误句柄 */
    if (errhp != NULL) {
        rc = OCIHandleFree(
            errhp,
            OCI_HTYPE_ERROR
        );

        if (rc != OCI_SUCCESS) {
            fprintf(stderr, "OCIHandleFree() - free error handle error !\n");
            return (-1);
        }
    }

    /* 释放OCI环境句柄 */
    if (envhp != NULL) {
        rc = OCIHandleFree(
            envhp,
            OCI_HTYPE_ENV
        );

        if (rc != OCI_SUCCESS) {
            fprintf(stderr, "OCIHandleFree() - free env handle error !\n");
            return (-1);
        }
    }

    return (0);
}

/* 线程开始运行入口函数 */
static void thread_run(void *arg)
{
    sword       rc;
    sb4         ec;
    int         num;
    int         slen;
    ub4         u4;
    OCIError    *errhp1 = NULL;
    OCISvcCtx   *svchp1 = NULL;
    OCIStmt     *stmthp = NULL;
    OCIDefine   *defp;
    char        sqltxt[1024];
    OraText     errbuf[512];


    /* 创建本线程使用的错误句柄 */
    rc = OCIHandleAlloc(
        (void *)envhp,
        (void **)&errhp1,
        OCI_HTYPE_ERROR,
        0,
        (void **)NULL
    );

    if (rc != OCI_SUCCESS) {
        fprintf(stderr, "OCIHandleAlloc() - allocate error handle error !\n");
        return;
    }

    /* 获取会话，使用了OCILogon2()函数 */
    rc = OCILogon2(envhp, errhp1, &svchp1,
        (const OraText *)inputs.uname, (ub4)strlen(inputs.uname),
        (const OraText *)inputs.upwd,  (ub4)strlen(inputs.upwd),
        (const OraText *)pool_name,    (ub4)pool_name_len,
        OCI_CPOOL
    );

    if (rc != OCI_SUCCESS) {
        OCIErrorGet(errhp1, 1, NULL, &ec, errbuf, 512, OCI_HTYPE_ERROR);
        fprintf(stderr, "OCILogon2() - [%d] %s\n", ec, errbuf);
        goto thread_error;
    }

    /* 分配语句句柄 */
    rc = OCIHandleAlloc(
        (void *)envhp,
        (void **)&stmthp,
        OCI_HTYPE_STMT,
        0,
        (void **)NULL
    );

    if (rc != OCI_SUCCESS) {
        fprintf(stderr, "OCIHandleAlloc() - allocate statement handle error !\n");
        goto thread_error;
    }

    /* 得到线程传入的参数 */
    num = *((int *)arg);

    /* 使用会话从dual中获取这个数字 */
    sprintf(sqltxt, "select %d from dual", num);
    slen = strlen(sqltxt);

    /* 准备语句 */
    rc = OCIStmtPrepare(stmthp, errhp1, (const OraText *)sqltxt, slen,
          OCI_NTV_SYNTAX, OCI_DEFAULT);

    if (rc != OCI_SUCCESS) {
        OCIErrorGet(errhp1, 1, NULL, &ec, errbuf, 512, OCI_HTYPE_ERROR);
        fprintf(stderr, "OCIStmtPrepare() - [%d] %s\n", ec, errbuf);
        goto thread_error;
    }

    /* 定义输出变量 */
    rc = OCIDefineByPos(stmthp,
        &defp,
        errhp1,
        (ub4)1,
        (void *)&u4,
        (sb4)4,
        (ub2)SQLT_INT,
        (void *)NULL,
        (ub2 *)NULL,
        (ub2 *)NULL,
        (ub4)OCI_DEFAULT
    );

    if (rc != OCI_SUCCESS) {
        OCIErrorGet(errhp1, 1, NULL, &ec, errbuf, 512, OCI_HTYPE_ERROR);
        fprintf(stderr, "OCIDefineByPos() - [%d] %s\n", ec, errbuf);
        goto thread_error;
    }

    /* 执行查询语句 */
    rc = OCIStmtExecute(svchp1, stmthp, errhp1, 0, 0, NULL, NULL, OCI_DEFAULT);

    if (rc != OCI_SUCCESS) {
        OCIErrorGet(errhp1, 1, NULL, &ec, errbuf, 512, OCI_HTYPE_ERROR);
        fprintf(stderr, "OCIStmtExecute() - [%d] %s\n", ec, errbuf);
        goto thread_error;
    }

    /* 获取结果集 */
    rc = OCIStmtFetch2(stmthp, errhp1, 1, OCI_FETCH_NEXT, 0, OCI_DEFAULT);

    if (rc != OCI_SUCCESS) {
        OCIErrorGet(errhp1, 1, NULL, &ec, errbuf, 512, OCI_HTYPE_ERROR);
        fprintf(stderr, "OCIStmtFetch2() - [%d] %s\n", ec, errbuf);
        goto thread_error;
    }

    /* 打印取到的数字 */
    fprintf(stdout, "number from dual is: %d\n", u4);

    /* 释放语句句柄 */
    rc = OCIHandleFree(
        stmthp,
        OCI_HTYPE_STMT
    );

    if (rc != OCI_SUCCESS) {
        fprintf(stderr, "OCIHandleFree() - free statement handle error !\n");
        goto thread_error;
    }

    stmthp = NULL;

    /* 退出会话 */
    rc = OCILogoff(svchp1, errhp1);

    if (rc != OCI_SUCCESS) {
        OCIErrorGet(errhp1, 1, NULL, &ec, errbuf, 512, OCI_HTYPE_ERROR);
        fprintf(stderr, "OCILogoff() - [%d] %s\n", ec, errbuf);
        goto thread_error;
    }

    svchp1 = NULL;

    /* 释放错误句柄 */
    rc = OCIHandleFree(
        errhp1,
        OCI_HTYPE_ERROR
    );

    if (rc != OCI_SUCCESS) {
        fprintf(stderr, "OCIHandleFree() - free error handle error !\n");
    }

    errhp1 = NULL;

    return;

thread_error:
    if (stmthp != NULL) {
        OCIHandleFree(stmthp, OCI_HTYPE_STMT);
    }

    if (svchp1 != NULL) {
        OCILogoff(svchp1, errhp1);
    }

    if (errhp1 != NULL) {
        OCIHandleFree(errhp1, OCI_HTYPE_ERROR);
    }
}

/* 定义线程的最大个数，和传入线程的数字数组 */
#define MAX_THREAD      4
int     t_num[MAX_THREAD];

int main(int argc, char **argv)
{
    int                 i;
    sword               rc;
    sb4                 ec;
    OCIThreadId         *tid[MAX_THREAD];
    OCIThreadHandle     *thp[MAX_THREAD];
    OraText             errbuf[512];


    /* 解析命令行参数 */
    if (parse_inputs(argc, argv) < 0)
        return (-1);

    /* 检查OCI程序运行的环境变量 */
    if (check_ora_env() < 0)
        return (-1);

    /* 创建连接池 */
    if (create_connection_pool() < 0)
        goto error_exit;

    /* 初始化OCI线程包 */
    OCIThreadProcessInit();

    /* 初始化线程包上下文 */
    rc = OCIThreadInit(envhp, errhp);

    if (rc != OCI_SUCCESS) {
        OCIErrorGet(errhp, 1, NULL, &ec, errbuf, 512, OCI_HTYPE_ERROR);
        fprintf(stderr, "OCIThreadInit() - [%d] %s\n", ec, errbuf);
    }

    /* 初始化每个线程的ID和句柄 */
    for (i=0; i<MAX_THREAD; i++) {
        rc = OCIThreadIdInit(envhp, errhp, &tid[i]);
        if (rc != OCI_SUCCESS) {
            OCIErrorGet(errhp, 1, NULL, &ec, errbuf, 512, OCI_HTYPE_ERROR);
            fprintf(stderr, "OCIThreadIdInit() - [%d] %s\n", ec, errbuf);
        }

        rc = OCIThreadHndInit(envhp, errhp, &thp[i]);
        if (rc != OCI_SUCCESS) {
            OCIErrorGet(errhp, 1, NULL, &ec, errbuf, 512, OCI_HTYPE_ERROR);
            fprintf(stderr, "OCIThreadHndInit() - [%d] %s\n", ec, errbuf);
        }
    }

    /* 创建和启动每个线程，传入参数 */
    for (i=0; i<MAX_THREAD; i++) {
        t_num[i] = i+1;

        rc = OCIThreadCreate(envhp, errhp, thread_run,
            (void *)&t_num[i], tid[i], thp[i]);
        if (rc != OCI_SUCCESS) {
            OCIErrorGet(errhp, 1, NULL, &ec, errbuf, 512, OCI_HTYPE_ERROR);
            fprintf(stderr, "OCIThreadCreate() - [%d] %s\n", ec, errbuf);
        }
    }

    for (i=0; i<MAX_THREAD; i++) {
        /* 等待线程结束 */
        rc = OCIThreadJoin(envhp, errhp, thp[i]);
        if (rc != OCI_SUCCESS) {
            OCIErrorGet(errhp, 1, NULL, &ec, errbuf, 512, OCI_HTYPE_ERROR);
            fprintf(stderr, "OCIThreadJoin() - [%d] %s\n", ec, errbuf);
        }

        /* 关闭线程句柄 */
        rc = OCIThreadClose(envhp, errhp, thp[i]);
        if (rc != OCI_SUCCESS) {
            OCIErrorGet(errhp, 1, NULL, &ec, errbuf, 512, OCI_HTYPE_ERROR);
            fprintf(stderr, "OCIThreadClose() - [%d] %s\n", ec, errbuf);
        }

        /* 销毁线程ID */
        rc = OCIThreadIdDestroy(envhp, errhp, &tid[i]);
        if (rc != OCI_SUCCESS) {
            OCIErrorGet(errhp, 1, NULL, &ec, errbuf, 512, OCI_HTYPE_ERROR);
            fprintf(stderr, "OCIThreadIdDestroy() - [%d] %s\n", ec, errbuf);
        }

        /* 销毁线程句柄 */
        rc = OCIThreadHndDestroy(envhp, errhp, &thp[i]);
        if (rc != OCI_SUCCESS) {
            OCIErrorGet(errhp, 1, NULL, &ec, errbuf, 512, OCI_HTYPE_ERROR);
            fprintf(stderr, "OCIThreadHndDestroy() - [%d] %s\n", ec, errbuf);
        }
    }

    /* 结束线程包 */
    rc = OCIThreadTerm(envhp, errhp);

    if (rc != OCI_SUCCESS) {
        OCIErrorGet(errhp, 1, NULL, &ec, errbuf, 512, OCI_HTYPE_ERROR);
        fprintf(stderr, "OCIThreadTerm() - [%d] %s\n", ec, errbuf);
    }

    /* 销毁连接池 */
    destroy_connection_pool();

    return (0);

error_exit:
    destroy_connection_pool();
    return (-1);
}

tomcoding
关注
OCI编程高级篇（二十一） OCI的线程支持和函数原型
tomcoding的博客
09-05 788
介绍了OCI中使用线程的步骤，线程函数的原型和参数。
Oci 多线程操作接口封装demo
07-09
用C++封装的Oci操作接口，使用了数据库连接池，可以在多线程中并发操作数据。
ocilib多线程支持
weixin_30877493的博客
02-12 280
服务端程序中使用多线程调用ocilib，出现程序运行不稳定情况； 解决：将OCIlib的初始化函数OCI_Initialize(NULL, NULL,OCI_ENV_DEFAULT）第三个参数进行修改成支持多线程OCI_Initialize(NULL, NULL,OCI_ENV_THREADED)。 转载于:https://www.cnblogs.com/kiss-passion/p/10364...
ocilib不是多线程安全的！每个线程都要有一个connection实体
liutan731的专栏
02-09 1460
这两天用ocilib开发程序，发现ocilib并不是多线程安全的。所以如果要在多个线程中访问数据库，请一定单独new一个oci的访问对象！ 代码我就不写了，反正原则就是，多个线程不能同时访问同一个ocilib的connect实体！否则执行OCI_ExecuteStmt会返回false!!!! 欢迎讨论： 521-lion@163.com
怎样使用OCI编写多线程的ORACLE应用软件
eboyhaining的专栏
07-02 1273
多线程的应用程序可充分利用计算机资源，能有效提高应用程序的运行效率。本文通过实例叙述了使用ORACLE  OCI 编写多线程的应用程序的方法和多线程应用程序的运行机制。 关键字： OCI  线程  互斥  应用程序 将一个较为复杂的应用软件按功能划分为若干执行不同操作的模块，再利用多线程机制使它们同时运行在多处理机或单处理机系统上，就能提高软件的运行效率。本文讨论多线程的实用性，并通过实例（
C++封装Oci接口实现多线程数据库并发操作示例
在本文中，我们将详细探讨关于标题“Oci 多线程操作接口封装demo”中提及的知识点，同时结合描述以及提供的标签“Oci C++ Oracle”和压缩包子文件的文件名称列表，来深入理解该demo涉及的技术细节和应用场景。...
Oracle OCI API封装类库及示例代码
因此，作者参考了网络上的开源或示例代码，整理并封装出一套名为“OciClasses”的C++类库，旨在为使用VC5或VC6（即Visual C++ 5.0 和 6.0）开发环境的程序员提供一个简洁、易用的数据库访问框架。这类封装通常包括...
Oracle OCI编程入门与环境初始化
OCI包含多种功能，如支持多线程、SQL访问函数、数据类型映射和操作、以及数据加载功能。它通过不透明的句柄接口提供服务，这些句柄存储了与特定任务相关的上下文信息。 3. **封装的接口** 句柄是OCI中的核心概念...
VC下OCI编程：Oracle数据库连接与配置步骤详解
接下来，是创建一个简单的示例程序来展示如何使用OCI编程。这个程序主要包括以下几个步骤： - 定义处理环境相关的指针，如环境句柄(myenvhp)、服务句柄(mysrvhp)、错误句柄(myerrhp)和用户句柄(myusrhp)。 - 使用`...
基于PBNI封装OCI实现PowerBuilder句柄传递与多线程优化
该技术结合了PBNI（PowerBuilder Native Interface）、OCI（Oracle Call Interface）以及多线程编程、数据库连接池管理等多个关键技术点，旨在解决传统PowerBuilder在高并发、数据库密集型应用场景下的性能瓶颈问题...
OCI调用接口文档
10-10
实现数据库读写，地理信息空间数据库实现的必要接口。
Orcale中OCILogon和OCIServerAttach登录方式的区别分析
Bussy的博客
04-26 1261
几乎每个OCI调用的参数列表中都会包含一个或多个句柄。一个句柄就是一个指向由OCI库分配的存储空间的不透明指针。应用可以使用句柄存储上下文或连接信息，例如环境或服务上下文句柄，也可以存储OCI函数或数据的信息，例如错误或describe句柄。句柄让编程变得简单，因为是使用库来维护数据而非应用来维护数据。大多数OCI应用必须要获取存储在句柄中的信息，所以设计通过set和get属性的OCI调用，OCIAttrGet()和OCIAttrSet()来访问或设置这些信息。
Oracle官方OCI(Oracle Call Interface)文档翻译
12-09 9871
Oracle官方OCI(Oracle Call Interface)文档翻译                       -----Oracle8i开始的句柄方式的OCI OCI学习资料 --Oracle8及以后版本的OCI 1.     简介 Oracle调用接口(Oracle Call Interface)是一个让我们通过函数调用来访问Oracle数据库和 控制SQL语句执行各个
OCI文档、C++实现例子
热门推荐
骑猪喝咖啡
07-08 1万+
一、OCI是什么 ？OCI是一组底层的API(应用程序接口)，主要和Oracle数据库进行交互。你可以调用一些操作如 logon , execute, parse, fecth 等等。OCI支持大数据语言，通常使用C/C++。与Oracle Pro*C等不同，OCI不需要预编译。 OCI比Pro*C的一些优势：    OCI的性能十分出色  代码大量缩减  对内置函数直接访问  对LONG
OCI 简介
changyanmanman的专栏
10-09 5446
文章整理自网络： oci - 简介        OCI（Oracle Call Interface）是ORACLE公司开发的一个应用程序开发工具，是一个通过访问Oracle数据库的服务器，控制各类SQL语句的执行，进而创建应用程序的的应用程序接口（API）。它支持SQL所有的数据定义，数据操作，查询，事务管理等操作，支持C和C++的数据类型，调用，语法和语义。它提供了一组可对Or
Oracle OCI ：OCI说明
忘忧草
05-27 1627
Oracle oci工具包安装：     $ORACLE_HOME\BIN:执行文件和help文件     $ORACLE_HOME\OCI\INCLUDE:头文件     $ORACLE_HOME\OCI\LIB\BC:  for Borlanf C++的OCI库     $ORACLE_HOME\OCI\LIB\MSVC:  for MS Visual C++的OCI库 如
oic oracle程序测试,linux下用C编写的OCI连接Oracle数据库程序代码 | 学步园
weixin_39987985的博客
04-13 193
在Oracle建立数据库create table employees(employee_id number(3), name varchar2(20), sex varchar2(5), birthday date);alter session set nls_date_format = 'yyyy-mm-dd';insert into employees values('101', '耳温枪 ...
linux多线程服务器，用oci API连接Oracle数据库
seven407的专栏
11-28 1660
这就是我两个星期的成果server.c:#include #include #include #include #include #include #include #include #include #include #include #include #define S_PORT 1234#define LOG_NUM 10#define MAXDATASIZE 4096st
C、C++面试题目的总结
never give up的博客
06-02 1239
1.求下面函数的返回值（微软） int func(x)  {     int countx = 0;     while(x)     {           countx ++;           x = x&(x-1);      }     return countx;  }  假定x = 9999。答案：8 思路：将x转化为2进制，看含有的1的个数。 2.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值