linux c 多线程

shell 脚本创建

mkdir EMprj
cd EMprj/
code .

在vscode中

新建CMakeLists.txt文件,编写内容:

cmake_minimum_required(VERSION 2.8)

project(demo)

add_executable(main main.c)

新建main.c文件,编写内容:

# include <stdio.h>

int main(int argc, char const *argv[])
{
   printf("nihao\n");
   return 0;
}

gedit run.sh

在run.sh中编写:

#!/bin/bash

rm build -r
mkdir build
cd build
cmake ..
make
./main

sudo chmod 777 run.sh
./run.sh

多线程使用

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

pthread_t thread[2];

void *thread1()
{
    int time = 5;
    for (; ; )
    {
        if (!time--)
        {
            break;
        }
        printf("thread1:I'm thread 1\n");
        sleep(1);
        
    }
    pthread_exit(NULL);
}

void *thread2()
{
    for (; ;)
    {
        printf("thread2:I'm thread 2\n");
        sleep(1);
    }
    pthread_exit(NULL);
}

void thread_create() //创建两个线程
{
    int temp;
    if((temp = pthread_create(&thread[0], NULL, thread1, NULL)) != 0)
        printf("线程1创建失败!\n");
    else
        printf("线程1被创建\n");

    if((temp = pthread_create(&thread[1], NULL, thread2, NULL)) != 0)
        printf("线程2创建失败!\n");
    else
        printf("线程2被创建\n");
}

void thread_wait() //等待线程结束
{
    pthread_join(thread[0], NULL);
    printf("线程1已经结束\n");
    pthread_join(thread[1], NULL);
    printf("线程2已经结束\n");
}

int main(int argc, char const *argv[])
{
    printf("我是主函数哦, 我正在创建线程,呵呵\n");
    sleep(1);
    thread_create();
    printf("我是主函数哦, 我正在等待线程完成任务阿,呵呵\n");
    thread_wait();
    return 0;
}

线程通讯&同步

互斥锁

确保同一时间只能有一个线程访问共享资源。当锁被占用时试图对其加锁的线程都进入阻塞状态(释放CPU资源使其由运行状态进入等待状态)。当锁释放时哪个等待线程能获得该锁取决于内核的调度。两个线程同时 a++

读写锁

当以写模式加锁而处于写状态时任何试图加锁的线程(不论是读或写)都阻塞，当以读状态模式加锁而处于读状态时“读”线程不阻塞，“写”线程阻塞。读和读互不影响，读和写互斥，写和写互斥。安全+提高效率

条件变量

可以以原子的方式阻塞进程,直到某个特定条件为真为止。对条件的测试是在互斥锁的保护下进行的。条件变量始终与互斥锁一起使用。安全+进一步提高效率

自旋锁

上锁受阻时线程不阻塞而是在循环中轮询查看能否获得该锁,让等待锁的线程处于忙等状态,没有线程的切换因而没有切换开销,不过对CPU的霸占会导致CPU资源的浪费。所以自旋锁适用于并行结构(多个处理器)或者适用于锁被持有时间短而不希望在线程切换产生开销的情况。

使用环境

互斥&读写&条件

1.线程等待锁的时间较长

2.单核处理器

3.临界区有10操作

4,临界区操作复杂或者有大量循环

5.临界区竞争非常激烈

自旋

1.线程等待锁的时间短

2.加锁的代码（临界区）频繁被访问，竞争不激烈

3.cpu资源不紧张

4.多核处理器

信号量机制(Semaphore)：包括无名线程信号量和命名线程信号量

信号机制(Signal):类似进程间的信号处理

信号量&互斥量=同步&资源保护(互斥)

1.检测按键信号、处理按键事件用信号量

2.任务从缓存区读出需要处理的订单，需要用互斥量