第一章 概述

Linux基础第一章 概述,linux第一章概述

linux第一章概述,Linux基础第七章。第一章 概述

前言

前边商量了经过,精通一个进度能做一件事情,假如想同时处理多件工作,那么需求八个进程,可是经过间很不便于的某些是,进度间的数据调换就如并未那么便民。Linux提供线程功效,能在一个进度中,处理多职务,而且线程之间的多寡是完全共享的。

线程也有PCB,它的PCB和进度的PCB结构完全一致,只是它其中保存的虚拟地址空间和开创它的历程的虚拟地址空间完全保持一致。

1.1 前言

本章切磋系统的定义,从硬件、操作系统角度更是长远的敞亮统计机种类,并快速浏览Linux系统提供的服务。

第一章 概述

1.1 前言

本章商量系统的定义,从硬件、操作系统角度更是深刻的领悟总结机体系,并快捷浏览Linux系统提供的劳务。

线程的创办

通过pthread_create函数可以创造一个线程,被创建的线程的例程,就是一个新的实践命令体系了。

#include <pthread.h>

void* thread_func(void* p )
{
    return NULL;
}

int main()
{
    pthread_t tid;

    pthread_create(&tid, NULL, thread_func, NULL);
    printf("tid=%d\n", (int)tid);
    pthread_create(&tid, NULL, thread_func, NULL);
    printf("tid=%d\n", (int)tid);
    pthread_create(&tid, NULL, thread_func, NULL);
    printf("tid=%d\n", (int)tid);
    pthread_create(&tid, NULL, thread_func, NULL);
    printf("tid=%d\n", (int)tid);

    getchar();
}

 

 

Compile and link with -lpthread.

 

补充
intptr_t是一种整型,它的尺寸信赖机器位长,也就意味着它的长短和指针的长度一样的。

1.2 系统组成

 澳门金沙国际 1

 

1.1 前言

本章钻探系统的定义,从硬件、操作系统角度更是深远的通晓总括机序列,并快速浏览Linux系统提供的劳动。

1.2 系统整合

 澳门金沙国际 2

 

 线程标识

线程使用pthread_t来标识线程,它也是一个非负整数,由系统分配,保障在经过范围内唯一。pthread_t就算在Linux下是非负整数,不过在任何平台下不肯定是,所以相比较线程号是或不是想等,应该用pthread_equal

其他一个函数都足以调用pthread_self来获取方今代码运行的线程。

1.3 操作系统和应用程序

操作系统那几个词语有二意性,有时候指内核,有时候指内核和系统工具软件的构成。

 

 澳门金沙国际 3

 

 

操作系统是管制系列硬件的软件。操作系统是一向运行在裸机之上。其余使用软件运行在操作系统之上。

操作系统本身提供操作接口,支持用户通过该接口来操作
系统,可是系统本身提供的功力,不足于达成用户须求时,则必要开支应用程序来拓展系统机能。

发行版:
不等的铺面利用Linux内核,加上自己开发的系统工具软件,一起发表的Linux操作系统版本。

1.2 系统整合

1.3 操作系统和应用程序

操作系统这些词语有二意性,有时候指内核,有时候指内核和种类工具软件的结缘。

 

 澳门金沙国际 4

 

 

操作系统是管理种类硬件的软件。操作系统是一向运行在裸机之上。其余应用软件运行在操作系统之上。

操作系统本身提供操作接口,援助用户通过该接口来操作
系统,不过系统自身提供的意义,不足于完结用户须要时,则须要开发应用程序来拓展系统机能。

发行版:
差其他商家选择Linux内核,加上自己费用的系统工具软件,一起发表的Linux操作系统版本。

线程终止

终止方式  
例程返回 正常退出
调用pthread_exit 正常退出
响应pthread_cancel 异常退出

注意:

  • 在线程里调用exit是退出整个经过。

  • 在三八线程的长河中,主线程调用pthread_exit,过程并不会脱离,它的其余线程依旧在推行,可是主线程已经淡出了。

  • 意味着:主线程和其余线程是大约是同样的。

  • 不平等的是,若是主线程的main函数return了,那么任何线程也停止了,要是别的线程的入口函数return了,主线程不会随着截止。

1.4 启动和登陆

澳门金沙国际 5

安插文件:
/etc/profile:系统启动时被实践
~/.bashrc:用户登陆时会调用

 澳门金沙国际 6  

1.4 启动和登陆

澳门金沙国际 7

配备文件:
/etc/profile:系统启动时被实施
~/.bashrc:用户登陆时会调用

线程的回收

线程退出之后,它的PCB如故在基本中留存,等着别样线程来获得它的运作结果,可以透过pthread_join来回收线程。从那几个角度看,线程和进度大约,可是跟进度不相同的时,线程没有父线程的概念,同一个历程内的其余线程都足以来回收它的运转结果。

pthread_join会卡住调用它的线程,一贯到被join的线程停止甘休。

pthread_joinwait/waitpid同一,也是阻塞的调用,它除了有回收PCB的职能,也有等待线程为止的职能。

1.5 文件

文本是一个重中之重的概念,一般定义为音讯的聚众。计算机做为音讯处理的机械,文件是电脑处理的目的。

在Unix和Linux系统中,泛化了文本的概念,设备也被架空成文件对象来展开操作。

数据的聚集叫做文件。
IT行业处理信息:转换,传输,存储

1.3 操作系统和应用程序

操作系统这个词语有二意性,有时候指内核,有时候指内核和系统工具软件的组合。

   澳门金沙国际 8    

操作系统是管制系列硬件的软件。操作系统是一贯运行在裸机之上。其他应用软件运行在操作系统之上。

操作系统本身提供操作接口,帮衬用户通过该接口来操作
系统,不过系统自身提供的意义,不足于完毕用户必要时,则要求成本应用程序来拓展系统功能。

发行版:
差距的店铺接纳Linux内核,加上自己开发的系统工具软件,一起发布的Linux操作系统版本。

1.5 文件

文件是一个首要的概念,一般定义为新闻的集结。总括机做为音信处理的机器,文件是计算机处理的靶子。

在Unix和Linux系统中,泛化了文件的定义,设备也被架空成文件对象来拓展操作。

数据的汇聚叫做文件。
IT行业处理音讯:转换,传输,存储

线程的选用景况

1.6 程序、进程

澳门金沙国际 9

1.4 启动和登陆

澳门金沙国际 10

布署文件:
/etc/profile:系统启动时被实践
~/.bashrc:用户登陆时会调用

1.6 程序、进程

澳门金沙国际 11

 客户端使用情况

相似的话,线程用于相比较复杂的多职务场景,比如:

 澳门金沙国际 12

如此那般主线程可以基础处理主线程的工作,不至于被复杂的职务阻塞。比如:

 

澳门金沙国际 13

这么聊天界面不会卡死在那里,否则一经互联网状态很差,有可能导致界面卡死。

1.7 错误处理

系统调用在貌似景况下重回整数,并且0表示成功,小于0代表战败。当系统调用重回失败时,可以透过errno得到错误嘛,通过strerror获取错误演讲,或者直接通过perror在规范错误文件中,输出错误新闻。

 

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main()
{
// 通过open重返的平头,在linux中有个特其余名字
// 叫文件讲述符 file description 简称fd

int fd = open(“a.txt”, O_WRONLY|O_CREAT|O_EXCL, 0777);
if(fd < 0)//表示文件打开失败
{
perror(“open”);
return 0;
}

// 把指针放到文件初阶
lseek(fd, 0, SEEK_SET);

// 对文件进行操作
write(fd, “hello”, 5);

// 关闭文件,要是不关门,内存会泄漏
// 当进度退出时,未关门的文书会活动关闭
close(fd);

}

1.5 文件

文件是一个关键的定义,一般定义为音讯的会晤。总括机做为音讯处理的机器,文件是计算机处理的对象。

在Unix和Linux系统中,泛化了文件的定义,设备也被架空成文件对象来进展操作。

数量的集纳叫做文件。
IT行业处理消息:转换,传输,存储

1.7 错误处理

系统调用在诚如处境下回来整数,并且0表示成功,小于0表示战败。当系统调用再次来到战败时,可以由此errno获得错误嘛,通过strerror获取错误演讲,或者直接通过perror在正式错误文件中,输出错误音讯。

 

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main()
{
// 通过open重临的平头,在linux中有个专门的名字
// 叫文件讲述符 file description 简称fd

int fd = open(“a.txt”, O_WRONLY|O_CREAT|O_EXCL, 0777);
if(fd < 0)//表示文件打开失利
{
perror(“open”);
return 0;
}

// 把指针放到文件初阶
lseek(fd, 0, SEEK_SET);

// 对文件进行操作
write(fd, “hello”, 5);

// 关闭文件,倘若不倒闭,内存会泄漏
// 当进度退出时,未关门的公文少禽活动关闭
close(fd);

}

服务器使用意况

服务器一般的流程如下:

 澳门金沙国际 14

在服务器上,一个线程来拍卖整个工艺流程,会造成处理流程分外慢,导致主线程不可能立时吸纳报文。一般会选取子线程来做具体的干活,而主线程只负责接收报文。

澳门金沙国际 15

有时为了坚实处理作用,会使用线程池

 

 

1.8 用户、组、文件权限

Linux是多用户系统,扶助多少个用户同时登陆系统。
为了安全起见,必要对系统的权杖加于规范。

1.6 程序、进程

1.8 用户、组、文件权限

Linux是多用户系统,帮忙七个用户同时登陆系统。
为了安全起见,须求对系统的权力加于规范。

7.7 线程的同步

不论是上述那种情景,都有一个报文队列或者新闻队列,一般那些行列是一个链表,主线程需求往链表中添加多少,而子线程从链表获取数据。八个线程同时操作一个全局变量是不安全的,应该防止不安全的访问。无论那种全局变量是数组、链表、仍旧一个概括的变量。

线程A:i = i + 1;
线程B:i = i + 1;

1.9 信号

信号是经过通讯的一种手段,某个进度收到信号,该信号可能源于内核、来自别的进度或者来自用户操作。例如:当用户按下ctrl+c时,其实是给前台进度发送了一个信号。

澳门金沙国际 16

1.9 信号

信号是经过通讯的一种手段,某个进程收到信号,该信号也许出自内核、来自其它进度或者来自用户操作。例如:当用户按下ctrl+c时,其实是给前台进度发送了一个信号。

7.7.1 不安全的案例

  • 多线程操作一个全局变量

#include <stdio.h>

#include <signal.h>

#include <pthread.h>

 

int result=0;

 

void add()

{

    int i;

    for(i=0; i<100000; ++i)

    {

        result++;

    }

}

 

void* thread_func(void* p)

{

    add();

    return NULL;

}

 

int main()

{

    pthread_t t1;

    pthread_t t2;

 

    pthread_create(&t1, NULL, thread_func, NULL);

    pthread_create(&t2, NULL, thread_func, NULL);

 

    pthread_join(t1, NULL);

    pthread_join(t2, NULL);

 

    printf(“%d\n”, result);

    return 0;

}

  • 不安全的生产者消费者模型

#include <list>

 

struct task_t

{

    int task;

};

 

list<task_t*> queue;

 

void* work_thread(void* arg)

{

    while(1)

    {

        if(queue.size() == 0) continue;

 

        task_t* task = *queue.begin();

        queue.pop_front();

 

        printf(“task value is %d\n”, task->task);

        delete task;

    }

}

 

void main(int argc, char* argv[])

{

    pthread_t tid;

    pthread_create(&tid, NULL, work_thread, NULL);

 

    while(1)

    {

        int i;

        cin >> i;

        task_t* task = new task_t;

        task->task = i;

 

        queue.push_back(task);

    }

 

    pthread_join(tid, NULL);

}

1.10 系统调用和库函数

上学Linux系统开发接口时,程序员也必要上学一般常用的第三方库,来开展程序员的编程能力。

 

澳门金沙国际 17

User Space和Kernel
Space是操作系统编程中常用的定义,表示近年来的代码在用户空间照旧基础空间运行,对于差别的运作空间,CPU对内存的处理格局稍有例外,在讲进度虚拟地址空间时再涉及该概念。

系统调用指操作系统内核提供的效益,它提供了接口给用户空间代码调用。比如open/read/write/close等,都是属于Linux系统操作接口,而fopen/fread/fwrite/fclose是属于C标准提供的接口,在Linux下,fopen其实底层调用了open。

配置文件:
/etc/profile:系统启动时被实践
~/.bashrc:用户登陆时会调用

1.7 错误处理

系统调用在相似情状下回到整数,并且0表示成功,小于0表示战败。当系统调用重返失利时,可以经过errno得到错误嘛,通过strerror获取错误解说,或者直接通过perror在正规错误文件中,输出错误音信。

 

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main()
{
// 通过open重返的整数,在linux中有个专门的名字
// 叫文件讲述符 file description 简称fd

int fd = open(“a.txt”, O_WRONLY|O_CREAT|O_EXCL, 0777);
if(fd < 0)//表示文件打开战败
{
perror(“open”);
return 0;
}

// 把指针放到文件开首
lseek(fd, 0, SEEK_SET);

// 对文本进行操作
write(fd, “hello”, 5);

// 关闭文件,如果不停歇,内存会泄漏
// 当进度退出时,未关门的文件会活动关闭
close(fd);

}

1.10 系统调用和库函数

学习Linux系统开发接口时,程序员也急需上学一般常用的第三方库,来举行程序员的编程能力。

 

澳门金沙国际 18

User Space和Kernel
Space是操作系统编程中常用的定义,表示近年来的代码在用户空间如故基本空间运行,对于不一致的周转空间,CPU对内存的处理格局稍有两样,在讲进度虚拟地址空间时再涉及该概念。

系统调用指操作系统内核提供的成效,它提供了接口给用户空间代码调用。比如open/read/write/close等,都是属于Linux系统操作接口,而fopen/fread/fwrite/fclose是属于C标准提供的接口,在Linux下,fopen其实底层调用了open。

配置文件:
/etc/profile:系统启动时被实施
~/.bashrc:用户登陆时会调用

7.7.2 锁(临界量)

锁能幸免五个线程同时做客一个全局变量。
锁会拉动多个难题:

  • 效率低

  • 死锁

    #include <stdio.h>
    #include <pthread.h>
    
    int result = 0;
    // 定义锁,锁一般也定义在全局
    //pthread_mutex_t mutex;  // 粗粒度的锁
    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
    
    int result1 = 0;
    pthread_mutex_t mutex1;
    
    // 1.一个线程重复加锁两次,会死锁
    void func()
    {
        pthread_mutex_lock(&mutex);
    
        pthread_mutex_unlock(&mutex);
    }
    
    void foo()
    {
        pthread_mutex_lock(&mutex);
        func();
        pthread_mutex_unlock(&mutex);
    }
    
    // 2. 一个线程加锁之后,忘记了解锁
    void foo1()
    {
    
        pthread_mutex_lock(&mutex);
        if(...) // 这种场合容易产生忘记解锁
            return;
        // ....
        // 忘记了解锁
        pthread_mutex_unlock(&mutex);
    }
    
    void foo2()
    {
        // 因为别的线程忘记解锁,所以本线程无法进行加锁
        pthread_mutex_lock(&mutex); // 阻塞在这里
        pthread_mutex_unlock(&mutex);
    }
    
    void* thread_func(void* ptr)
    {
        foo();
    
        int i=0;
        for(i=0; i<100000; ++i)
        {
            pthread_mutex_lock(&mutex1);
            result1++;//它的值由什么决定
            pthread_mutex_unlock(&mutex1);
    
            // 两个线程同时操作全局变量,结果不可靠
            //
            // 将该操作变成原子操作,或者至少不应该被能影响它操作的人打断
            pthread_mutex_lock(&mutex);
            result ++;  // result++代码被锁保护了,不会被其他线程的result++影响
            pthread_mutex_unlock(&mutex);
        }
        return NULL;
    }
    
    int main()
    {
        // 使用锁之前,要对它进行初始化
    //    pthread_mutex_init(&mutex, NULL);
        pthread_mutex_init(&mutex1, NULL);
    
        pthread_t t1, t2;
        pthread_create(&t1, NULL, thread_func, NULL);
        pthread_create(&t2, NULL, thread_func, NULL);
    
        pthread_join(t1, NULL);
        pthread_join(t2, NULL);
    
        printf("result is %d\n", result);
    }
    
    #include <stdio.h>
    #include <list>
    #include <iostream>
    using namespace std;
    
    struct task_t
    {
        int task;
    };
    
    // 全局的任务队列
    list<task_t*> tasks;
    pthread_mutex_t mutex;
    pthread_cond_t cond;
    
    // pthred_cond_signal和pthread_cond_wait类似不可靠信号,signal不会累计
    // 当一个线程发送signal时,如果另外一个线程此时没有调用wait函数,那么这个signal就会消失掉

    void* work_thread(void* ptr)
    {
        while(1)
        {
            // 等待条件
            pthread_mutex_lock(&mutex);
            pthread_cond_wait(&cond, &mutex);
            pthread_mutex_unlock(&mutex);

            // 一旦条件满足,就应该处理队列中所有的任务
            while(1)
            {
                pthread_mutex_lock(&mutex);
                if(tasks.size() == 0) 
                {
                    pthread_mutex_unlock(&mutex); // 特别容易忘记解锁
                    break;
                }
                task_t* task = *tasks.begin();
                tasks.pop_front();
                pthread_mutex_unlock(&mutex);

                // 处理任务
                printf("current task is %d\n", task->task);

                // new和delete(malloc和free)都是线程安全的
                delete task;
            }
        }
    }

    int main()
    {
        pthread_mutex_init(&mutex, NULL);
        pthread_cond_init(&cond, NULL);

        pthread_t tid;
        pthread_create(&tid, NULL, work_thread, NULL);

        while(1)
        {
            int i;
            // 阻塞的,等待任务
            cin >> i;

            // 构造任务结构体
            task_t* task = new task_t;
            task->task = i;

            // 把任务丢到任务列表中
            pthread_mutex_lock(&mutex);
            tasks.push_back(task);
            pthread_mutex_unlock(&mutex);

            // 唤醒条件变量
            pthread_cond_signal(&cond);
        }
    }

    //运用析构函数

    #ifndef __AUTO_LOCK_H__
    #define __AUTO_LOCK_H__

    #include <pthread.h>

    class auto_lock
    {
    public:
        auto_lock(pthread_mutex_t& m);
        ~auto_lock();
    private:
        pthread_mutex_t& mutex;
    };

    #endif



    #include "auto_lock.h"

    auto_lock::auto_lock(pthread_mutex_t& m): mutex(m)
    {
        pthread_mutex_lock(&mutex);
    }

    auto_lock::~auto_lock()
    {
        pthread_mutex_unlock(&mutex);
    }



    #include <stdio.h>
    #include "auto_lock.h"

    pthread_mutex_t mutex;
    int result = 0;

    void* thread_func(void*ptr)
    {
        for(int i=0 ;i<100000; ++i)
        {
            auto_lock var1(mutex); // 重复加锁
            auto_lock var(mutex); // 在构造里自动加锁
            result++;
        }
    }

    int main()
    {
        // 变成递归锁   及循环锁  
        pthread_mutexattr_t attr;//设计循环锁属性
        pthread_mutexattr_init(&attr);
        pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); 

        // 用递归属性去初始化这个锁
        pthread_mutex_init(&mutex, &attr);

        pthread_t tid1, tid2;
        pthread_create(&tid1, NULL, thread_func, NULL);
        pthread_create(&tid2, NULL, thread_func, NULL);

        pthread_join(tid1, NULL);
        pthread_join(tid2, NULL);

        printf("result is %d\n", result);
    }

 

争执的解决方法:

  • 读写锁

  • #include

    pthread_rwlock_t mutex;
    int result;
    
    void* thread_func(void* ptr)
    {
        pthread_rwlock_rdlock(&mutex);
        // 只能对数据读
        result ++; // 写数据的行为是会导致数据不正确
        pthread_rwlock_unlock(&mutex);
    
        pthread_rwlock_wrlock(&mutex);
        // 可以对数据读写
        pthread_rwlock_unlock(&mutex);
    }
    
    int main()
    {
    
        pthread_rwlock_init(&mutex, NULL);
    
        pthread_t tid;
        pthread_create(&tid, NULL, thread_func, NULL);
    }
    

     

  • 循环锁

文本操作

头文件:sys/types.h  sys/stat.h
 fcntl.h  例:int fd=open(“文件路径”,mode);
 mode决定了对文件的操作方法
  第多少个参数可有可无,对文本权限进行拍卖,   因umask存在,创立文件权限要与上000 000 010的反,导致用户权限初始不可以有写的权位

mode选项

解释

O_RDONLY

读方式打开(与后面俩个互斥)

O_WRONLY

写方式打开

O_RDWR

读写方式打开

O_CREAT

创建文件,如果文件存在,直接打开

O_TRUNC

截断

O_APPEND

追加

O_EXCL

和O_CREAT一起用,如果文件存在则失败

1.8 用户、组、文件权限

Linux是多用户系统,帮助几个用户同时登陆系统。
为了安全起见,要求对系统的权杖加于规范。

文本操作

头文件:sys/types.h  sys/stat.h
 fcntl.h  例:int fd=open(“文件路径”,mode);
 mode决定了对文件的操作方法
  第多个参数可有可无,对文本权限进行处理,   因umask存在,创立文件权限要与上000 000 010的反,导致用户权限伊始不可能有写的权位

mode选项

解释

O_RDONLY

读方式打开(与后面俩个互斥)

O_WRONLY

写方式打开

O_RDWR

读写方式打开

O_CREAT

创建文件,如果文件存在,直接打开

O_TRUNC

截断

O_APPEND

追加

O_EXCL

和O_CREAT一起用,如果文件存在则失败

7.7.2.1 基本锁

类型:pthread_mutex_t
概念的变量一般在全局:pthread_mutex_t g_mutex;
在采用以前要初步化:pthread_mutex_init(&g_mutex, NULL);
访问敏感目的前加锁:pthread_mutex_lock(&g_mutex);
做客为止要解锁:pthread_mutex_unlock(&g_mutex);

一把所可以负担八个全局变量的安全难点,可是担负的限定越大,功能越低,代码相对不难写。负责全局变量的数据,被称之为锁的粒度。

死锁难题

  1. 忘了然锁会暴发死锁

  2. 双重加锁会促成死锁

怎么化解死锁难点:

  1. 忘驾驭锁:程序员自己要留意

  2. 重复加锁:使用循环锁可以解决难点

函数:

perror:对某种错误新闻进行打印

open/creat:打开文件/成立文件
read:读文件
write:写文件
close:关闭文件
lseek:定位文件读写地方
fcntl:修改文件属性
sysconf:读取系统布局
dup/dup2:复制文件讲述符
sync/fsync/fsyncdata:同步文件数量
mmap/munmap:文件映射
mkstemp:得到临时文件路径

1.9 信号

信号是进度通信的一种手段,某个进度收到信号,该信号也许来自内核、来自其余进程或者来自用户操作。例如:当用户按下ctrl+c时,其实是给前台进度发送了一个信号。

函数:

perror:对某种错误音信举行打印

open/creat:打开文件/创设文件
read:读文件
write:写文件
close:关闭文件
lseek:定位文件读写地点
fcntl:修改文件属性
sysconf:读取系统安顿
dup/dup2:复制文件讲述符
sync/fsync/fsyncdata:同步文件数量
mmap/munmap:文件映射
mkstemp:得到临时文件路径

7.7.2.2 循环锁

不留余地重复加锁导致死锁难点,循环锁的特性是,同一个线程举办频繁加锁,不会堵塞。
pthread_mutex_lock(&mutex);
pthread_mutex_lock(&mutex); //
第二次加锁不会堵塞,不过它会给mutex增添一个计数。
pthread_mutex_unlock(&mutex) // 减少计数
pthread_mutex_unlock(&mutex);//减少到0的时候,真正解锁

怎么设置循环锁。

     pthread_mutexattr_t attr;

     // 设置成循环锁属性

     pthread_mutexattr_init(&attr);

     pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);

澳门金沙国际 , 

     // 此时mutex是一个循环锁

     pthread_mutex_init(&mutex, &attr);

 

//头文件
#ifndef __AUTO_LOCK_H__
#define __AUTO_LOCK_H__

#include <pthread.h>

class auto_lock
{
public:
auto_lock(pthread_mutex_t& m);
~auto_lock();
private:
pthread_mutex_t& mutex;
};

#endif

//头文件的完成

#include “auto_lock.h”

auto_lock::auto_lock(pthread_mutex_t& m): mutex(m)
{
pthread_mutex_lock(&mutex);
}

auto_lock::~auto_lock()
{
pthread_mutex_unlock(&mutex);
}

//主函数
#include <stdio.h>
#include "auto_lock.h"

pthread_mutex_t mutex;
int result = 0;

void* thread_func(void*ptr)
{
    for(int i=0 ;i<100000; ++i)
    {
        auto_lock var1(mutex); // 重复加锁
        auto_lock var(mutex); // 在构造里自动加锁
        result++;
    }
}

int main()
{
    // 变成递归锁
    pthread_mutexattr_t attr;
    pthread_mutexattr_init(&attr);
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); 

    // 用递归属性去初始化这个锁
    pthread_mutex_init(&mutex, &attr);

    pthread_t tid1, tid2;
    pthread_create(&tid1, NULL, thread_func, NULL);
    pthread_create(&tid2, NULL, thread_func, NULL);

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);

    printf("result is %d\n", result);
}

 

命令

touch:修改文件的拜会时间,成立文件
cat:访问文件内容
vim:编辑
ulimit:展现一些限量音信(文件讲述符最大值、栈的上空尺寸)
umask:文件创造的权位掩码
getconf:对应sysconf

dd:能够拷贝块设备,可是要sudo权限  例  dd if=地点 of=文件名  bs=三次多少k cout=拷贝次数

Wc:计算文件的行数  单词个数
字节数

unlink:删除软链接

 

1.10 系统调用和库函数

读书Linux系统开发接口时,程序员也须要上学一般常用的第三方库,来开展程序员的编程能力。

  澳门金沙国际 19

User Space和Kernel
Space是操作系统编程中常用的定义,表示近日的代码在用户空间照旧基础空间运行,对于不相同的运转空间,CPU对内存的处理形式稍有例外,在讲进度虚拟地址空间时再涉及该概念。

系统调用指操作系统内核提供的法力,它提供了接口给用户空间代码调用。比如open/read/write/close等,都是属于Linux系统操作接口,而fopen/fread/fwrite/fclose是属于C标准提供的接口,在Linux下,fopen其实底层调用了open。

配置文件:
/etc/profile:系统启动时被实施
~/.bashrc:用户登陆时会调用

命令

touch:修改文件的走访时间,创制文件
cat:访问文件内容
vim:编辑
ulimit:显示一些限制新闻(文件讲述符最大值、栈的半空中尺寸)
umask:文件成立的权位掩码
getconf:对应sysconf

dd:可以拷贝块设备,然而要sudo权限  例  dd if=地方 of=文件名  bs=三次多少k cout=拷贝次数

Wc:计算文件的行数  单词个数
字节数

unlink:删除软链接

 

7.7.2.3 读共享写排他锁(读写锁)

共享锁/排他锁
定义锁:pthread_rwlock_t mutex;
初始化:pthread_rwlock_init(&mutex, NULL);
读锁定:pthread_rwlock_rdlock(&mutex);
写锁定:pthread_rwlock_wrlock(&mutex);
解锁:pthread_rwlock_unlock(&mutex);

信号

是决定进度通讯的一种格局,功用高,费用低

信号处理格局:掩盖、忽略、默许处理

掩码:延迟信号的处理  运用信号集合   

蒙面不可依赖信号,多次殡葬,只处理三次  掩盖:可信信号  处理数次

进程

fork()创建

文件操作

头文件:sys/types.h  sys/stat.h  fcntl.h  例:int
fd=open(“文件路径”,mode);  mode决定了对文本的操作方法
  第八个参数可有可无,对文件权限进行处理,
  因umask存在,创立文件权限要与上000 000
010的反,导致用户权限起先无法有写的权位

mode选项

解释

O_RDONLY

读方式打开(与后面俩个互斥)

O_WRONLY

写方式打开

O_RDWR

读写方式打开

O_CREAT

创建文件,如果文件存在,直接打开

O_TRUNC

截断

O_APPEND

追加

O_EXCL

和O_CREAT一起用,如果文件存在则失败

信号

是控制进程通信的一种方法,效能高,花费低

信号处理格局:掩盖、忽略、默许处理

掩码:延迟信号的拍卖  运用信号集合   

覆盖不可靠信号,很多次发送,只处理一遍  掩盖:可靠信号  处理很多次

进程

fork()创建

7.7.2.4 总结

  1. 无论怎么着锁,都会造成品质下落,所以能不用就硬着头皮不用

  2. 锁能仍然不能用来进度间一块?可以

线程

鼠标键盘都是只读的字符文件夹设备,所以可以利用函数举办监督
 一般在/dev/input/mic 文件上面  注意权限问题 鼠标键盘读取数据,是俩个进度,注意进度的不通问题 可以行使字进度和父进度进行处理

函数:

perror:对某种错误新闻举办打印

open/creat:打开文件/创制文件
read:读文件
write:写文件
close:关闭文件
lseek:定位文件读写地点
fcntl:修改文件属性
sysconf:读取系统安顿
dup/dup2:复制文件讲述符
sync/fsync/fsyncdata:同步文件数量
mmap/munmap:文件映射
mkstemp:得到临时文件路径

线程

鼠标键盘都是只读的字符文件夹设备,所以可以利用函数进行督察
 一般在/dev/input/mic 文件上面  注意权限难题 鼠标键盘读取数据,是俩个进度,注意进度的堵塞问题 可以行使字进度和父进度举行拍卖

 C++使用构造函数和析构函数自动加锁解锁

线程的成立 

 pthread_created(1,2,3,4)
//1:线程的id  2:线程的的特性  3:新线程的函数名字, 4:新线程的属性    要链接  -lpthread  库   

留意子线程是专属主线程的,主线程截至,子线程不能运转    
那些 pthread_exit(0)主线程甘休,子线程没有退出例外

 

运用pthread_equal  判断线程是还是不是等于,先等重返0  不对等重返非零值

pthread_jion(1,&ret)  阻塞调用 1:线程id  ret:线程再次回到值

 

pthread_t tid = pthread_self()  得到当前运行进程的id

命令

touch:修改文件的访问时间,创设文件
cat:访问文件内容
vim:编辑
ulimit:呈现一些限制新闻(文件讲述符最大值、栈的空中尺寸)
umask:文件创造的权力掩码
getconf:对应sysconf

dd:可以拷贝块设备,不过要sudo权限  例  dd if=地点 of=文件名
 bs=四次多少k cout=拷贝次数

Wc:总计文件的行数  单词个数 字节数

unlink:删除软链接

 

线程的创立 

 pthread_created(1,2,3,4)
//1:线程的id  2:线程的的品质  3:新线程的函数名字, 4:新线程的性质    要链接  -lpthread  库   

专注子线程是隶属主线程的,主线程截止,子线程无法运行    
那几个 pthread_exit(0)主线程甘休,子线程没有脱离例外

 

运用pthread_equal  判断线程是否等于,先等重返0  不对等重回非零值

pthread_jion(1,&ret)  阻塞调用 1:线程id  ret:线程再次来到值

 

pthread_t tid = pthread_self()  得到当前运作进程的id

7.7.3 条件变量

原则变量是别的一种共同机制,它可以使线程在无竞争的等待条件发出。在后面讲到的线程场景里,子线程往往要等到队列有数据才运行,否则它应当休眠,以避免浪费CPU。可是只要用锁来完毕那种体制以来,会极度费力。

定义:pthread_cond_t g_cond;
初始化:pthread_cond_init(&g_cond);
等待:pthread_cond_wait(&g_cond, &g_mutex);
唤醒:pthread_cond_signal(&g_cond);
pthread_cond_broadcast(&g_cond);
惊群

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

pthread_mutex_t mutex;
pthread_cond_t cond;

void* thread_func(void* ptr)
{
    sleep(1);

    pthread_mutex_lock(&mutex);
    pthread_cond_wait(&cond, &mutex);
    pthread_mutex_unlock(&mutex);

    printf("wait ok\n");
}

int main()
{
    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&cond, NULL);

    pthread_t tid;
    pthread_create(&tid, NULL, thread_func, NULL);

    // 发信号时,线程不是正在调用pthread_cond_wait,而是在执行sleep(1),所以signal发送之后,就消失了,不会保留
    // 按照刚才的说法,这个signal根本无效
    // 所以当一个线程发送多次的signal时,那么最多只有一次是有作用的
    pthread_cond_signal(&cond);

    pthread_join(tid, NULL);

}

 

进度和线程的界别:

进程:分配资源的单位  线程:调度的单位     多线程可以共享全局变量

信号

是控制进程通讯的一种方法,成效高,开销低

信号处理格局:掩盖、忽略、默许处理

掩码:延迟信号的拍卖  运用信号集合   

覆盖不可靠信号,数十次发送,只处理一次   掩盖:可相信信号  处理多次

进程

fork()创建

进程和线程的分别:

进度:分配资源的单位  线程:调度的单位     多线程可以共享全局变量

7.7.3.1 条件变量的等候和提示

假定没无线程在等候条件,此时唤醒函数pthread_cond_signal不会提醒任何的线程,也不会记录。

万一有七个线程在履行pthread_cond_wait,而此刻有一个线程调用pthread_cond_signal,那么只会唤起其中一个线程。

要是想唤起所有线程,那么调用pthread_cond_broadcast,该函数可以唤起等待该条件的装有线程。

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

// 假如有三个线程同时调用pthread_cond_wait,一个线程调用pthread_cond_signal
//
pthread_mutex_t mutex;
pthread_cond_t cond;

void* thread_func(void* ptr)
{

    pthread_mutex_lock(&mutex);
    pthread_cond_wait(&cond, &mutex);
    pthread_mutex_unlock(&mutex);

    printf("wait ok\n");
}

int main()
{
    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&cond, NULL);

    pthread_t tid1, tid2, tid3;
    pthread_create(&tid1, NULL, thread_func, NULL);
    pthread_create(&tid2, NULL, thread_func, NULL);
    pthread_create(&tid3, NULL, thread_func, NULL);

    sleep(1);
    // 唤醒一个线程
//    pthread_cond_signal(&cond);
//    唤醒所有正在等待的线程
    pthread_cond_broadcast(&cond);

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    pthread_join(tid3, NULL);

}

 

幸免俩个线程同时操作全局变量,第二个线程运用了锁,后边的线程在外面等,等待解锁后,前面的线程在进入

线程

鼠标键盘都是只读的字符文件夹设备,所以可以采纳函数举办监察
 一般在/dev/input/mic 文件上边  注意权限问题 鼠标键盘读取数据,是俩个经过,注意进度的鸿沟问题 能够动用字进度和父进度进行处理

幸免俩个线程同时操作全局变量,第三个线程运用了锁,前面的线程在外场等,等待解锁后,前面的线程在进入

7.7.4 信号量

信号量类似条件变量,然而信号量能够保留信号数量。

  • 定义: sem_t sem;

  • 初始化:sem_init(&sem, 0, 0);
    伊始化的首个参数,如若是0表示一致进度内的十六线程之间的信号量,假诺是非0,那么该信号量可以运用在进程之间。第二个参数表示信号量的初叶值。

  • 等待:sem_wait(&sem);
    sem_wait函数会造成该线程休眠,唤醒的尺码是sem的值大于0。并且sem_wait调用截止后,会自动将sem值减1。

  • 唤醒:sem_post(&sem);
    sem_post只是粗略的将sem值+1

    #include <stdio.h>
    #include <semaphore.h>
    #include <pthread.h>
    
    sem_t sem;
    
    void* thread_func(void* ptr)
    {
        sleep(1);
        sem_wait(&sem);
        printf("wait ok\n");
    }
    
    int main()
    {
        sem_init(&sem, 0, 0);
    
        pthread_t tid1, tid2, tid3;
        pthread_create(&tid1, NULL, thread_func, NULL);
        pthread_create(&tid2, NULL, thread_func, NULL);
        pthread_create(&tid3, NULL, thread_func, NULL);
    
        // 发送信号
        sem_post(&sem);
    
        pthread_join(tid1, NULL);
        pthread_join(tid2, NULL);
        pthread_join(tid3, NULL);
    }
    

     

死锁

连日俩次加锁,加锁后,没有解锁,又持续加锁,会导致死锁。
运用循环锁,能够再一次加锁   通过定义锁的特性,变为循环锁
 例:pthread_mutexattr_t attr;  pthread_mutexattr_init(&attr);
 pthread_mutexattr_settype(&attr,
PTHREAD_MUTEX_RECURSIVE);pthread_mutex_init(&mutex,&attr)

加锁后,忘记解锁,也会并发死锁
 C++中行使析构函数,可以防止忘记解锁,定义一个类

 

线程的开创 

 pthread_created(1,2,3,4) //1:线程的id  2:线程的的特性
 3:新线程的函数名字, 4:新线程的属性    要链接  -lpthread  库   

只顾子线程是专属主线程的,主线程为止,子线程不可能运转    
那一个 pthread_exit(0)主线程为止,子线程没有退出例外

 

运用pthread_equal  判断线程是或不是等于,先等再次回到0  不对等重回非零值

pthread_jion(1,&ret)  阻塞调用 1:线程id  ret:线程重回值

 

pthread_t tid = pthread_self()  得到当前运作进度的id

死锁

连年俩次加锁,加锁后,没有解锁,又延续加锁,会造成死锁。
运用循环锁,可以再次加锁   通过定义锁的属性,变为循环锁
 例:pthread_mutexattr_t attr;  pthread_mutexattr_init(&attr);
 pthread_mutexattr_settype(&attr,
PTHREAD_MUTEX_RECURSIVE);pthread_mutex_init(&mutex,&attr)

加锁后,忘记解锁,也会现身死锁
 C++中运用析构函数,可以避免忘记解锁,定义一个类

 

7.8 重入

一经函数操作了全局变量,那些函数就不是可重入的函数了。

#include <stdio.h>
#include <pthread.h>
#include <string.h>
int result = 0;
void foo()
{
    // 因为这个函数操作了全局变量
    result ++;
}

void* thread_func(void* ptr)
{
#if 0
    int i;
    for(i=0; i<10000; ++i)
    {
        // 该函数是不可重入的函数
        // 用锁来保护它
        foo();
    }
#endif

    char p[] = "1 2 3 4 5 6 7 8 9 0";

    char* saveptr;
    char* sub = strtok_r(p, " ", &saveptr);
    while(sub)
    {
        usleep(1000); // 1毫秒        
        printf("%s, tid=%d\n", sub, (int)pthread_self());
        sub = strtok_r(NULL, " ", &saveptr);
    }

}

int main()
{
    pthread_t tid1, tid2;
    pthread_create(&tid1, NULL, thread_func, NULL);
    pthread_create(&tid2, NULL, thread_func, NULL);

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    printf("result=%d\n", result);
}

 

读写锁

pthread_rwlock_t mutex;

pthread_rwlock_init(&mutex, NULL);

读/写锁定pthread_rwlock_rd/wrlock(&mutex);

解锁:pthread_rwlock_unlock(&mutex);

进程和线程的界别:

经过:分配资源的单位  线程:调度的单位     二十四线程可以共享全局变量

读写锁

pthread_rwlock_t mutex;

pthread_rwlock_init(&mutex, NULL);

读/写锁定pthread_rwlock_rd/wrlock(&mutex);

解锁:pthread_rwlock_unlock(&mutex);

7.9 分离的线程

离其余线程不用pthread_join,也不知道该如何做通过pthread_join来获得结果。因为它运行截至之后,它的PCB同时被放飞了。

#include <errno.h>
#include <stdio.h>
#include <pthread.h>
#include <inttypes.h>

// intptr_t 整数类型:char short int long (long long)
//     整数:8 16 32 64
//     有些机器的int是32位,有的机器是64位
//     void*指针类型都是按照机器的字长决定
//
//     intptr_t是一个整数,并且它总是和指针的字节数是一样的

void* thread_func(void* ptr)
{
    // 用的是地址本身,而不是地址指向的值
    printf("%d\n", (int)(intptr_t)ptr);
    sleep(1);
}

int foo()
{
    char p[] = "hello world";
    int a = 100;

    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

    pthread_t tid;
    pthread_create(&tid, &attr, thread_func, (void*)(intptr_t)a);

    // 该线程自生自灭
    // pthread_detach(tid);

    int ret = pthread_join(tid, NULL);
    printf("join error, ret=%d, errno=%d, EINVAL=%d\n", ret, errno, EINVAL);
}

int main()
{
    foo();
    sleep(2);
}

 

 

幸免俩个线程同时操作全局变量,第三个线程运用了锁,后边的线程在外面等,等待解锁后,前面的线程在进入

 

7.10 线程私有数量

线程能够定义私有数据,私有数据只供该线程使用。
线程私有数据足以在该线程调用函数中访问,其他线程调用的函数中,不可访问。

// 定义线程私有数量的key,是在线程设置和行使个人数据从前成立

pthread_key_t key;

pthread_key_create(&key, 用来清理私有数量的函数指针);

 

// 设置私有数量,该函数被那些线程调用,那么就是安装该线程私有多少

pthread_set_specific(key, data);

void* data = pthread_get_specific(key);

 

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

pthread_key_t key;

// 可能被线程A调用
// 也可能线程B调用
void foo()
{
    char* p = (char*)pthread_getspecific(key);
    printf("%s\n", p);
}

void my_malloc()
{
    // 去这个线程的内存池去申请内存
    void* mempool = pthread_getspecific(key);
  //  __my_malloc(mempool, ...);
}

void* thread_func(void* ptr)
{
    // setspecific,需要在线程中调用,当然也可以在主线程中调用
    // 为这个线程设置私有数据
    pthread_setspecific(key, ptr);

    foo();
    my_malloc();
    return NULL;
}

void free_func(void* ptr)
{
    printf("free call\n");
    free(ptr);
}

int main()
{
    pthread_key_create(&key, free_func);

    pthread_t tid1, tid2;
    pthread_create(&tid1, NULL, thread_func, strdup("thread1"));
    pthread_create(&tid2, NULL, thread_func, strdup("thread2"));

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);

}

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

// 线程本地变量,每个线程都有一份拷贝
thread_local int result = 0;

void foo()
{
    // 全局变量
    thread_local static int a = 0;
    a++;
    printf("%d\n", a);
}



void* thread_func1(void* ptr)
{
    foo();
    foo();
    result = 100;
}

void* thread_func2(void* ptr)
{
    foo();
    foo();

    sleep(1);
//    printf("%d\n", result); // 100
    printf("%d\n", result); // thread_local时,这个值是0
}

int main()
{
    pthread_t tid1, tid2;
    pthread_create(&tid1, NULL, thread_func1, NULL);
    pthread_create(&tid2, NULL, thread_func2, NULL);

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
}

 

看护进程

医护进度不和极端关联,注意此进程只好有一个,创立文件记录,判断此程序是或不是打开

死锁

延续俩次加锁,加锁后,没有解锁,又再而三加锁,会招致死锁。
运用循环锁,可以重复加锁   通过定义锁的属性,变为循环锁
 例:pthread_mutexattr_t attr;  pthread_mutexattr_init(&attr);
 pthread_mutexattr_settype(&attr,
PTHREAD_MUTEX_RECURSIVE);pthread_mutex_init(&mutex,&attr)

加锁后,忘记解锁,也相会世死锁
 C++中选用析构函数,可以幸免忘记解锁,定义一个类

 

看护进度

医护进度不和极端关联,注意此进程只好有一个,成立文件记录,判断此程序是或不是开启

7.11 线程裁撤

废除线程也终结线程,可是相应幸免那种设计。

退出点函数:man pthreads搜索cancel关键字,找到那一个退出点函数。

pthread_cancel在线程外部(其他线程)来退出其它一个线程A,当线程A调用了cancelpoint函数时,会脱离。

要是指望调用cancelpoint函数不脱离,应该设置当前的线程状态为:不理睬线程退出(cancelability
disabled)
pthread_setcancelstate(…)

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

void* thread_func(void* ptr)
{
    // 因为这个线程没有cancel point
    while(1)
    {
        // 关闭cancel检测
        pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);

        sleep(10);

        // 打开cancel检测
        pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);

        // 检查cancel point
        pthread_testcancel(); 
    }
    return NULL;
}

int main()
{
    pthread_t tid;
    pthread_create(&tid, NULL, thread_func, NULL);

    // 让线程退出
    pthread_cancel(tid);

    // 等待线程退出
    pthread_join(tid, NULL);
}

 

编程规则:

设umask=0;

调用fork,让父进度退出。    让父进程变为init,  若是父进度不脱离,用俩次fork()

调用setuid创设新会话  setsid

重设当前目录/根目录     chdir        

关闭不必要的文件讲述符    运用循环关闭所有文件讲述符

读写锁

pthread_rwlock_t mutex;

pthread_rwlock_init(&mutex, NULL);

读/写锁定pthread_rwlock_rd/wrlock(&mutex);

解锁:pthread_rwlock_unlock(&mutex);

编程规则:

设umask=0;

调用fork,让父进度退出。    让父进程变为init,  假设父进度不脱离,用俩次fork()

调用setuid创造新会话  setsid

重设当前目录/根目录     chdir        

关闭不要求的文件讲述符    运用循环关闭所有文件讲述符

高级IO

一个历程就是一段指令

 

高级IO

一个进程就是一段指令

IO复用技术

医护进度

看护进度不和极端关联,注意此进度只好有一个,成立文件记录,判断此程序是或不是开启

IO复用技术

select的运用

动用文件讲述符集合  运用fd_set创设文件讲述符集合
 文件接口相对较小,跨平台利用

FD_SET(1,2)
将文件讲述符放入文件讲述符集合  1:文件讲述符  2:集合名字

编程规则:

设umask=0;

调用fork,让父进度退出。    让父进度变为init,
 要是父进度不脱离,用俩次fork()

调用setuid创制新会话  setsid

重设当前目录/根目录     chdir        

关闭不要求的文件讲述符    运用循环关闭所有文件讲述符

select的运用

采取文件讲述符集合  运用fd_set创制文件讲述符集合
 文件接口相对较小,跨平台选择

FD_SET(1,2)
将文件讲述符放入文件讲述符集合  1:文件讲述符  2:集合名字

epoll的运用

epollfd  创造文件讲述符集合

epol_ctl将文件讲述参预集合中

高级IO

一个历程就是一段指令

epoll的运用

epollfd  创立文件讲述符集合

epol_ctl将文件讲述参加集合中

非阻塞IO

 

IO复用技术

非阻塞IO

 

管道

一边读,一边写

select的运用

行使文件讲述符集合  运用fd_set创设文件讲述符集合
 文件接口相对较小,跨平台应用

FD_SET(1,2) 将文件讲述符放入文件讲述符集合  1:文件讲述符
 2:集合名字

管道

一边读,一边写

匿名管道  pipe()创制管道

 

 

mmap  可以完成有亲子关系进度的文书共享
 成效低,数据写入内存,在从内存中读取数据
 运用shm_open达成文件共享也可以

文本内存共享,不可以开展通讯

 

因此锁,让进度共享内存举行通信 pthread_mutex_init  须求将锁放在共享内存中  

 

fork  +  exec 让进度有例外的职能

 

epoll的运用

epollfd  创造文件讲述符集合

epol_ctl将文件讲述出席集合中

匿名管道  pipe()创设管道

 

 

mmap  能够已毕有亲子关系进程的文件共享
 功能低,数据写入内存,在从内存中读取数据
 运用shm_open落成文件共享也得以

文件内存共享,不可能进展通信

 

透过锁,让进程共享内存举行通信 pthread_mutex_init  要求将锁放在共享内存中  

 

fork  +  exec 让进度有分化的功力

 

非阻塞IO

 

管道

一边读,一边写

匿名管道  pipe()创制管道

 

 

mmap  可以达成有亲子关系进度的文件共享
 功效低,数据写入内存,在从内存中读取数据
 运用shm_open达成文件共享也足以

文件内存共享,不能进展通讯

 

透过锁,让进度共享内存进行通讯  pthread_mutex_init
 须要将锁放在共享内存中  

 

fork  +  exec 让进程有两样的功力

 

概述,linux第一章概述 第一章 概述
1.1 前言
本章钻探系统的概念,从硬件、操作系统角度更是深厚的领会总计机种类,并快…

相关文章