UNIX高级环境编程读书笔记（chapter11）

最新推荐文章于 2017-04-30 20:05:45 发布
原创 最新推荐文章于 2017-04-30 20:05:45 发布 · 403 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本博客详细阐述了线程的概念、创建与销毁、线程标识、线程同步方法，包括互斥量、读写锁、条件变量等，并通过实例展示了如何使用这些技术保护共享资源，以及如何避免死锁等问题。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

第11章 线程



       典型的UNIX进程可以看成只有一个控制线程：一个进程在同一时刻只做一件事情。有了多个控制线程以后，在程序设计时可以把线程设计成在同一时刻能够做不止一件事情，每个线程处理各自独立的任务。


        (1)通过为每种事件类型的处理分配单独的线程,能够简化处理异步事件的代码。

        (2)多个进程必需使用操作系统提供的复杂机制才能实现内存和文件描述符的共享。

        (3)有些问题可以通过将其分解从而改善整个程序的吞吐量。

        (4)交互的程序同样可以通过使用多线程实现响应时间得改善，多线程可以把程序中处理用户输入输出的部分与其他部分分开。


一、线程标识

     就像每个进程ID一样，每个线程也有一个线程ID。进程在整个系统中是唯一的，但线程ID不同，线程ID只在它所属的进程环境中有效。

线程用pthread_t数据类型来表示，实现的时候可以用一个结构来代表pthread_t数据类型，所以，可移植的操作系统实现不能把它作为整数处理。因此必需使用函数来对两个线程ID进行比较:

        int pthread_equal(pthread_t tid1, pthread_t tid2);

        线程可以通过pthread_self函数获得自身的线程ID：

         pthread_t pthread_self(void);


二、线程创建

       在传统的UINIX进程模型中，每个进程只有一个控制线程。在POSIX线程的情况下，程序开始运行时，它是以单进程中的单个控制线程启动的，在创建多个控制线程以前，程序的行为与传统的进程并没有什么区别。新增的线程可以通过调用pthread_create函数创建：

      int pthread_create(pthread_t *restrict tidp, const pthread_attr_t, void *(*start_rtn)(void *), void *restrict arg);

注意:pthread函数在调用失败时通常会返回错误码,它们并不像其他POSIX函数一样设置errno。


实例：创建一个线程并且打印进程ID、新线程的线程ID以及初始现成的线程ID。

#include "apue.h"
#include <dlfcn.h>
#include <pthread.h>


static void * thr_fn(void *arg);
static void printids(const char *s);

pthread_t ntid;

static 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);
}

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

int main(void)
{
    int err;

    err = pthread_create(&ntid, NULL, thr_fn, NULL);
    if (err != 0)
    {
        err_quit("can't create thread: %s\n", strerror(err));
    }

    printids("main thread: ");
    sleep(1);
    exit(0);
}

编译和运行：

        gcc 11.1.c -o 11.1 -lpthread

        ./11.1
        main thread:  pid 4381 tid 3078342336 (0xb77bc6c0)
        new thread:  pid 4381 tid 3078339440 (0xb77bbb70)


         这个实例有两个特别之处，需要处理主线程和新线程之间的竞争。首先是主线程需要休眠，如果主线程不休眠，它就可能退出，这样在新线程有机会运行之前整个进程可能就已经终止了。这种行为特征依赖于操作系统中的线程实现和调度算法。


三、线程终止

       如果进程中的任意线程调用了exit、_Exit、_exit，那么整个进程就会终止。与此类似，如果信号的默认动作是终止进程，那么把该信号发送到线程会终止整个进程。

       单个线程可以通过下列三个方式退出：

        (1)线程只是从启动例程中返回,返回值是线程的退出码.

        (2)线程可以被同一进程中的其他线程取消.

        (3)线程调用pthread_exit.

             void pthread_exit(void *rval_ptr);

        进程中的其它线程可以通过调用pthread_join函数访问到这个指针：

int pthrea_join(pthread_t thread, void **rval_ptr)   

调用线程将一直阻塞，直到指定的线程调用pthread_exit、从启动例程中返回或者被取消。如果线程只是从它的启动例程返回，rval_ptr将包含返回码。如果线程被取消，则有rval_ptr指定的内存单元就置为PTHREAD_CANCELED。

实例：获取已终止的线程的退出码：

#include "apue.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");
    pthread_exit((void *)2);
}

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

    err = pthread_create(&tid1, NULL, thr_fn1, NULL);
    if (err != 0)
    {
        err_quit("can't creat thread 1: %s\n", strerror(err));
    }

    err = pthread_create(&tid2, NULL, thr_fn2, NULL);
    if (err != 0)
    {
        err_quit("can't creat thread 2: %s\n", strerror(err));
    }

    err = pthread_join(tid1, &tret);
    if (err != 0)
    {
        err_quit("can't join with thread 1: %s\n", strerror(err));
    }
    printf("thread 1 exit code %d\n", (int)tret);

    err = pthread_join(tid2, &tret);
    if (err != 0)
    {
        err_quit("can't join with thread 2: %s\n", strerror(err));
    }
    printf("thread 2 exit code %d\n", (int)tret);

    exit(0);
}


编译和运行结果:


gcc 11.2.c -o 11.2 -lpthread

        ./11.2
        thread 2 exiting
        thread 1 returning
        thread 1 exit code 1
        thread 2 exit code 2

       可以看出，当一个线程通过调用pthread_exit退出或者简单地从启动例程中返回时， 进程中的其他线程可以通过调用pthread_join函数获得该线程的退出状态。


实例：pthread_exit函数的不正确使用。

#include "apue.h"
#include <pthread.h>

struct foo
{
    int a;
    int b;
    int c;
    int d;
};

void printfoo(const char *s, const struct foo *fp)
{
    printf(s);
    printf("struct at 0x%xx\n", (unsigned)fp);
    printf(" foo.a = %d\n", fp->a);
    printf(" foo.b = %d\n", fp->b);
    printf(" foo.c = %d\n", fp->c);
    printf(" foo.d = %d\n", fp->d);
}

void *thr_fn1(void)
{
    struct foo foo = {1, 2, 3, 4};
    printfoo("thread 1: \n", &foo);
    pthread_exit((void*)&foo);
}


void *thr_fn2(void)
{
    printfoo("thread 2: ID is %d\n", pthread_self());
    pthread_exit((void*)0);
}

int main(void)
{
    int err;
    pthread_t tid1, tid2;
    struct foo *fp;

    err = pthread_create(&tid1, NULL, thr_fn1, NULL);

    if (err != 0)
    {
        err_quit("can't create thread 1: %s\n", strerror(err));
    }

    err = pthread_join(tid1, (void *)&fp);
    if (err != 0)
    {
        err_quit("can't join with thread 1: %s\n", strerror(err));
    }
    sleep(1);

    printf("parent starting second thread\n");
    err = pthread_create(&tid2, NULL, thr_fn2, NULL);

    if (err != 0)
    {
        err_quit("can't create thread 2: %s\n", strerror(err));
    }
    sleep(1);
    printf("parent: \n", fp);
    exit(0);
}

编译和运行结果：

        gcc 11.3.c -o 11.3 -lpthread

        thread 1: 
        struct at 0xb77e6370x
        foo.a = 1
        foo.b = 2
        foo.c = 3
        foo.d = 4
        parent starting second thread
        thread 2: ID is 9120912
        struct at 0xb77e6b70x
        foo.a = -1216451728
        foo.b = 138305552
        foo.c = -1216451728
        foo.d = 1
        parent:


        可以看出，当主线程访问这个结构时，结构的内容已经改变。为了解决这个问题，可以使用全局结构， 或者用malloc函数分配结构

       



pthread_cancel函数：

        线程可以通过调用thread_cancel函数来请求取消同一进程中的其它线程:

                int pthread_cancel(pthread_t tid);

              

        pthread_cancel函数并不等待线程终止，它仅仅提出请求。


清理函数：

        void pthread_cleanup_push(void (*rtn)(void *), void *arg);

        void pthread_cleanup_pop(int excute);

        当线程执行以下动作时调用清理函数， 调用参数为arg，清理函数rtn的调用顺序是由pthread_cleanup_push函数来安排的。

        (1)调用pthread_exit时

        (2)响应取消请求时

        (3)用非零excute参数调用pthread_cleanup_pop时;

实例:线程清理处理程序

#include "apue.h"
#include <pthread.h>

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

void *
thr_fn1(void *arg)
{
    printf("thread 1 start\n");
    pthread_cleanup_push(cleanup, "thread 1 first handler");
    pthread_cleanup_push(cleanup, "thread 1 second handler");
    printf("thread 1 push complete\n");

    if (arg)
    {
        return((void *)1);
    }

    pthread_cleanup_pop(0);
    pthread_cleanup_pop(0);
    return((void *)1);
}

void *
thr_fn2(void *arg)
{
    printf("thread 2 start\n");
    pthread_cleanup_push(cleanup, "thread 2 first handler");
    pthread_cleanup_push(cleanup, "thread 2 second handler");
    printf("thread 2 push complete\n");

    if (arg)
    {
        return((void *)2);
    }

    pthread_cleanup_pop(0);
    pthread_cleanup_pop(0);
    return((void *)2);
}

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

    err = pthread_create(&tid1, NULL, thr_fn1, (void *)1);
    if (err != 0)
    {
        err_quit("can't create thread 1: %s\n", strerror(err));
    }

    err = pthread_create(&tid2, NULL, thr_fn2, (void *)2);
    if (err != 0)
    {
        err_quit("can't create thread 2: %s\n", strerror(err));
    }

    err = pthread_join(tid1, &tret);
    if (err != 0)
    {
        err_quit("can't join with thread 1: %s\n", strerror(err));
    }
    printf("thread 1 exit code %s\n", (int)tret);

    err = pthread_join(tid1, &tret);
    if (err != 0)
    {
        err_quit("can't join with thread 1: %s\n", strerror(err));
    }
    printf("thread 2 exit code %s\n", (int)tret);
    exit(0);
}


        如果线程是通过它的启动例程中返回而终止的话，那么它的清理程序就不会被调用，还要注意清理程序是按照于它们安装时相反的顺序被调用的。

在默认情况下，线程的终止状态会保存到对该线程调用pthreat_join，如果线程已经处于分离状态，线程的底层存储资源可以在线程终止时立即被收回

pthread_detach调用可以用于使线程可以进入分离状态。

        int pthread_detach(pthread_t tid);

四、线程同步

       当某个线程可以修改变量，而其它线程也可以读取或者修改这个变量的时候，就需要对这些线程进行同步，以确保他们在访问变量的存储内容时不会访问到无效的数值。

       为了解决这个问题，线程不得不使用锁，在同一时间只允许一个线程访问该变量。

       当两个或多个线程试图在同一时间修改同一变量时， 也需要进行同步。

        1.互斥量

               可以通过使用pthread的互斥接口保护数据，确保同一时间只有一个线程访问数据。互斥量从本质上说是一            把锁，在访问共享资源前对互斥量进行加锁，在访问完成后释放互斥量的锁。

                互斥量用pthread_mutex_t数据类型来表示，在使用互斥量以前，必须首先对它进行初始化。也可以通过调            用pthread_mutex_init函数进行初始化。如果动态分配互斥量，则释放内存前要调pthread_mutex_destroy。

                 int pthreat_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);

                 int pthread_mutex_destroy(pthread_mutex_t *mutex);

         要用默认的属性初始化互斥量,只需要把attr设置为NULL。

                 对互斥量进行加锁，需要调用pthread_mutex_lock。对互斥量解锁，需要调用pthread_mutex_unlock。

                 int  pthread_mutex_lock(pthread_mutex_t *mutex);

                 int  pthread_mutex_trylock(pthread_mutex_t *mutex);

                 int  pthread_mutex_unlock(pthread_mutex_t *mutex)；

                 返回值：若成功则返回0， 否则返回错误编码。

实例：使用互斥量保护数据结构

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

struct foo
{
    int f_count;
    pthread_mutex_t f_lock;
};


struct foo *
foo_alloc(void)
{
    if ((fp = malloc(sizeof(struct foo))) != NULL)
    {
        fp->fp_count = 1;
        if (pthread_mutex_init(&fp->f_lock, NULL) != 0)
        {
            free(fp);
            return(NULL);
        }
    }
    return(fp);
}


void foo_hold(struct foo *fp)
{
    pthread_mutex_lock(&fp->f_lock);
    fp->f_count++;
    pthread_mutex_unlock(&fp->f_lock);
}

void
foo_rele(struct foo *fp)
{
    pthread_mutex_lock(&fp->f_lock);
    if (--fp->f_count == 0)
    {
        pthread_mutex_unlock(&fp->f_lock);
        pthread_mutex_destroy(&fp->f_lock);
        free(fp);
    }
    else
    {
        pthread_mutex_unlock(&fp->flock);
    }
}

            2.避免死锁

       如果线程试图对同一个互斥量加锁两次，那么它自身就会陷入死锁状态，使用互斥量时，还有其他更不明显         的方式也能产生死锁。

                可以通过小心的控制互斥量加锁的顺序来避免死锁的发生。

实例：使用两个互斥量


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

#define NHASH 29;
#define HASH(fp)    (((unsigned long)fp) % NHASH)
struct foo *fh[NHASH];

struct foo
{
    int f_count;
    pthread_mutex_t f_lock;
    struct foo *next;
    int f_id;
};


struct foo *
foo_alloc(void)
{
    struct foo *fp;
    int idx;
    if ((fp = malloc(sizeof(struct foo))) != NULL)
    {
        fp->fp_count = 1;
        if (pthread_mutex_init(&fp->f_lock, NULL) != 0)
        {
            free(fp);
            return(NULL);
        }

        idx = HASH(fp);
        pthread_mutex_lock(&hashlock);
        fp->f_next = fh(idx);
        fh[idx] = fp;
        pthread_mutex_lock(&fp->flock);
        pthread_mutex_unlock(&fp->f_lock);
    }
    return(fp);
}


void foo_hold(struct foo *fp)
{
    pthread_mutex_lock(&fp->f_lock);
    fp->f_count++;
    pthread_mutex_unlock(&fp->f_lock);
}

struct foo *
foo_find(int id)
{
    struct foo *fp;
    int idx;

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

void
foo_rele(struct foo *fp)
{
    struct foo *tfp;
    int idx;


    pthread_mutex_lock(&fp->f_lock);

    if (fp->f_count == 1)
    {
        pthread_mutex_unlock(&fp->f_lock);
        pthread_mutex_lock(&hashlock);
        pthread_mutex_lock(&fp->f_lock);

        if (fp->f_count != 1)
        {
            fp->f_count--;
            pthread_mutex_unlock(&fp->f_lock);
            pthread_mutex_unlock(&hashlock);
            return;
        }
        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->next;
        }

        pthread_mutex_unlock(&hashlock);
        pthread_mutex_unlock(&fp->f_lock);
        pthread_mutex_destroy(&fp->f_lock);
        free(fp);
    }
    else
    {
        fp->f_count--;
        pthread_mutex_unlock(&fp->f_lock);
    }
}


实例：简化的加、解锁

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

#define NHASH 29;
#define HASH(fp)    (((unsigned long)fp) % NHASH)
struct foo *fh[NHASH];
pthread_mutex_t hashlock = PTHREAD_MUTEX_INITIALZER;


struct foo
{
    int             f_count;
    pthread_mutex_t f_lock;
    struct foo      *next;
    int             f_id;
};


struct foo *
foo_alloc(void)
{
    struct foo *fp;
    int idx;
    if ((fp = malloc(sizeof(struct foo))) != NULL)
    {
        fp->fp_count = 1;
        if (pthread_mutex_init(&fp->f_lock, NULL) != 0)
        {
            free(fp);
            return(NULL);
        }

        idx = HASH(fp);
        pthread_mutex_lock(&hashlock);
        fp->f_next = fh(idx);
        fh[idx] = fp;
        pthread_mutex_lock(&fp->flock);
        pthread_mutex_unlock(&fp->f_lock);
    }
    return(fp);
}


void foo_hold(struct foo *fp)
{
    pthread_mutex_lock(&fp->f_lock);
    fp->f_count++;
    pthread_mutex_unlock(&fp->f_lock);
}

struct foo *
foo_find(int id)
{
    struct foo *fp;
    int         idx;

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

void
foo_rele(struct foo *fp)
{
    struct foo *tfp;
    int idx;


    pthread_mutex_lock(&fp->f_lock);
    if (--fp->f_count == 0)
    {
        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(&fp->f_lock);
    }
}

        3.读写锁

      读写锁与互斥量类似，不过读写锁允许更高的并行性。互斥量要么是锁住状态，要么是不加锁状态，而且一        次只有一个线程可以对其加锁。读写锁可以有三种状态：读模式下加锁状态，写模式下加锁状态，不加锁状态。        一次只有一个线程可以占有写模式的读写锁，但是多个线程可以占有读模式的读写锁。

实例：使用读写锁

#include <pthread.h>

struct job
{
    struct job *j_next;
    struct job *j_prev;

    pthread_t j_id;
};

struct queue
{
    struct job *q_head;
    struct job *q_tail;

    pthread_t q_lock;
};

int queue_init(stuct queue *qp)
{
    int err;

    qp->q_head = NULL;
    qp->q_tail = NULL;
    err = pthread_rwlock_init(&qp->q_lock, NULL);

    if (err != 0)
    {
        return(err);
    }

    return 0;
}


void
job_insert(struct queue *qp, struct job *jp)
{
    pthread_rwlock_wrlock(&qp->q_lock);
    jp->j_next = qp->q_head;
    jp->prev = NULL;

    if (qp->q_head != NULL)
    {
        qp->q_head->j_prev = jp;
    }
    else
    {
        qp->q_tail = jp;
    }

    qp->q_head = jp;
}

void
job_append(struct queue *qp, struct job *jp)
{
    pthread_rwlock_wrlock(&qp->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);
}


void
job_remove(struct queue *qp, struct job *jp)
{
    pthread_rwlock_wrlock(&qp->q_lock);
    if (jp == qp->q_head)
    {
        qp->q_head = jp->j_next;
        if (qp->q_tail == jp)
        {
                q_tail = NULL;
        }
    }
    else if (jp == qp->qtail)
    {
        qp->q_tail = jp->j_prev;
        if (qp->q_head == jp)
        {
            qp->q_head = NULL;
        }
    }
    else
    {
        jp->j_prev->j_next = jp->j_next;
        jp->j_next->j_prev = jp->j_prev;
    }

    pthread_rwlock_unlock(&qp->q_lock);
}

struct job *
{
    struct job *jp;

    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))
        {
            break;
        }
    }

    pthread_rwlock_unlock(&qp->q_lock);
    return (jp);
}


        4.条件变量

               条件变量是线程可用的另一种同步机制。条件变量给多个线程提供了一个会和的场所。条件变量与互斥量一        起使用时，允许线程以无竞争的方式等待特定的条件发生。

                条件本身是由互斥量保护的。线程在改变条件状态前必须首先锁住互斥量，其它线程在获得互斥量之前不          会察觉到这种改变，因为必需锁住互斥量以后才能计算条件。

实例：使用条件变量

#include <stdlib.h>

struct msg
{
    struct msg *m_next;
}

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

void process_msg(void)
{
    struct msg *mp;

    for (;;)
    {
        pthread_mutex_lock(&qlock);
        while (workq == NULL)
        {
            pthread_cond_wait(&qready, &qlock);
        }

        mp = workq;
        worq = mp->m_next;
        pthread_mutex_unlock(&qlock);
    }
}

void
equeue_msg(struct msg *mp)
{
    pthread_mutex_lock(&qlock);
    mp->m_next = workq;
    pthread_mutex_unlock(&qlock);
    pthread_cond_signal(&qready);
}


         在本章中，介绍了线程的概念，讨论了现有的创建线程和销毁线程的POSIX.1原语;此外,还介绍了线程同步的问题,讨论了三种基本的同步机制:互斥、读写锁以及条件变量，了解了如何使用它们来保护共享资源。


《UNIX网络编程——Socket Networking API》（3rd，Vol1）读书笔记(1)【第一章】
vingstar的专栏
08-15 1433
《Uni网络编程—Socket Networking API》 读书笔记 UNIX® Network Programming Volume 1, Third Edition: The Sockets Networking API>  Reading Notes (使用的是2003年的英文第三版）
《极致C语言》第10章 -- Unix 内核及其体系结构
weixin_44457905的博客
02-03 2576
《极致C语言》第10章学习笔记
UNIX高级环境编程读书笔记（chapter5）
fly_lhw的专栏
03-11 457
5.9 二进制IO 下列两个函数执行二进制IO操作：fread(),fwrite(). (1)读或写一个二进制数组; (2)读或写一个结构; 返回:读或写的对象数 5.10 定位流 有三种方法定位标准IO流 (1)ftell和fseek函数 (2)ftello和fseeko函数 (3)fgetpos和fsetpos函数 5.11 格式化IO 5.11.1  格
读书笔记《高级UNIX环境编程》
xsj的专栏
04-07 435
主要记录了阅读《高级UNIX环境编程》的过程中，发现的知识点。
UNIX高级环境编程读书笔记（chapter14）
fly_lhw的专栏
03-26 729
第十四章  高级IO 一、引言        本章内容包括非阻塞IO、记录锁、系统V流机制、I/O多路转接(select 和 poll函数)、readv和writev函数以及存储映射I\O，这些都称为高级I/O。 二、非阻塞I/O        非阻塞I/O使我们可以调用open、read和write这样的I/O操作，并使这些操作不会永远阻塞。如果这种操作不能完成，则调用立即出错返回，表示
UNIX高级环境编程读书笔记（chapter10）
fly_lhw的专栏
03-16 728
chapter 10  信号 信号就是软件中断。
UNIX高级环境编程读书笔记（chapter12）
fly_lhw的专栏
03-19 491
第十二章  线程控制 一、线程限制         与其它的系统限制一样，这些线程也可以通过sysconf函数进行查询。         与sysconf报告的其它限制一样，这些限制的使用是为了增强应用程序在不同的操作系统实现之间的可移植性。 二、线程属性 实例：以分离状态创建的线程 #include "apue.h" #include int makethre
UNIX高级环境编程读书笔记（chapter7）
fly_lhw的专栏
03-11 558
7.1 main函数 C程序总是从main函数开始执行。 7.2 进程终止 有8种方式是进程终止 (1)从main返回 (2)调用exit() (3)调用_exit或_Exit (4)最后一个线程从启动例程返回 (5)最后一个线程调用pthread_exit 异常终止有三种方式: (6)调用abort (7)接到一个信号并终止 (8)最后一个线程对取消请求做
UNIX高级环境编程读书笔记（chapter13）
fly_lhw的专栏
03-20 481
第十三章    守护进程         守护进程也称精灵进程是生存期较长的一种进程，它们常常在系统自举时启动，关闭时才终止，因为它们没有控制终端，所以说它们是在后台运行的。         系统进程依赖于操作系统实现。父进程ID为0的进程通常是内核进程，它们作为系统自举过程的一部分而启动。 一、编程规则        在编写守护进程程序时需遵循一些基本规则，以便防止产
UNIX高级环境编程读书笔记（chapter9）
fly_lhw的专栏
03-13 540
chapter 9 进程关系    当系统自举时，内核创建进程ID为1的进程，Init进程。Init进程使系统进入多用户状态。Init进程读文件/etc/ttys，对每一个允许登陆的终端设备，Init调用一次fork，它所生成的子进程则执行getty程序。 getty为终端设备调用open函数，以读写方式将终端打开。一旦设备被打开，则文件描述符0、1、2就被设置到该设备。然后getty输出“
UNIX高级环境编程读书笔记（chapter4）
fly_lhw的专栏
03-11 516
Chapter 4  文件和目录 4.0.给定一个pathname   (1)stat函数返回一个与此命名有关的信息结构.   (2)fstat函数获得已在描述符filedes上打开的文件的有关信息.            (3)lstat函数类似于stat,但是当命名的文件是一个符号链接时,lstat返回该符号链接的有关信息,而不是由该符号链接引用的文件的信息. 4.1文件类型 (1
unix学习笔记(网上转来的，和朋友们一起分享)
09-16
最后，笔记可能会介绍一些高级话题，如Unix的I/O重定向、信号处理、守护进程（daemon）以及Unix下的编程接口，如系统调用和C库函数。 总之，"Unix学习笔记"是一个全面的教程，旨在帮助初学者理解Unix的基本概念，...
UDP local server--Python网络编程学习笔记
oldwayphone的博客
04-30 773
Listing 2-1 UDP Server and Client让Server跑起来的步骤 第一步， 将以下代码复制到编辑器Notepad中，然后命名为udp_local.py保存在某个文件夹。 #!/usr/bin/env python3 # Foundations of Python Network Programming, Third Edition # https://github.com
UNIX高级环境编程读书笔记（chapter8）
fly_lhw的专栏
03-11 591
第八章 进程控制 每个进程都有一个非负整型表示唯一的进程ID.虽然是唯一的,但是进程ID可以重用,当一个进程终止后,其进程ID就可以再次使用了.ID为0的进程通常是调度进程,常常是交换进程,是内核的一部分,也被称为系统进程.进程ID1通常是init进程,在自举过程结束时内核调用. 8.1.由fork创建的新进程被称为子进程.fork函数被调用一次单返回两次.两次返回的唯一区别是子进程的返回值是
UNIX高级环境编程读书笔记（chapter1-3）
fly_lhw的专栏
03-11 559
UNIX： 程序的执行实例被称为进程； UNIX 环境高级编程： 1.调用open函数可以打开或创建一个文件. 2.可以调用creat函数创建一个新文件. 3.close函数关闭一个打开的文件. 4.lseek函数:每个打开的文件都有一个与其相关联的"当前文件偏移量".他通常是一个非负整数          Ex1:测试能否对标准输入设置偏移量: #include "ap
MPU9250九轴传感器数据融合：扩展卡尔曼滤波（EKF）算法解析与应用——以四元数、陀螺仪和加速度计为核心 · 四元数
最新发布
08-13
MPU9250 九轴传感器的工作原理及其应用背景，重点讲解了如何利用扩展卡尔曼滤波 (EKF) 进行数据融合。文中解释了选择四元数作为状态量、三轴陀螺仪的漂移作为控制量以及三轴加速度计和磁偏角作为观测量的原因。通过这种方式，在短时间尺度上优先信任陀螺仪提供的高精度角速度数据，而在长时间尺度上则依赖于加速度计提供的稳定姿态信息。此外，还提供了 Python 实现的简单 EKF 数据融合算法代码示例。 适合人群：对传感器数据融合感兴趣的电子工程技术人员、自动化控制领域的研究人员、从事机器人导航系统开发的技术人员。 使用场景及目标：适用于需要精确测量和稳定控制的场合，如无人机飞行控制系统、自动驾驶汽车的姿态感知模块、智能穿戴设备的动作捕捉单元等。目的是提高运动信息的准确性与稳定性。 其他说明：本文不仅理论阐述详尽，而且附有实际代码示例，便于读者理解和实践。对于希望深入了解传感器数据融合技术并掌握其实现细节的专业人士而言，是一份非常有价值的参考资料。
S7-200与MCGS PLC控制抽水泵系统：梯形图程序、接线图及组态画面解析 梯形图
08-13
No.201 S7-200与MCGS PLC在控制抽水泵系统中的应用。首先，文章讲解了梯形图程序作为控制逻辑的关键组成部分，展示了如何通过梯形图实现自动化控制，如当水位低于设定值时启动抽水泵电机。其次，文章阐述了IO分配与接线图原理图的重要性，通过合理的输入输出分配，确保系统的高效稳定运行。最后，文章介绍了MCGS PLC的组态画面，使操作人员能实时监控和管理系统，提供便捷的操作界面和故障排查工具。 适合人群：从事工业自动化领域的工程师和技术人员，特别是对PLC控制系统有一定了解的人群。 使用场景及目标：适用于需要理解和掌握S7-200与MCGS PLC在抽水泵系统中的具体应用场合，帮助工程师和技术人员更好地设计、安装和维护此类系统。 其他说明：文章不仅提供了理论知识，还附有具体的实例和图表，便于读者理解和实践。
威纶通触摸屏配方管理模板（含图库与宏程序详解）
08-13
内容概要：本文深入介绍了威纶通触摸屏配方管理模板的应用，涵盖从模板概览、文件构成到宏程序详解等多个方面。首先，模板包含完整的图库、原图和PS原文件，用户可以通过直接拖拽的方式快速设计触摸屏界面，或者对原文件进行个性化修改。其次，文中详细解释了宏程序的工作原理，以一个简单的照明控制系统为例，展示了如何利用宏程序实现灯光的开关控制。最后，文章强调了这套模板在实际应用中的灵活性和高效性，无论是简单控制还是复杂工艺流程，都能提供极大便利。 适合人群：从事自动化控制领域的工程师和技术人员，尤其是需要使用威纶通触摸屏进行项目开发的人员。 使用场景及目标：适用于各类工业控制场景，旨在提高工作效率，简化触摸屏界面设计和配置过程，帮助用户更好地理解和应用宏程序。 其他说明：本文不仅提供了理论指导，还通过具体实例进行了操作演示，确保读者能够在实践中掌握相关技能。
UNIX环境高级编程笔记：登录、Shell与文件系统
"这篇读书笔记主要涵盖了《UNIX环境高级编程》一书中的核心概念，包括UNIX系统的登录过程、shell的使用、以及文件和目录管理。笔记详细解析了UNIX登录时的口令文件结构，强调了shell作为命令行解释器的角色，并列举...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值