www.9778.com 13

Linux基础第一章 概述

第一章 概述

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

前言

之前讨论了进程,了解一个进程能做一件事情,如果想同时处理多件事情,那么需要多个进程,但是进程间很不方便的一点是,进程间的数据交换似乎没有那么方便。Linux提供线程功能,能在一个进程中,处理多任务,而且线程之间的数据是完全共享的。

线程也有PCB,它的PCB和进程的PCB结构完全一样,只是它里面保存的虚拟地址空间和创建它的进程的虚拟地址空间完全保持一致。

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=%dn", (int)tid);
    pthread_create(&tid, NULL, thread_func, NULL);
    printf("tid=%dn", (int)tid);
    pthread_create(&tid, NULL, thread_func, NULL);
    printf("tid=%dn", (int)tid);
    pthread_create(&tid, NULL, thread_func, NULL);
    printf("tid=%dn", (int)tid);

    getchar();
}

 

 

Compile and link with -lpthread.

 

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

1.2 系统组成

 www.9778.com 1

 

1.1 前言

本章讨论系统的概念,从硬件、操作系统角度更加深刻的理解计算机系统,并快速浏览Linux系统提供的服务。

 线程标识

线程使用pthread_t来标识线程,它也是一个非负整数,由系统分配,保证在进程范围内唯一。pthread_t虽然在Linux下是非负整数,但是在其它平台下不一定是,所以比较线程号是否想等,应该用pthread_equal

任何一个函数都可以调用pthread_self来获取目前代码运行的线程。

1.3 操作系统和应用程序

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

 

 www.9778.com 2

 

 

操作系统是管理系统硬件的软件。操作系统是直接运行在裸机之上。其他应用软件运行在操作系统之上。

操作系统本身提供操作接口,支持用户通过该接口来操作
系统,但是系统本身提供的功能,不足于完成用户需求时,则需要开发应用程序来拓展系统功能。

发行版:
不同的公司使用Linux内核,加上自己开发的系统工具软件,一起发布的Linux操作系统版本。

1.2 系统组成

线程终止

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

注意:

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

  • 在多线程的进程中,主线程调用pthread_exit,进程并不会退出,它的其他线程依旧在执行,但是主线程已经退出了。

  • 意味着:主线程和其他线程是几乎是平等的。

  • 不平等的是,如果主线程的main函数return了,那么其他线程也结束了,如果其他线程的入口函数return了,主线程不会跟着结束。

1.4 启动和登陆

www.9778.com 3

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

 www.9778.com 4  

线程的回收

线程退出之后,它的PCB依旧在内核中存在,等着其它线程来获取它的运行结果,可以通过pthread_join来回收线程。从这个角度看,线程和进程差不多,但是跟进程不同的时,线程没有父线程的概念,同一个进程内的其它线程都可以来回收它的运行结果。

pthread_join会阻塞调用它的线程,一直到被join的线程结束为止。

pthread_joinwait/waitpid一样,也是阻塞的调用,它除了有回收PCB的功能,也有等待线程结束的功能。

1.5 文件

文件是一个重要的概念,一般定义为信息的集合。计算机做为信息处理的机器,文件是计算机处理的对象。

在Unix和Linux系统中,泛化了文件的概念,设备也被抽象成文件对象来进行操作。

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

1.3 操作系统和应用程序

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

   www.9778.com 5    

操作系统是管理系统硬件的软件。操作系统是直接运行在裸机之上。其他应用软件运行在操作系统之上。

操作系统本身提供操作接口,支持用户通过该接口来操作
系统,但是系统本身提供的功能,不足于完成用户需求时,则需要开发应用程序来拓展系统功能。

发行版:
不同的公司使用Linux内核,加上自己开发的系统工具软件,一起发布的Linux操作系统版本。

线程的使用场景

1.6 程序、进程

www.9778.com 6

1.4 启动和登陆

www.9778.com 7

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

 客户端使用场景

一般来说,线程用于比较复杂的多任务场景,比如:

 www.9778.com 8

这样主线程可以基础处理主线程的事情,不至于被复杂的任务阻塞。比如:

 

www.9778.com 9

这样聊天界面不会卡死在那里,否则如果网络情况很差,有可能导致界面卡死。

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行业处理信息:转换,传输,存储

服务器使用场景

服务器一般的流程如下:

 www.9778.com 10

在服务器上,一个线程来处理整个流程,会导致处理流程非常慢,导致主线程无法及时接收报文。一般会使用子线程来做具体的工作,而主线程只负责接收报文。

www.9778.com 11

有时为了提高处理效率,会使用线程池

 

 

1.8 用户、组、文件权限

Linux是多用户系统,支持多个用户同时登陆系统。
为了安全起见,需要对系统的权限加于规范。

1.6 程序、进程

7.7 线程的同步

无论上述那种场景,都有一个报文队列或者消息队列,一般这个队列是一个链表,主线程需要往链表中添加数据,而子线程从链表获取数据。两个线程同时操作一个全局变量是不安全的,应该避免不安全的访问。无论这种全局变量是数组、链表、还是一个简单的变量。

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

1.9 信号

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

www.9778.com 12

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(“%dn”, result);

    return 0;

}

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

#include <list>

 

struct task_t

{

    int task;

Linux基础第一章 概述。};

 

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 %dn”, 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系统开发接口时,程序员也需要学习一般常用的第三方库,来拓展程序员的编程能力。

 

www.9778.com 13

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

}

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 %dn", 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 %dn", 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 %dn", 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一起用,如果文件存在则失败

www.9778.com,1.8 用户、组、文件权限

Linux是多用户系统,支持多个用户同时登陆系统。
为了安全起见,需要对系统的权限加于规范。

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时,其实是给前台进程发送了一个信号。

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 %dn", result);
}

 

命令

touch:修改文件的访问时间,创建文件
cat:访问文件内容
vim:编辑
ulimit:显示一些限制信息(文件描述符最大值、栈的空间尺寸)
umask:文件创建的权限掩码
getconf:对应sysconf

dd:可以拷贝块设备,但是要sudo权限  例  dd if=位置 of=文件名  bs=一次多少k cout=拷贝次数

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

unlink:删除软链接

 

1.10 系统调用和库函数

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

  www.9778.com 14

User Space和Kernel
Space是操作系统编程中常用的概念,表示当前的代码在用户空间还是内核空间运行,对于不同的运行空间,CPU对内存的处理方式稍有不同,在讲进程虚拟地址空间时再涉及该概念。

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

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

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一起用,如果文件存在则失败

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:得到临时文件路径

 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:删除软链接

 

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 okn");
}

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 okn");
}

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 okn");
    }
    
    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

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=%dn", 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=%dn", result);
}

 

读写锁

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("%dn", (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=%dn", 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("%sn", 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 calln");
    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("%dn", a);
}



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

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

    sleep(1);
//    printf("%dn", result); // 100
    printf("%dn", 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);

高级IO

一个进程就是一段指令

 

IO复用技术

守护进程

守护进程不和终端关联,注意此进程只能有一个,创建文件记录,判断此程序是否开启

select的运用

运用文件描述符集合  运用fd_set创建文件描述符集合
 文件接口相对较小,跨平台运用

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

编程规则:

设umask=0;

调用fork,让父进程退出。    让父进程变为init,
 如果父进程不退出,用俩次fork()

调用setuid创建新会话  setsid

重设当前目录/根目录     chdir        

关闭不需要的文件描述符    运用循环关闭所有文件描述符

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将文件描述加入集合中

非阻塞IO

 

管道

一边读,一边写

匿名管道  pipe()创建管道

 

 

mmap  可以实现有亲子关系进程的文件共享
 效率低,数据写入内存,在从内存中读取数据
 运用shm_open实现文件共享也可以

文件内存共享,无法进行通信

 

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

 

fork  +  exec 让进程有不同的功能

 

概述,linux第一章概述 第一章 概述
1.1 前言
本章讨论系统的概念,从硬件、操作系统角度更加深刻的理解计算机系统,并快…