APUE函数笔记九: 线程

最新推荐文章于 2023-06-29 18:25:02 发布
最新推荐文章于 2023-06-29 18:25:02 发布
阅读量529 收藏
点赞数
分类专栏： c unix 笔记 文章标签： struct thread fp null reference initialization
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cxxmaker/article/details/7409505
版权
笔记 同时被 3 个专栏收录
82 篇文章 0 订阅
订阅专栏
c
58 篇文章 0 订阅
订阅专栏
unix
49 篇文章 0 订阅
订阅专栏

第十一章  线程:

#include <pthread.h>
int pthread_equal(pthread_t tid1, pthread_t tid2);
    if equal return non-zero, else return 0

#include <pthread.h>
pthread_t pthread_self(void);

#include <pthread.h>
int pthread_create(pthread_t * restrict tidp, 
                   const pthread_attr_t * restrict attr, 
                   void * (*start_rtn)(void *), void * restrict arg);
    if success return 0, else return error-no, will not modify errno

#include <pthread.h>
void pthread_exit(void * rval_ptr);

#include <pthread.h>
int pthread_join(pthread_t thread, void ** rval_ptr);
    if success return 0, else return error-no, will not modify errno

#include <pthread.h>
int pthread_cancel(pthread_t tid);
    not wait, just tell the request
    if success return 0, else return error-no, will not modify errno

#include <pthread.h>
void pthread_cleanup_push(void (*rtn)(void *), void * arg);
void pthread_cleanup_pop(int execute);
     only when thread exit by pthread_exit/pthread_cancel 
     or pthread_cleanup_pop(non-zero), will call rtn
     pthread_cleanup_pop(0) will unregist the last rtn, but not call it

compare:
        process     thread
        fork()      pthread_create()
        exit()      pthread_exit()
        waitpid()   pthread_join()
        atexit()    pthread_cleanup_push()
        getpid()    pthread_self()
        abort()     pthread_cancel()

#include <pthread.h>
int pthread_detach(pthread_t tid);
    if success return 0, else return error-no, will not modify errno

#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t * restrict mutex, 
                       const pthread_mutexattr_t * restrict attr);
    if success return 0, else return error-no, will not modify errno
int pthread_mutex_destroy(pthread_mutex_t * mutex);
    if success return 0, else return error-no, will not modify errno

PTHREAD_MUTEX_INITIALIZER

a mutex/rwlock cannot be lock 2 times in one thread

#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t * mutex);
    if success return 0, else return error-no, will not modify errno
int pthread_mutex_trylock(pthread_mutex_t * mutex);
    if success return 0, else return error-no, will not modify errno
int pthread_mutex_unlock(pthread_mutex_t * mutex);
    if success return 0, else return error-no, will not modify errno

lock mutexs need same order, unlock need not

#include <pthread.h>
int pthread_rwlock_init(pthread_rwlock_t * restrict rwlock, 
                        const pthread_rwlockattr_t * restrict attr);
    if success return 0, else return error-no, will not modify errno
int pthread_rwlock_destroy(pthread_rwlock_t * rwlock);
    if success return 0, else return error-no, will not modify errno

#include <pthread.h>
int pthread_rwlock_rdlock(pthread_rwlock_t * rwlock);
    if success return 0, else return error-no, will not modify errno
int pthread_rwlock_wrlock(pthread_rwlock_t * rwlock);
    if success return 0, else return error-no, will not modify errno
int pthread_rwlock_unlock(pthread_rwlock_t * rwlock);
    if success return 0, else return error-no, will not modify errno

#include <pthread.h>
int pthread_rwlock_tryrdlock(pthread_rwlock_t * rwlock);
    if success return 0, else return error-no, will not modify errno
int pthread_rwlock_trywrlock(pthread_rwlock_t * rwlock);
    if success return 0, else return error-no, will not modify errno

#include <pthread.h>
int pthread_cond_init(pthread_cond_t * restrict cond, 
                      pthread_condattr_t * restrict attr);
    if success return 0, else return error-no, will not modify errno
int pthread_cond_destroy(pthread_cond_t * cond);
    if success return 0, else return error-no, will not modify errno

PTHREAD_COND_INITIALIZER

#include <pthread.h>
int pthread_cond_wait(pthread_cond_t * restrict cond, 
                      pthread_mutex_t * restrict mutex);
    if success return 0, else return error-no, will not modify errno
int pthread_cond_timedwait(pthread_cond_t * restrict cond, 
                           pthread_mutex_t * restrict mutex, 
                           const struct timespec * restrict timeout);
    if success return 0, else return error-no, will not modify errno
    struct timespec {
        time_t    tv_sec;  /* seconds */
        long      tv_nsec; /* nanosecods */
    };

#include <pthread.h>
int pthread_cond_signal(pthread_cond_t * cond);
    if success return 0, else return error-no, will not modify errno
int pthread_cond_broadcast(pthread_cond_t * cond);
    if success return 0, else return error-no, will not modify errno

示例: 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>

void 
printids(const char * s)
{
    pid_t       pid;
    pthread_t   tid;

    pid = getpid();
    tid = pthread_self();
    printf("%s pid %u tid %u (0x%x)\n", s, (unsigned int)pid, 
           (unsigned int)tid, (unsigned int)tid);
}

void * 
thr_fn(void * arg)
{
    printids("new thread: ");
    return ((void *)0);
}

int 
main(void)
{
    int          err;
    pthread_t    ntid;

    err = pthread_create(&ntid, NULL, thr_fn, NULL);
    if (err != 0) {
        printf("cannot create thread: %s\n", strerror(err));
        exit(1);
    }
    printids("main thread: ");
    sleep(1);
    exit(0);
}


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>

void * 
thr_fn1(void * arg)
{
    printf("thread 1 returning\n");
    return ((void *)1);
}

void * 
thr_fn2(void * arg)
{
    printf("thread 2 exiting\n");
    return ((void *)2);
}

int 
main(void)
{
    int         err;
    pthread_t   tid1;
    pthread_t   tid2;
    void      * tret;

    if ((err = pthread_create(&tid1, NULL, thr_fn1, NULL)) != 0) {
        printf("cannot create thread 1: %s\n", strerror(err));
        exit(1);
    }
    if ((err = pthread_create(&tid2, NULL, thr_fn2, NULL)) != 0) {
        printf("cannot create thread 2: %s\n", strerror(err));
        exit(1);
    }
    if ((err = pthread_join(tid1, &tret)) != 0) {
        printf("cannot join with thread 1: %s\n", strerror(err));
        exit(1);
    }
    printf("thread 1 exit code %d\n", (int)tret);
    if ((err = pthread_join(tid2, &tret)) != 0) {
        printf("cannot join with thread 2: %s\n", strerror(err));
        exit(1);
    }
    printf("thread 2 exit code %d\n", (int)tret);
    exit(0);
}


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>

void 
cleanup(void * arg)
{
    printf("cleanup %s\n", (char *)arg);
}

/*
 * pop and push implement to be macros
 * pop-count must equit to push-count in a func-block
 * otherwise, error in complile
 */
void * 
thr_fn(void * arg)
{
    int   idx = (int)arg;
    char  buff1[64];
    char  buff2[64]; /* need two buffer! */

    printf("thread %d start\n", idx);
    sprintf(buff1, "thread %d first handler", idx);
    pthread_cleanup_push(cleanup, buff1);
    sprintf(buff2, "thread %d second handler", idx);
    pthread_cleanup_push(cleanup, buff2);
    printf("thread %d push complete\n", idx);
    if (idx == 1) {
        return (arg);
    }
    if (idx == 2) {
        pthread_exit(arg);
    }
    pthread_cleanup_pop(0);
    if (idx == 3) {
        return (arg);
    }
    if (idx == 4) {
        pthread_exit(arg);
    }
    pthread_cleanup_pop(0);
    if (idx == 5) {
        return (arg);
    }
    if (idx == 6) {
        pthread_exit(arg);
    }

    abort();
}

int 
main(void)
{
    int       i;
    int       err;
    pthread_t tid[6];
    void    * tret;

    for (i = 0; i < 6; ++i) {
        if ((err = pthread_create(&tid[i], NULL, thr_fn, (void *)(i + 1))) != 0) {
            printf("cannot create thread %d: %s\n", i + 1, strerror(err));
            exit(1);
        }
    }

    for (i = 0; i < 6; ++i) {
        if ((err = pthread_join(tid[i], &tret)) != 0) {
            printf("cannot join with thread %d: %s\n", i +1, strerror(err));
            exit(1);
        }
    }

    exit(0);
}


#include <stdlib.h>
#include <pthread.h>

struct foo {
    int              f_count;
    pthread_mutex_t  f_lock;
    /* ... more stuff here ... */
};

struct foo * 
foo_alloc(void) /* allocate the object */
{
    struct foo * fp;

    if ((fp = (struct foo *)malloc(sizeof(struct foo))) != NULL) {
        fp->f_count = 1;
        if (pthread_mutex_init(&fp->f_lock, NULL) != 0) {
            free(fp);
            return(NULL);
        }
        /* ... continue initialization ... */
    }
    return(fp);
}

void foo_hold(struct foo * fp) /* add a reference to the object */
{
    pthread_mutex_lock(&fp->f_lock);
    ++fp->f_count;
    pthread_mutex_unlock(&fp->f_lock);
}

void 
foo_rele(struct foo * fp) /* release a reference to the object */
{
    pthread_mutex_lock(&fp->f_lock);
    if (--fp->f_count == 0) { /* last reference */
        pthread_mutex_unlock(&fp->f_lock);
        /* if foo_hold here, what can we do?*/
        pthread_mutex_destroy(&fp->f_lock);
        free(fp);
    }
    else {
        pthread_mutex_unlock(&fp->f_lock);
    }
}


#include <stdlib.h>
#include <pthread.h>

#define NHASH 29
#define HASH(fp) (((unsigned int)fp) % NHASH)

struct foo {
    int               f_count;
    pthread_mutex_t   f_lock;
    struct foo      * f_next; /* protected by hashlock */
    int               f_id;
    /* ... more stuff here ... */
};

struct foo * fh[NHASH];
pthread_mutex_t hashlock = PTHREAD_MUTEX_INITIALIZER;

struct foo * 
foo_alloc(void) /* allocate the object */
{
    struct foo * fp;
    int          idx;

    if ((fp = (struct foo *)malloc(sizeof(struct foo))) != NULL) {
        fp->f_count = 1;
        if (pthread_mutex_init(&fp->f_lock, NULL) != 0) {
            free(fp);
            return(NULL);
        }
        /* continue initialization */
        idx = HASH(fp);
        pthread_mutex_lock(&hashlock);
        fp->f_next = fh[idx];
        fh[idx] = fp;
        pthread_mutex_unlock(&hashlock);
    }
    return(fp);
}

void 
foo_hold(struct foo * fp) /* add a reference to the object */
{
    pthread_mutex_lock(&fp->f_lock);
    ++fp->f_count;
    pthread_mutex_unlock(&fp->f_lock);
}

struct foo * 
foo_find(int id) /* find an existing object */
{
    struct foo * fp;
    int          idx;

    pthread_mutex_lock(&hashlock);
    for (idx = 0; idx < NHASH; ++idx) {
        for (fp = fh[idx]; fp != NULL; fp = fp->f_next) {
            if (fp->f_id == id) {
                foo_hold(fp);
                break;
            }
        }
        if (fp != NULL) {
            break;
        }
    }
    pthread_mutex_unlock(&hashlock);
    return(fp);
}

void 
foo_rele(struct foo * fp) /* release a reference to the object */
{
    struct foo * tfp;
    int          idx;

    pthread_mutex_lock(&fp->f_lock);
    if (fp->f_count == 1) { /* last reference */
        pthread_mutex_unlock(&fp->f_lock);
        pthread_mutex_lock(&hashlock);
        pthread_mutex_lock(&fp->f_lock);
        /* need to recheck the condition */
        if (--fp->f_count == 0) {
            /* remove from list */
            idx = HASH(fp);
            tfp = fh[idx];
            if (tfp == fp) {
                fh[idx] = fp->f_next;
            }
            else {
                while (tfp->f_next != fp) {
                    tfp = tfp->f_next;
                }
                tfp->f_next = fp->f_next;
            }
            pthread_mutex_unlock(&hashlock);
            pthread_mutex_unlock(&fp->f_lock);
            pthread_mutex_destroy(&fp->f_lock);
            free(fp);
        }
        else {
            pthread_mutex_unlock(&hashlock);
            pthread_mutex_unlock(&fp->f_lock);
        }
    }
    else {
        --fp->f_count;
        pthread_mutex_unlock(&fp->f_lock);
    }
}


#include <stdlib.h>
#include <pthread.h>

#define NHASH 29
#define HASH(fp) (((unsigned int)fp) % NHASH)

struct foo {
    int               f_count; /* protected by hashlock */
    pthread_mutex_t   f_lock;
    struct foo      * f_next; /* protected by hashlock */
    int               f_id;
    /* ... more stuff here ... */
};

struct foo * fh[NHASH];
pthread_mutex_t hashlock = PTHREAD_MUTEX_INITIALIZER;

struct foo * 
foo_alloc(void) /* allocate the object */
{
    struct foo * fp;
    int          idx;

    if ((fp = (struct foo *)malloc(sizeof(struct foo))) != NULL) {
        fp->f_count = 1;
        if (pthread_mutex_init(&fp->f_lock, NULL) != 0) {
            free(fp);
            return(NULL);
        }
        /* continue initialization */
        idx = HASH(fp);
        pthread_mutex_lock(&hashlock);
        fp->f_next = fh[idx];
        fh[idx] = fp;
        pthread_mutex_unlock(&hashlock);
    }
    return(fp);
}

void 
foo_hold(struct foo * fp) /* add a reference to the object */
{
    pthread_mutex_lock(&hashlock);
    ++fp->f_count;
    pthread_mutex_unlock(&hashlock);
}

struct foo * 
foo_find(int id) /* find an existing object */
{
    struct foo * fp;
    int          idx;

    pthread_mutex_lock(&hashlock);
    for (idx = 0; idx < NHASH; ++idx) {
        for (fp = fh[idx]; fp != NULL; fp = fp->f_next) {
            if (fp->f_id == id) {
                /* do not use foo_hold, will deathlock */
                ++fp->f_count;
                break;
            }
        }
        if (fp != NULL) {
            break;
        }
    }
    pthread_mutex_unlock(&hashlock);
    return(fp);
}

void 
foo_rele(struct foo * fp) /* release a reference to the object */
{
    struct foo * tfp;
    int          idx;

    pthread_mutex_lock(&hashlock);
    if (--fp->f_count == 0) { /* last reference */
        /* remove from list */
        idx = HASH(fp);
        tfp = fh[idx];
        if (tfp == fp) {
            fh[idx] = fp->f_next;
        }
        else {
            while (tfp->f_next != fp) {
                tfp = tfp->f_next;
            }
            tfp->f_next = fp->f_next;
        }
        pthread_mutex_unlock(&hashlock);
        pthread_mutex_destroy(&fp->f_lock);
        free(fp);
    }
    else {
        pthread_mutex_unlock(&hashlock);
    }
}


#include <stdlib.h>
#include <pthread.h>

struct job {
    struct job * j_prev;
    struct job * j_next;
    int          j_id; /* tells which thread handles this job */
    /* ... more stuff here ... */
};

struct queue {
    struct job *     q_head;
    struct job *     q_tail;
    pthread_rwlock_t q_lock;
};

/*
 * initialize a queue
 */
int 
queue_init(struct queue * qp)
{
    int err;

    if ((err = pthread_rwlock_init(&qp->q_lock, NULL)) != 0) {
        return(err);
    }
    qp->q_head = NULL;
    qp->q_tail = NULL;
    /* ... continue initialization ... */

    return(0);
}

/*
 * insert a job at the head of the queue
 */
void 
job_insert(struct queue * qp, struct job * jp)
{
    pthread_rwlock_wrlock(&qp->q_lock);
    jp->j_prev = NULL;
    jp->j_next = qp->q_head;
    if (qp->q_head != NULL) {
        qp->q_head->j_prev = jp;
    }
    else {
        qp->q_tail = jp;
    }
    qp->q_head = jp;
    pthread_rwlock_unlock(&qp->q_lock);
}

/*
 * append a job on the tail of the queue
 */
void 
job_append(struct queue * qp, struct job * jp)
{
    pthread_rwlock_wrlock(&qp->q_lock);
    jp->j_next = NULL;
    jp->j_prev = qp->q_tail;
    if (qp->q_tail != NULL) {
        qp->q_tail->j_next = jp;
    }
    else {
        qp->q_head = jp;
    }
    qp->q_tail = jp;
    pthread_rwlock_unlock(&qp->q_lock);
}

/*
 * remove the given job from a queue
 */
void 
job_remove(struct queue * qp, struct job * jp)
{
    pthread_rwlock_wrlock(&qp->q_lock);
    if (qp->q_head == jp) {
        if (qp->q_tail == jp) {
            qp->q_tail = NULL;
        }
        else {
            jp->j_next->j_prev = NULL;
        }
        qp->q_head = jp->j_next;
    }
    else if (qp->q_tail == jp) {
        jp->j_prev->j_next = NULL;
        qp->q_tail = jp->j_prev;
    }
    else {
        jp->j_prev->j_next = jp->j_next;
        jp->j_next->j_prev = jp->j_prev;
    }
    pthread_rwlock_unlock(&qp->q_lock);
}

/*
 * find a job for the given thread ID
 */
struct job * 
job_find(struct queue * qp, pthread_t id)
{
    struct job * jp;

    /* read lock must check */
    if (pthread_rwlock_rdlock(&qp->q_lock) != 0) {
        return(NULL);
    }

    for (jp = qp->q_head; jp != NULL; jp = jp->j_next) {
        if (pthread_equal(jp->j_id, id) != 0) {
            break;
        }
    }
    pthread_rwlock_unlock(&qp->q_lock);

    return(jp);
}


#include <pthread.h>

struct msg {
    struct msg * m_next;
    /* ... more stuff here ... */
};

struct msg * workq;
pthread_cond_t qready = PTHREAD_COND_INITIALIZER;
pthread_mutex_t qlock = PTHREAD_MUTEX_INITIALIZER;

void 
process_msg(void)
{
    struct msg * mp;

    while (1) {
        pthread_mutex_lock(&qlock);
        while (workq == NULL) {
            pthread_cond_wait(&qready, &qlock);
        }
        mp = workq;
        workq = workq->m_next;
        pthread_mutex_unlock(&qlock);
        /* now process the message mp */
    }
}

void 
enqueue(struct msg * mp)
{
    pthread_mutex_lock(&qlock);
    mp->m_next = workq;
    workq = mp;
    pthread_mutex_unlock(&qlock); /* step 1 */
    pthread_cond_signal(&qready); /* step 2 */
    /*
     * we can switch step 1 and step 2, 
     * they are all right, 
     * but they have diffect effective
     */
}


#include <sys/time.h>
#include <pthread.h>

void 
maketimeout(struct timespec * tsp, long minutes)
{
    struct timeval now;

    /* get the current time */
    gettimeofday(&now, NULL);
    tsp->tv_sec = now.tv_sec;
    tsp->tv_nsec = now.tv_usec * 1000; /* usec to nsec */
    /* add the offset to get timeout value */
    tsp->tv_sec += minutes * 60;
}


ken_scott
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
apue 学习笔记——线程
sdutkqb的专栏
06-09 513
线程的创建
apue 函数原型 ---线程
qq_24395625的博客
06-05 203
#include 1.int pthread_equal(pthread_t tid1,pthread_t tid2);比较两个线程ID，若相等返回非0数值，否则返回0 2.pthread_t pthread_self();返回调用线程ID 3.int pthread_create(pthread_t *restrict tid,const pthread_attr_t *r
APUE函数笔记十: 线程控制
二斗墨汁
03-31 564
第十二章  线程控制: #include int pthread_attr_init(pthread_attr_t * attr); if success return 0, else return error-no, will not modify errno int pthread_attr_destroy(pthread_attr_t * attr); if succes
APUE学习笔记之：进程终止的几种方式
开心就好的专栏
10-06 529
环境 $ cat /etc/os-release PRETTY_NAME="Deepin 20" NAME="Deepin" VERSION_ID="20" VERSION="20" ID=Deepin HOME_URL="https://www.deepin.org/" BUG_REPORT_URL="https://bbs.deepin.org/" 进程终止的方式共8种 5种正常终止，3种异常终止： 其中： 正常终止： 从main()函数返回 调用exit()函数 调用_exit()或者_Exit
APUE学习笔记（十一）线程
chinamen1的博客
06-19 140
11. 1 线程概念 进程可以有多个控制线程，每个线程处理各自独立的任务。一个进程的所有信息对该进程的所有线程都是共享的，包括可执行程序的代码、程序的全局内存和堆内存、栈以及文件描述符。 1. 多个进程必须使用操作系统提供的复杂机制才能实现内存和文件描述符的共享，而多个线程共享相同的存储地址空间和文件描述符。 2. 通过为每种事件类型分配单独的处理线程，可以简化处理异步事件的代码。 3. 有些问题可以分解使用多线程从而提高整个程序的吞吐量。 4. 交互的程序可以通过使用多线程来改善响应时间。 11.2 线
APUE学习笔记——11 线程基础
L24986721的博客
09-04 105
线程标识 线程由线程号进行标识。线程号仅在线程所属的进程环境中有效。也就是说属于不同进程的两个线程可能线程号一样。 线程标识用结构体pthread_t tid表示。与线程Id相关的函数如下： 比较两个线程ID： #include <pthread.h> int pthread_equal(pthread_t tid1,pthread_t...
APUE读书笔记（九）线程及线程同步
缇珞的博客
04-13 234
文章目录1 线程标识1.1 线程ID的比较函数pthread_equal1.2 线程获得自身的线程ID函数pthread_self2 线程的基本操作函数2.1 线程创建函数pthread_create2.2 等待线程结束函数pthread_join2.3 线程终止函数pthread_exit2.4 实例3 线程同步3.1 互斥量3.1.1 互斥量的各种函数原型3.1.2 实例3.2 读写锁3.2....
APUE读书笔记(18)线程
myz123321的博客
09-09 125
第十一章 线程 一：主要内容：   线程可以在单进程环境中执行多个任务，并且一个进程中的所有线程都可以访问该进程的组成部件，比如内存和文件描述符。多线程使得单个资源会被多个用户共享，所以同步机制在多线程中是至关重要的。 二：线程概念   典型的UNIX进程可以看成只有一个控制线程：一个进程在同一时间只能做一件事情。一个进程对应多个线程有以下好处：   1.通过对每种事件分配一个单独的处理线程，可以...
Pthread线程同步总结——APUE学习笔记
最新发布
Programmerist的专栏
06-29 180
扩展一下，如果本来不止AB两个线程在阻塞，而是多个线程在阻塞，那么因为使用if，所有的线程可能都被唤醒，接着不管条件x是否满足，全都往下执行，则发生了“惊群效应”。首次判断时x==1，此时进入if块内，执行wait函数，当前线程阻塞。以上，不管是为了防止虚假唤醒或是惊群效应，本质都是由于线程被唤醒是一回事、条件满足是另一回事，被唤醒不代表条件一定被满足，因此唤醒后需要再检查一遍条件，只有使用while才能在循环中再判断一次，而if不能，所以pthread_cond_wait函数常与while搭配使用。
APUE笔记之:进程环境详解
09-05
在深入探讨APUE中的进程环境之前，我们先理解一下什么是进程。进程是操作系统中的一个基本概念，它代表了程序在内存中的执行实例。每个进程都有自己的独立内存空间，包括正文段、堆、栈以及进程环境。 正文段包含了...
Linux应用开发：APUE读书笔记+源码
04-08
压缩包内容包含了第三版APUE读书笔记以及相关训练源码，适用于初学UNIX环境（Linux）应用编程的工程师进行学习，能够帮助工程师更好的上手Linux环境下的应用开发。压缩包中还包含很多文中的示例以及相关笔记注释，...
apue.2e:ubuntu下可以编译通过的apue源代码
03-24
在APUE.2e中，读者可以学习到如何使用pthread库创建和管理线程，理解线程同步和互斥的概念。这些知识对于编写并发应用程序至关重要，如服务器程序和高并发应用。 接着，APUE.2e详细阐述了文件I/O操作，包括打开、...
apue.2e:unix环境高级编程源码---在修改源码的过程中学习linux
03-23
4. **信号处理**：Unix系统中的信号机制用于进程间通信和异常处理，APUE会介绍signal(), sigaction()等函数的用法，以及如何编写信号处理函数。 5. **多线程**：线程是Unix/Linux系统中的轻量级进程，通过pthread库...
浮点运算转换成整数运算
二斗墨汁
06-02 4717
相比整数运算，浮点运算是很慢的，在效率要求很高的情形下，有时我们得转换成整数运算 如下面的表达式: void get_gray(int red, int green, int blue, int & gray) { gray = static_cast(red * 0.123 + green * 0.456 + blue * 0.421 + 0.5); } 可以转换为:
linux下静态库的依赖顺序
二斗墨汁
04-28 3665
贴下结论： LD在链接生成目标文件时, 会从左到有扫描输入的依赖库, 但是, 当依赖库之间也有依赖关系时,必须将”依赖别人的库”放在 “被别人依赖的库”的前面. 否则,会链接失败!
试题:两个基类有同名的虚函数要实现, 怎么办?
二斗墨汁
01-06 3318
先把问题陈述一下: 有两个类A, B, 它们可能是别人实现的(或是别人提供的库中的类), 很复杂且已经在用, 你不能修改他们, 你想写一个类C同时具有这两个类的特性, 因为自己实现它代价实在是太大, 所以你想到用C继承A, B以达到效果, 但是有一个问题, A, B具有一个同名的虚函数, 你在C中怎么重新实现这个虚函数呢? 先看下面的代码: #include #include usin
【笔记】Qt程序在Windows、OS X、CentOS、Ubuntu下的打包处理
二斗墨汁
08-28 3172
主程序名 web_transmit_adapter Windows： 打包主目录windows：包含子目录web_transmit_adapter和两个打包文件web_transmit_adapter.nsi、和packing.bat 而在web_transmit_adapter子目录中包含了Qt程序web_transmit_adapter.exe以及一些依赖的第三方库文件等 发布
UNP函数笔记七: 基本SCTP套接字编程
二斗墨汁
04-14 2686
第九章  基本SCTP套接字编程: #include int sctp_bindx(int sockfd, const struct sockaddr * addrs, int addrcnt, int flags); flags: SCTP_BINDX_ADD_ADDR, SCTP_BINDX_REM_ADDR success
fatal error: apue.h: 没有那个文件或目录
06-01
这个错误提示表明您的代码中使用了一个名为apue.h的头文件，但是编译器无法找到这个文件。可能原因是您没有正确地设置编译器的头文件搜索路径或者您没有安装该头文件所属的库。 您可以尝试以下步骤来解决该问题： ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值