APUE第十一章学习笔记

最新推荐文章于 2020-02-23 17:37:32 发布
最新推荐文章于 2020-02-23 17:37:32 发布
阅读量335 收藏
点赞数
分类专栏： APUE 文章标签： 线程 APUE UNIX Linux linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/RGBMarco/article/details/78202342
版权

1.线程标识

/*****************************************
包含头文件:  #include <pthread.h>
函数原型:  int pthread_equal(pthread_t tid1,pthread_t tid2);
函数说明:   判断线程ID是否相等
返回值:若相等,返回非0数值,否则,返回0
*****************************************/

/*****************************************
包含头文件:  #include <pthread.h>
函数原型:   pthread_t pthread_self(void);
函数说明:线程得到自己线程ID
返回值:调用线程的线程ID
*****************************************/

vi 11.1.c

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

int main()
{
    printf("进程ID:  %d\n",getpid());
    printf("线程ID： %ld\n",(long int)(pthread_self()));
    return 0;
}

这里写图片描述

2.线程创建

/************************************************************
包含头文件:  #include <pthread.h>
函数原型:   int pthread_create(pthread_t *restrict tidp,const pthread_attr_t * restrict attr,void *(*start_rtn)(void *),void * restrict arg);
函数说明:当pthread_create成功返回时,新创建线程的线程ID会被设置成tidp指向的内存单元,attr用于指定各种不同的线程属性
返回值:若成功,返回0，否则,返回错误编号
*********************************************************/

vi 11.2.c

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

void* pthread_1(void *arg)
{
    printf("pthread1 starting \n");
    printf("线程1 ID:  %ld\n",pthread_self());
    printf("do we want to do\n");
    printf("pthread1 ending\n");
    return (void*)0;
}

void * pthread_2(void* arg)
{

    printf("pthread2 starting \n");
    printf("线程2 ID:  %ld\n",pthread_self());
    printf("do we want to do\n");
    printf("pthread2 ending\n");
    return (void*)0;
}

int main()
{
    int err;
    pthread_t tid1,tid2;
    err = pthread_create(&tid1,NULL,pthread_1,NULL);
    if (err != 0)
    {
    printf("pthread_create 1 error\n");
    exit(0);
    }

    err = pthread_create(&tid2,NULL,pthread_2,NULL);

    if (err != 0)
    {
    printf("pthread_create 2 error\n");
    exit(0);
    }

    sleep(2);
    return 0;
}

这里写图片描述

3.线程终止

vi 11.3.c

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

void* pthread_1(void* arg)
{
    printf("线程 1 ID:  %ld 进行中\n",pthread_self());
    printf("do something you want to\n");
    printf("exiting \n");
    return (void*)1;
}

void * pthread_2(void *arg)
{
    printf("线程 2 ID: %ld 进行中\n",pthread_self());
    printf("do something you want to\n");
    printf("exiting \n");
    pthread_exit((void*)1);
}

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

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

    if (err != 0)
    {
    printf("pthread_create 1 error\n");
    exit(0);
    }

    if (pthread_join(tid1,&rval_ptr) != 0)
    {
    printf("pthread_join 1 error\n");
    exit(0);
    }

    printf("thread 1 exit code is %ld\n",(long)rval_ptr);

    err = pthread_create(&tid2,NULL,pthread_2,NULL);

    if (err != 0)
    {
    printf("pthread_create 2 error\n");
    exit(0);
    }

    if (pthread_join(tid2,&rval_ptr) != 0)
    {
    printf("pthread_join 2 error\n");
    exit(0);
    }

    printf("thread 2 exit code is %ld\n",(long)rval_ptr);

    return 0;
}

这里写图片描述

/*****************************************
包含头文件:  #include <pthread.h>
函数原型:   int pthread_cancel(pthread_t tid);
函数说明:请求取消同一进程中的其他线程
返回值:若成功,返回0，否则，返回错误编号
*****************************************/

/**************************************************
包含头文件:  #include <pthread.h>
函数原型:   void pthread_cleanup_push(void(*rtn)(void*),void* arg);
            void pthread_cleanup_pop(int execute);
函数说明: 压进或弹出线程退出函数
1.调用pthread_exit时
2.响应取消请求时
3.用非零execute参数调用pthread_cleanup_pop时
如果exec参数设置为0，清理函数将不被调用
发生1,2,3情况,pthread_cleanup_pop都会自动调用一次
*****************************************************/

vi 11.4.c

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


pthread_t temp1,temp2;

void cleanup(void * arg)
{
    printf("调用线程ID为:  %ld existing \n",*(long*)arg);
}

void* pthread_1(void* arg)
{
    printf("线程 1 ID %ld\n",pthread_self());

    temp1 = pthread_self();

    pthread_cleanup_push(cleanup,(void*)&temp1);

    pthread_exit((void*)1);

    pthread_cleanup_pop(0);
}

void* pthread_2(void *arg)
{
    printf("线程 2 ID %ld\n",pthread_self());

    temp2 = pthread_self();
    pthread_cleanup_push(cleanup,(void*)&temp2); 

    pthread_exit((void*)2);

    pthread_cleanup_pop(0);
}

int main()
{
    pthread_t tid1,tid2;
    int err;

    err = pthread_create(&tid1,NULL,pthread_1,NULL);
    if (err != 0)
    {
    printf("thread 1 create error\n");
    exit(0);
    }


    err = pthread_create(&tid2,NULL,pthread_2,NULL);
    if (err != 0)
    {
    printf("thread 2 create error\n");
    exit(0);
    }

    err = pthread_join(tid1,NULL);
    if (err != 0)
    {
    printf("pthread_join 1 error\n");
    exit(0);
    }


    err = pthread_join(tid2,NULL);
    if (err != 0)
    {
    printf("pthread_join 2 error\n");
    exit(0);
    }
    return 0;
}

这里写图片描述

/***********************************************
包含头文件:  #include <pthread.h>
函数原型:   int pthread_detach(pthread_t tid);
函数说明:进行线程分离,线程底层资源会被立即回收
，分离后不能用pthread_join等待它的终止状态
返回值:若成功,返回0，返回错误编号
************************************************/

4.线程同步

1.互斥量

/*********************************************
包含头文件:  #include <pthread.h>
函数原型:   int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t * restrict atrr);
函数说明:初始化 pthread_mutex_t
可以通过常量 PTHREAD_MUTEX_INITIALIZER初始化(只适合用于静态分配),也可以通过pthread_mutex_init进行初始化,动态分配pthread_mutex_t时要调用pthread_mutex_destroy释放内存，attr初始化pthread_mutex_t属性
int  pthread_mutex_destroy(pthread_mutex_t * mutex);
返回值:若成功,返回0,若出错,返回错误编号
*********************************************/
/*****************************************
包含头文件:  #include <pthread.h>
函数原型:1.int pthread_mutex_lock(pthread_mutex_t * mutex);
2. int pthread_mutex_trylock(pthread_mutex_t * mutex);
3.int pthread_mutex_unlock(pthread_mutex_t *mutex);
函数说明:1.若互斥量是锁住的,则该线程阻塞,直到互斥量被解锁，否则,锁住互斥量
2.若互斥量是锁住的,则调用失败,返回EBUSY,否则,锁住互斥量
3.解锁互斥量
返回值:若成功,返回0，若失败,返回错误编号
*****************************************/

vi 11.5.c

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

//维护struct Student* next
pthread_mutex_t mutex_next = PTHREAD_MUTEX_INITIALIZER;
struct Student
{
    int age;
    std::string name;
    char sex;
    pthread_mutex_t mutex_mem;
    struct Student* next = NULL;
};

struct Student* head = NULL;
void addRecord(struct Student s)
{
    pthread_mutex_lock(&mutex_next);
    if (head == NULL)
    {
    head = (struct Student*)malloc(sizeof(struct Student));
    head->mutex_mem = PTHREAD_MUTEX_INITIALIZER;
    pthread_mutex_lock(&head->mutex_mem);
    head->age = s.age;
    head->name = s.name;
    head->sex = s.sex;
    pthread_mutex_unlock(&head->mutex_mem);
    pthread_mutex_unlock(&mutex_next);
    return;
    }
    struct Student * temp = head;
    while (temp->next != NULL)
    temp = temp->next;
    temp->next = (struct Student*)malloc(sizeof(struct Student));
    pthread_mutex_init(&temp->next->mutex_mem,NULL);
    pthread_mutex_lock(&temp->next->mutex_mem);
    temp->next->age = s.age;
    temp->next->name = s.name;
    temp->next->sex = s.sex;
    pthread_mutex_unlock(&temp->next->mutex_mem);
    pthread_mutex_unlock(&mutex_next);
}
void* pthread_n(void* arg)
{
    if (arg == NULL)
    return (void*)1;
    addRecord(*(struct Student*)arg);
    pthread_exit((void*)0);
}
void display()
{
    if (head == NULL)
    return;
    struct Student* temp = head;
    while (temp != NULL)
    {
    printf("姓名:  %s  年龄:  %d 性别: %c\n",temp->name.c_str(),temp->age,temp->sex);
    temp = temp->next;
    }
}
int main()
{

    struct Student s[5]
    {
    {19,"marco",'m'},
    {20,"Tom",'m'},
    {15,"Mary",'w'},
    {14,"Coco",'w'},
    {17,"Sam",'m'}
    };
    pthread_t tid[5];
    int err;

    for (int i = 0; i < 5; ++i)
    {
    err = pthread_create(&tid[i],NULL,pthread_n,&s[i]);
    if (err != 0)
    {
        printf("thread %d create failure\n",i);
        continue;
    }
    }
    sleep(3);
    display();
    return 0;
}

这里写图片描述

5。读写锁

/*****************************************
包含头文件:  #include <pthread.h>
函数原型: int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,const pthread_rwlockattr_t *restrict
attr);
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
函数说明:可用常量PTHREAD_RWLOCK_INITIALIZER初始化(初始化静态分配的互斥量),pthread_rwlock_init也可初始化,对于动态分配的pthread_rwlock_t需要调用pthread_rwlock_destroy释放内存
返回值:若成功,返回0，若失败,返回错误编号
*****************************************/


/*****************************************
包含头文件:  #include <pthread.h>
函数原型:   1.int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
2.int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
3.int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
函数说明:读模式锁定读写锁,写模式锁定读写锁线程将被阻塞,待读模式读写锁全解锁时,写模式读写锁才可被锁定，写模式读写锁被锁定时,读模式读写锁被阻塞
*****************************************/

/*****************************************
包含头文件:  #include <pthread.h>
函数原型:   int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_trywrlock(pthread_rwlock_t * rwlock);
函数说明:若不能立即锁定读模式的读写锁或锁定写模式的读写锁,函数返回错误编号EBUSY，否则立即锁定
返回值:若成功,返回0，若失败,返回错误编号
*****************************************/


/*****************************************
包含头文件:  #include <pthread.h>
函数原型:   int pthread_rwlock_timerdlock(pthread_rwlock_t * rwlock,const struct timespec *restrict tsptr);
int pthread_rwlock_timewrlock(pthread_rwlock_t * rwlock,const struct timespec *restrict tsptr);
函数说明:tsptr表示绝对时间,若超过绝对时间,返回错误编号ETIMEOUT
返回值:若成功,返回0，若失败,返回错误编号
*****************************************/

6.条件变量

/*****************************************
包含头文件:  #include <pthread.h>
函数原型:   int pthread_cond_init(pthread_cond_t *restrict cond,const pthread_condattr_t *restrict attr);
int pthread_cond_destroy(pthread_cond_t *cond);
函数说明:   可由PTHREAD_COND_INITIALIZER初始化pthread_cond_t(初始化静态分配的pthread_cond_t)或者以pthread_cond_init初始化pthread_cond_t，释放条件变量的底层空间之前,可以用pthread_cond_destroy进行反初始化
返回值:若成功,返回0，若出错,返回错误编号
*****************************************/

/*****************************************
包含头文件:  #include   <pthread.h>
函数原型:   int pthread_cond_wait(pthread_cond_t *restrict cond,pthread_mutex_t *restrict mutex);
int pthread_cond_timewait(pthread_cond_t *restrict cond,pthread_mutex_t * restrict mutex，const struct timespec *restrict tsptr);
函数说明:传递给pthread_cond_wait的互斥量对条件进行保护,调用者把锁住的互斥量传给函数,函数自动把调用线程放入等待队列,返回时,对互斥量再次加锁,tsptr是绝对时间,绝对时间内未返回就返回错误码变量
*****************************************/

/*****************************************
包含头文件:  #include <pthread.h>
函数原型:   1.int pthread_cond_signal(pthread_cond_t 
*cond);
2.int pthread_cond_broadcast(pthread_cond_t *cond);
函数说明:1.唤醒至少一个等待条件变量满足的线程
2.唤醒所有所有等待条件变量满足的线程
返回值:若成功,返回0，若失败,返回错误编号
*****************************************/

vi 11.6.c

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

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

void* pthread_1(void* arg)
{
    pthread_mutex_lock(&mutex);
    pthread_cond_wait(&cond,&mutex);
    printf("thread 1 something after thread 2\n");
    printf("thread 1 exiting\n");
    pthread_mutex_unlock(&mutex);
    pthread_exit((void*)0);
}

void* pthread_2(void* arg)
{
    pthread_mutex_lock(&mutex);
    printf("thread 2 do something before thread 1\n");
    //......
    printf("thread 2 exiting\n");
    pthread_mutex_unlock(&mutex);
    pthread_cond_signal(&cond);
    pthread_exit((void*)0);
}
void* pthread_3(void* arg)
{
    pthread_mutex_lock(&mutex);
    printf("thread 3 do something\n");
    printf("thread 3 exiting\n");
    pthread_mutex_unlock(&mutex);
    pthread_exit((void*)0);
}

int main()
{
    pthread_t tid1,tid2,tid3;

    int err;

    err = pthread_create(&tid1,NULL,pthread_1,NULL);
    if (err != 0)
    {
    printf("thread create error\n");
    exit(0);
    }

    err = pthread_create(&tid2,NULL,pthread_2,NULL);
    if (err != 0)
    {
    printf("thread 2 create error\n");
    exit(0);
    }

    err = pthread_create(&tid3,NULL,pthread_3,NULL);
    if (err != 0)
    {
    printf("thread 3 create error\n");
    exit(0);
    }
    sleep(2);
    return 0;
}

这里写图片描述

7.自旋锁

/*****************************************
包含头文件:  #include  <pthread.h>
函数原型:   int pthread_spin_init(pthread_spinlock_t *lock,int pshared);
int pthread_spin_destroy(pthread_spinclok_t *lock);
函数说明:初始化pthread_spinlock_t，pshared可设置为PTHREAD_PROCESS_SHARED为多进程共享自旋锁,如果设置为PTHREAD_PROCESS_PRIVATE，则只能同一进程的多线程共享
pthread_spin_destroy进行pthread_spinlock_t进行反初始化
返回值:若成功,返回0，若出错，返回错误编号
*****************************************/


/*****************************************
包含头文件:  #include <pthread.h>
函数原型:   int pthread_spin_lock(pthread_spinlock_t *lock);
int pthread_spin_trylock(pthread_spinlock_t *lock);
int pthread_spin_unlock(pthread_spinlock_t *lock);
函数说明:进行加锁，试图加锁,解锁
返回值:若成功,返回0，若出错,返回错误编号
*****************************************/

vi 11.7.c

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

pthread_spinlock_t spin;

void* pthread_1(void *arg)
{
    pthread_spin_lock(&spin);
    printf("thread 1 is starting\n");
    printf("do something you want to do\n");
    printf("thread 1 is exiting\n");
    pthread_spin_unlock(&spin);
    pthread_exit((void*)0);
}

void* pthread_2(void* arg)
{

    pthread_spin_lock(&spin);
    printf("thread 2 is starting\n");
    printf("do something you want to do\n");
    printf("thread 2 is exiting\n");
    pthread_spin_unlock(&spin);
    pthread_exit((void*)0);
}
void* pthread_3(void* arg)
{
    pthread_spin_lock(&spin);
    printf("thread 3 is starting\n");
    printf("do something you want to do\n");
    printf("thread 3 is exiting\n");
    pthread_spin_unlock(&spin);
    pthread_exit((void*)0);
}

int main()
{
    pthread_t tid1,tid2,tid3;

    int err;
    err = pthread_spin_init(&spin,PTHREAD_PROCESS_PRIVATE);
    if (err != 0)
    {
    printf("pthread spinlock init error\n");
    exit(0);
    }

    err = pthread_create(&tid1,NULL,pthread_1,NULL);
    if (err != 0)
    {
    printf("thread 1 create error\n");
    exit(0);
    }

    err = pthread_create(&tid2,NULL,pthread_2,NULL);
    if (err != 0)
    {
    printf("thread 3 create error\n");
    exit(0);
    }

    err = pthread_create(&tid3,NULL,pthread_3,NULL);
    if (err != 0)
    {
    printf("thread 3 create error\n");
    exit(0);
    }
    sleep(2);
    return 0;
}

这里写图片描述

8.屏障


/*****************************************
包含头文件:  #include <pthread.h>
函数原型:   int pthread_barrier_init(pthread_barrier_t *restrict barrier,const pthread_barrierattr_t *restrict attr,unsigned int count);
int pthread_barrier_destroy(pthread_barrier_t *barrier);
函数说明:初始化pthread_barrier_t,count为允许所有线程运行之前必须到达屏障的线程数目,使用attr参数
指定屏障对象的属性
pthread_barrier_destroy反初始化释放分配给pthread_barrier_t的资源
返回值:若成功,返回0,若出错,返回为错误编号
*****************************************/











/*****************************************
包含头文件:  #include <pthread.h>
函数原型:   int pthread_barrier_wait(pthread_barrier_t * barrier);
函数说明:使未满足屏障计数的线程处于休眠状态,直到最后一个满足屏障计数的线程开始,所有线程将被唤醒
对于任意线程,pthread_barrier_wait的返回值为PTHREAD_BARRIER_SERIAL_THREAD,剩下的线程看到的返回值是0
返回值:若成功,返回为PTHREAD_BARRIER_SERIAL_THREAD，若出错,返回值为错误编号
*****************************************/

vi 11.8.c


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

pthread_barrier_t barrier;

void* pthread_1(void *arg)
{
    printf("thread 1 is starting\n");
    printf("thread 1 do something you want to do\n");
    printf("thread 1 exiting\n");

    pthread_barrier_wait(&barrier);
    pthread_exit((void*)0);
}

void* pthread_2(void *arg)
{
    printf("thread 2 is starting\n");
    printf("thread 2 do something you want to do\n");
    printf("thread 2 exiting\n");
    pthread_barrier_wait(&barrier);
    pthread_exit((void*)0);
}

void* pthread_3(void *arg)
{
    printf("thread 3 is starting\n");
    printf("thread 3 do something you want to do\n");
    printf("thread 3 exiting\n");
    pthread_barrier_wait(&barrier);
    pthread_exit((void*)0);
}

int main()
{
    pthread_t tid1,tid2,tid3;

    pthread_barrier_init(&barrier,NULL,4);
    printf("等待3个线程完成\n");

    int err;

    err = pthread_create(&tid1,NULL,pthread_1,NULL);
    if (err != 0)
    {
    printf("thread 1 create error\n");
    exit(0);
    }

    err = pthread_create(&tid2,NULL,pthread_2,NULL);
    if (err != 0)
    {
    printf("thread 2 create error\n");
    exit(0);
    }

    err = pthread_create(&tid3,NULL,pthread_3,NULL);
    if (err != 0)
    {
    printf("thread 3 create error\n");
    exit(0);
    }

    pthread_barrier_wait(&barrier);

    printf("3 个线程已全部结束,主线程准备结束(第四个线程)\n");
    return 0;
}

这里写图片描述

RGBMarco
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
APUE学习笔记 第三章 文件I/O
m0_38099899的博客
04-22 312
APUE学习笔记 第三章 文件I/O1、函数open和openat       调用open或openat函数可以打开或创建一个文件#include&lt;fcntl.h&gt; Int open(const char *path,into flag,…/*mode_t made*/); Int openat(int fd,const char* path,into flag,…/*mode_t ...
APUE学习笔记.xmind
04-03
APUE学习笔记.xmind
APUE第11章 线程
Escaping
02-23 148
10.1 引言 pthread 在前面的章节中讨论了进程，学习了UNIX进程的环境、进程间的 关系以及控制进程的不同方式。可以看到在相关的进程间可以存在一定 的共享。 本章将进一步深入理解进程，了解如何使用多个控制线程(或者简 单地说就是线程)在单进程环境中执行多个任务。一个进程中的所有线 程都可以访问该进程的组成部件，如文件描述符和内存。 不管在什么情况下，只要单个资...
APUE第三章学习笔记
RGBMarco的博客
08-13 318
shell 输入输出重定向 command > file 将输出重定向到file command < file 将输入重定向到file command >> file 将输出以追加的形式重定向到file n > file 将文件描述符n重定向到file n >> file 将文件描述符n以追加的形式重定向到file n >& m 将输出m和文件n合并 n <& m 将输入n和
APUE第十二章学习笔记
RGBMarco的博客
10-16 266
1.线程属性/***************************************** 包含头文件: #include <pthread.h> 函数原型: int pthread_attr_init(pthread_attr_t *attr); int pthread_attr_destroy(pthread_attr_t * attr); 函数说明:pthread_attr_ini
APUE第六章学习笔记
RGBMarco的博客
09-05 420
一:口令文件的操作/***************************************** struct passwd成员: struct passwd { char* pw_name; // 用户名 char* pw_passwd; //加密口令 uid_t pw_uid; //数值用户ID gid_t pw_gid; //
APUE第四章学习笔记
RGBMarco的博客
08-15 378
/**************************************************** 包含头文件: #include <sys/stat.h> 结构体 struct stat { mode_t st_mode; // 文件模式及类型 ino_t st_ino; //inode节点号 dev_t st_d
APUE第十四章.第十五章学习笔记
RGBMarco的博客
10-24 353
1.I/O多路转接 /********************************************* 包含头文件: #include <sys/select.h> 函数原型: int select(int maxfdpl,fd_set *restrict readfds, fd_set *restrict writefds,fd_set *restrict
APUE学习笔记（第十一章：线程）
askunix
12-19 321
1、每个线程在进行事件处理时可以采用同步编程模式，同步编程要比异步编程模式简单得多。 2、有人把多线程的程序设计与多处理器或多核系统联系起来。但是即使程序运行在单处理器上，也能得到多线程编程的模型的好处。 3、处理器的数量并不影响程序结构，所以不管处理器的个数多少，程序都可以通过使用线程得以简化。多线程程序在单处理器上运行还可以改善响应时间和吞吐量。 4、进程ID在系统中是惟一的，...
APUE学习笔记 第十一章 线程
m0_38099899的博客
04-26 123
第十一章 线程    本章将进一步深入理解进程，了解如何使用多个控制线程在单进程环境中执行多个任务。一个进程中的所有线程都可以访问该进程的组成部件，如文件描述符和内存。不管在什么情况下，只要单个资源需要在多个用户间共享，就必须处理一致性问题。本章最后将讨论目前可用的同步机制，防止多个线程在共享资源时出现不一致的问题。 参考：http://www.cnblogs.com/runnyu/p/46433...
Linux应用开发：APUE读书笔记+源码
04-08
压缩包内容包含了第三版APUE读书笔记以及相关训练源码，适用于初学UNIX环境（Linux）应用编程的工程师进行学习，能够帮助工程师更好的上手Linux环境下的应用开发。压缩包中还包含很多文中的示例以及相关笔记注释，...
学习《高级Linux环境编程》读书笔记(APUE读书笔记)
04-23
APUE读书笔记： 可以学习一下简化的APUE了，自己可以边看边学，很不错的笔记
APUE笔记之:进程环境详解
09-05
在深入探讨APUE中的进程环境之前，我们先理解一下什么是进程。进程是操作系统中的一个基本概念，它代表了程序在内存中的执行实例。每个进程都有自己的独立内存空间，包括正文段、堆、栈以及进程环境。 正文段包含了...
APUE中文第二版.zip
04-05
《Unix环境高级编程》(Advanced Programming in the UNIX Environment, 简称APUE) 是一本在IT领域中具有极高影响力的经典书籍，由Stephen R. Johnson撰写。这本书详细介绍了在UNIX系统上进行高级程序设计和系统级...
APUE Linux环境设置
RGBMarco的博客
08-06 672
今天终于收到了 APUE这本书，终于可以拿出我早早配好的Unbuntu出来大显身手(想想都有点小激动),好啦，下面来谈谈我是怎么做好第一个APUE里的实例的,首先你得是有个能支持的系统的，大部分linux应该可以，Mac好像也可以(反正我是没钱用),我用的是 Unbuntu 16.04LTS ，写程序当然是用vim了,虽然我下了Qt Creator，不过，听说大神都在用vim，想成为大神的我，哪有
APUE第九章笔记
RGBMarco的博客
09-21 638
1.进程组/********************************************************* 包含头文件: #include <unistd.h> 函数原型: pid_t getpgrp(void); 函数说明: 同一进程组中的各进程接收来自同一终端的各种信号,每个进程组有一个唯一的进程组ID. 返回值: 调用进程的进程组ID ***********
APUE第五章学习笔记
RGBMarco的博客
08-28 433
/***************************************** 包含头文件: #include <stdio.h> #include <wchar.h> 函数原型: int fwide(FILE *fp,int mode); 函数说明: 设置流的定向 注: 若mode为正值，则流试图被设置为宽定向,若mode是负值,则流试图被设置为字节
小白to大神 vim学习笔记
RGBMarco的博客
08-10 409
Vim文档编辑 一、实验介绍 1.1 实验内容上次实验带大家快速入门了Vim,本次实验将介绍更多文档编辑命令 1.2 实验知识点Vim重复命令 跳转命令 复制粘贴 二、实验步骤 2.1 vim重复命令 　2.1.1 重复执行上次命令在普通模式下.(小数点)表示重复上一次的命令操作拷贝测试文件到本地目录$ cp /etc/protocols .打开文件进行编辑$ vim protocols普
homebrew 安装apue
最新发布
10-07
您可以通过Homebrew在macOS上安装apue（Advanced Programming in the UNIX Environment）。以下是安装apue的步骤： 1. 打开终端。 2. 确保已经安装了Homebrew。如果没有安装，请在终端中运行以下命令进行安装： `/...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值