本文主要是介绍多线程编程与资源同步，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

多线程编程与资源同步

在Windows下,主线程退出后,子线程也会被关闭;

在Linux下,主线程退出后,系统不会关闭子线程,这样就产生了僵尸进程

3.2.1创建线程

• Linux 线程的创建

  #include <unistd.h>
  #include <stdio.h>
  #include <pthread.h>
  void* threadfunc(void* arg)
  {
      while (1)
      {
          sleep(1);
          printf("I am a new thread!!!\n");
      }
      return NULL;
  }
  
  int main()
  {
      pthread_t threadid;
      pthread_create(&threadid, NULL,threadfunc, NULL);
      while (1)
      {
  
      }
      return 0;
  }
  

• Windows CRT^[1]提供的线程创建函数

  #include <process.h>
  #include <stdio.h>
  unsigned int __stdcall threadfun(void* args)
  {
  	while (true)
  	{
  		printf("I am new thread!");
  	}
  	return 0;
  }
  int main(int argc,char* argv[])
  {
  	unsigned int threadid;
  	_beginthreadex(0, 0, threadfun, 0, 0, &threadid);
  
  	while (true)//不让主线程退出
  	{
  
  	}
  	return 0;
  }
  

• C++ 提供的std::thread类

  #include <iostream>
  #include <thread>
  
  void threadproc1()
  {
  	while (true)
  	{
  		printf("I am aNew Thread!!");
  	}
  }
  
  void threadproc2(int a,int b)
  {
  	while (true)
  	{
  		printf("I an Thread2");
  	}
  }
  
  int main()
  {
  	std::thread t1(threadproc1);
  	std::thread t2(threadproc2, 1, 2);
  	while (true)
  	{
  		
  	}
  }
  

  这种方法容易出错,原因如下:

  #include <iostream>
  #include <thread>
  
  void threadproc1()
  {
  	while (true)
  	{
  		printf("I am aNew Thread!!");
  	}
  }
  
  void func()
  {
  	std::thread t(threadproc1);
  }
  int main()
  {
  	func();
  	while (true)
  	{
  		
  	}
  }
  

  这段代码实际上试运行不了的,在vs2019 release模式下结果:

  

  在func函数调用完成后,func中的局部变量t被销毁,而此时线程函数仍然在运行.所以使用std::thread创建线程必须保证线程函数运行期间,线程对象始终有效!!

  当然,我们也可以使用detach方法解决这个问题,使线程函数和线程对象脱离

  ...
  void func()
  {
  	std::thread t(threadproc1);
      t.detach();
  }
  ...
  

  这样就可以运行了,但是不推进这样做,因为我们需要线程对象对线程进行管理

  3.2.2线程ID

  下面介绍一下Linux系统线程ID本质

• Linux系统线程ID本质

  在Linux系统中有三种方法可以获取一个线程的ID

  • 调用pthread_create函数时,可以通过第一个参数获取线程ID
  • 在需要获取ID的线程中调用pthread_self函数获取
  • 通过系统调用获取线程ID

  其中,方法一和方法二获取线程ID的结果都是一样的,都是pthread_t类型

  

不同的进程可能有同样的地址内存块(共享内存),所以通过方法一和方法二获取到的线程ID可能不是全系统唯一的,而方法三获取的线程ID是全系统唯一的,就是LWP(轻量级进程)^[2]

• C++ 获取线程ID的方法

  #include <thread>
  #include <iostream>
  #include <sstream>
  void worker_thread_func()
  {
      while (true)
      {
  
      }
  }
  
  int main()
  {
      //获取线程t的id
      std::thread t(worker_thread_func);
      std::thread::id worker_thread_id=t.get_id();
      std::cout<<worker_thread_id<<std::endl;
      //获取主线程的id
      std::thread::id main_thread_id = std::this_thread::get_id();
      std::cout<<main_thread_id<<std::endl;
      while (true)
      {
      }
  }
  

  运行结果(ubuntu20):

  

3.2.3 等待线程结束

• 在Linux下等待线程结束

  Linux 线程库提供了pthread_join函数,用来等待某线程的退出并接收他的返回值

  这种操作被称为汇接(join)

  Declared in: pthread.h  
  static int pthread_join(pthread_t __th, void * *__thread_return)
  

  参数__th是需要等待的线程ID;参数__thread__return是输出参数,用于接受被等待线程的退出码,

  可以再调用pthread_exit()时指定退出码

  Declared in: pthread.h  
  static void pthread_exit(void *__retval)
  

  其中__retval可以通过__thread_return参数获得

  下面来展示一个实例,在程序启动时开启一个工作线程,工作线程将当前系统时间写入一个文件后,主线程等待工作线程退出后,从文件中读取时间,并将其输出

  #include <cstdio>#include <string>#include <pthread.h>#include <cstring>#define TIME_FILENAME "time.txt"void* fileThreadFunc(void* arg){    time_t now = time(nullptr);    tm* t = localtime(&now);    char timeStr[32]={0};    snprintf(timeStr,32,"%04d/%02d %02d:%02d:%02d",             t->tm_year+1900,             t->tm_mon+1,             t->tm_mday,             t->tm_hour,             t->tm_min,             t->tm_sec);    FILE* fp = fopen(TIME_FILENAME,"w");    if(fp == nullptr)    {        printf("打开文件（time.txt）失败\n");        return nullptr;    }    size_t sizeToWrite=strlen(timeStr) +1;    size_t ret = fwrite(timeStr,1,sizeToWrite,fp);    if(ret != sizeToWrite)    {        printf("写入错误！\n");    }    fclose(fp);    return nullptr;}int main(){    pthread_t fileThreadID;    int ret = pthread_create(&fileThreadID, nullptr,fileThreadFunc, nullptr);    if(ret != 0)    {        printf("创建线程失败\n");        return -1;    }    int* retval;    pthread_join(fileThreadID,(void**)&retval);    FILE* fp = fopen(TIME_FILENAME,"r");    if(fp == nullptr)    {        printf("打开文件失败！\n");        return -2;    }    char  buf[32] = {0};    int sizeRead = fread(buf,1,32,fp);    if(sizeRead == 0)    {        printf("读取文件失败");        fclose(fp);        return -3;    }    printf("Current time is: %s.\n",buf);    fclose(fp);    return 0;}
  

  执行结果如下:

  

• Windows 等待线程结束

  在Windows下我们可以使用WaitForSingleObject function (synchapi.h)和WaitForMultipleObjects function (synchapi.h)

• C++11提供的等待线程结束的函数

  #include <cstdio>#include <cstring>#include <thread>#define TIME_FILENAME "time.txt"void fileThreadFunc(){    time_t now = time(nullptr);    tm* t = localtime(&now);    char timeStr[32]={0};    snprintf(timeStr,32,"%04d/%02d %02d:%02d:%02d",             t->tm_year+1900,             t->tm_mon+1,             t->tm_mday,             t->tm_hour,             t->tm_min,             t->tm_sec);    FILE* fp = fopen(TIME_FILENAME,"w");    if(fp == nullptr)    {        printf("打开文件（time.txt）失败\n");        return ;    }    size_t sizeToWrite=strlen(timeStr) +1;    size_t ret = fwrite(timeStr,1,sizeToWrite,fp);    if(ret != sizeToWrite)    {        printf("写入错误！\n");    }    fclose(fp);    return;}int main(){    std::thread t(fileThreadFunc);    if(t.joinable()) t.join();    FILE* fp = fopen(TIME_FILENAME,"r");    if(fp == nullptr)    {        printf("打开文件失败！\n");        return -2;    }    char  buf[32] = {0};    int sizeRead = fread(buf,1,32,fp);    if(sizeRead == 0)    {        printf("读取文件失败");        fclose(fp);        return -3;    }    printf("Current time is: %s.\n",buf);    fclose(fp);    return 0;}
  

3.4.3 C++11 对整型变量原子操作的支持

C++11 提供了对整形变量原子操作的支持

即std::atomic这是一个模板类型

Defined in header <atomic>template< class T >struct atomic;

例子

#include <atomic>#include <iostream>int main(){    std::atomic<int> value{1};    value++;//自增,原子操作    std::cout<<value<<std::endl;}

C++ 线程同步对象

C++ 新标准中新增用于线程同步的std::mutex和std::condition_variable

3.7.1 std::mutex系列

这个系列类型的对象均提供了加锁lock,尝试加锁trylock和解锁unlock的方法

#include <iostream>#include <chrono>#include <thread>#include <mutex>int  g_num =0 ;std::mutex g_num_mutex;void slow_increment(int id){    for (int i = 0; i < 10; ++i)    {        g_num_mutex.lock();        ++g_num;        std::cout<<id<<"->"<<g_num<<std::endl;        g_num_mutex.unlock();    }    std::this_thread::sleep_for(std::chrono::seconds(1));}int main(){    std::thread t1(slow_increment,0);    std::thread t2(slow_increment,1);    t1.join();    t2.join();    return 0;}

输出:

3.7.2 std::shared_mutex

std::shared_mutex的底层实现是操作系统提供的读写锁,也就是说,在有多个线程对共享资源读且少许线程对共享资源写的情况下,std::shared_mutex比std::mutex效率更高

shared_mutex 通常用于多个读线程能同时访问同一资源而不导致数据竞争，但只有一个写线程能访问的情形。

3.7.3 std::condition_variable

Member functions

`

这篇关于多线程编程与资源同步的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！