xml地图|网站地图|网站标签 [设为首页] [加入收藏]

c语言面试标题

stl空间配置器线程安全问题补充,stl安全问题

1:
int a[10];
int *p=a+1;//p将指向a[1]
p=&a+1;//p将指向a+10;
这是因为虽然a和&a的值都一样,是a[10]的首地址,但是&a类型为int (*)[5];而指针加1要根据指针类型加上一定的值,不同类型的指针+1之后增加的大小不同
a是长度为10的int数组指针,所以要加 10*sizeof(int)

摘要

在上一篇博客《STL空间配置器那点事》简单介绍了空间配置器的基本实现

两级空间配置器处理,一级相关细节问题,同时简单描述了STL各组件之间的关系以及设计到的设计模式等。

在最后,又关于STL空间配置的效率以及空间释放时机做了简单的探讨。

2: 引用与指针有什么区别?
1) 引用必须被初始化,指针不必。
2) 引用初始化以后不能被改变,指针可以改变所指的对象。
2) 不存在指向空值的引用,但是存在指向空值的指针。

线程安全问题概述

为什么会有线程安全问题?

  认真学过操作系统的同学应该都知道一个问题。

  first--进程是系统资源分配和调度的基本单位,是操作系统结构的基础,是一个程序的运行实体,同时也是一个程序执行中线程的容器

  seconed--进程中作为资源分配基本单位,管理着所有线程共享资源:代码段,数据段,堆,部分共享区(IPC中的共享内存等)。。栈则是线程私有的。

所以,由此就有:如果我们的数据存放位置处在数据段,堆这两个地方,那么就会有线程安全问题:

 1 #include <iostream>
 2 using namespace std;
 3 static int * arr = new int(4);     //arr作为全局变量存在于数据段,new申请所得空间存在于堆上。
 4 
 5 void testThreadSafe(int arg)
 6 {
 7     *arr = arg;
 8 }
 9 
10 int main()
11 {
12     int arg;
13     cin >> arg;
14     testThreadSafe(arg);
15     cout << (*arr)<<endl;
16     return 0;
17 }

  做个简单分析,假设进程同时运行到了第七行,因为程序执行的最小粒度是更为细致的cpu指令而不是一个代码语句。

所以可能A线程和B线程同时执行修改*arr = arg;,但是两个线程中cin>>arg输入的值不一样,那么就有问题。

两个线程各自执行到15行时,显示的结果是一样的(因为线程共享该区域),但他们本来却不该相同。

这就是线程安全问题。

3:五大内存分区

STL中线程安全问题的存在  

STL中,一级空间配置器简单封装malloc,free同时引入sethandler机制。而malloc,free作为最基本的系统调用是线程安全的,
所以问题就在二级空间配置器的实现部分了。

  各位还记得二级配置器内部结构定义吧。

template <bool threads, int inst>
class __DefaultAllocTemplate 
{
//...
protected:

//桶结构,保存链表
    static _Obj* _freeList[_NFREELISTS]; 
//.....
};

这里的核心结构,保存自由链表的指针数组就是各静态数据,存在于数据段,于是就有了线程安全问题。

在C++中,内存分成5个区,他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。

线程安全问题的解决方案之一:

linux环境,互斥锁

win环境,临界区(临界资源访问问题)

 

  对于STL的二级空间配置器中,线程安全问题的唯一存在也就是对于已组织的自由链表的访问了(也就是Allocate和Deallocate了):
两个线程同时向空间配置器申请内存块(ps,A未完成取出该节点并将表指针指向下一个节点时,B线程来了。于是两个线程同时得到一块内存);

图片 1

//////A执行玩1,尚未执行2,B就来申请空间。最终两个线程都修改数组中指针指向y,且共同拥有x

两个线程同时向空间配置器释放内存块;

  图片 2

////a释放执行1而没有来得及执行2,于是乎,在1。5的情况系,b释放,进入。于是,最终结果,a块,b块都指向了x,但是数组中指针只是指向了后来修改他的值,于是就有了内存泄漏。

 

栈,就是那些由编译器在需要的时候分配,在不需要的时候自动清楚的变量的存储区。里面的变量通常是局部变量、函数参数等。

解决方案,互斥锁使用

核心代码给出:

文件Alloc.h中部分代码

#pragma once

#include "Config.h"
#include "Trace.h"

#include "Threads.h"

#ifdef __STL_THREADS
#define __NODE_ALLOCATOR_THREADS true  //用于二级空间配置器翻非类型模板参数

#define __NODE_ALLOCATOR_LOCK 
        { if (threads) _S_node_allocator_lock._M_acquire_lock(); }
#define __NODE_ALLOCATOR_UNLOCK 
        { if (threads) _S_node_allocator_lock._M_release_lock(); }
#else
//  Thread-unsafe
#   define __NODE_ALLOCATOR_LOCK
#   define __NODE_ALLOCATOR_UNLOCK
#   define __NODE_ALLOCATOR_THREADS false
#endif




# ifdef __STL_THREADS
    static _STL_mutex_lock _S_node_allocator_lock;
# endif

template <bool threads, int inst>
class __DefaultAllocTemplate 
{

class _Lock;
    friend class _Lock;
    class _Lock {
        public:
            _Lock() 
            {
                __TRACE("锁保护n");
             __NODE_ALLOCATOR_LOCK;
             }
            ~_Lock()
            {
                __TRACE("锁撤销n");
             __NODE_ALLOCATOR_UNLOCK; 
             }
    };
static void* Allocate(size_t n)
    {
        void * ret = 0;
        __TRACE("二级空间配置器申请n = %un",n);
        if(n>_MAX_BYTES)
            ret = MallocAlloc::Allocate(n);

        _Obj* volatile * __my_free_list = _freeList + _FreeListIndex(n);

        //利用RAII(资源获取即初始化原则)进行封装,保证 即使内部抛出异常,依旧执行解锁操作
#ifdef __STL_THREADS
          _Lock __lock_instance;
#endif
        _Obj* __result = *__my_free_list;

        if (__result == 0)
            ret = _Refill(RoundUp(n));
        else
        {
            *__my_free_list = __result -> _freeListLink;
            ret = __result;
        }
        return ret;
    }

    static void Deallocate(void* p, size_t n)
    {
        if(!p)
        {
            return;
        }
        __TRACE("二级空间配置器删除p = %p,n = %dn",p,n);
        if (n > (size_t) _MAX_BYTES)
            MallocAlloc::Deallocate(p, n);
        else
        {
            _Obj* volatile*  __my_free_list = _freeList + _FreeListIndex(n);
            _Obj* q = (_Obj*)p;

#ifdef __STL_THREADS
            //进行资源归还自由链表时的锁操作。
              _Lock __lock_instance;
#endif
            q -> _freeListLink = *__my_free_list;
            *__my_free_list = q;
        }
    }

 

文件Threads.h

#pragma once 

#if defined(__STL_PTHREADS)
#include <pthread.h>
#endif

#include "Config.h"

__STLBEGIN

struct _STL_mutex_lock
{

#if defined(__STL_PTHREADS)
  pthread_mutex_t _M_lock;
  void _M_initialize()   { pthread_mutex_init(&_M_lock, NULL); }
  void _M_acquire_lock() { pthread_mutex_lock(&_M_lock); }
  void _M_release_lock() { pthread_mutex_unlock(&_M_lock); }
#else /* No threads */
  void _M_initialize()   {}
  void _M_acquire_lock() {}
  void _M_release_lock() {}
#endif
};

__STLEND

简单测试结果

图片 3

其中TRACE打印的“锁保护”,“锁撤销” 部分就是二级空间配置器资源分配时锁机制的保护实现了。

  其利用了C++的RAII(资源获取即初始化方案)  

  同时利用C++对象特性,退出作用域即执行析构函数,将解锁封装,巧妙的避免了死锁问题的产生

 

死锁:简单理解就是,因为某个线程锁定资源进行访问时,因为异常等原因退出执行,但是没来的及解锁,致使其他线程都无法访问共享资源的现象就是死锁。更细致的解释请找google叔。

 

最后,说明的是,实际的STL源码中因为需要考虑平台,系统兼容性等问题,对于锁的使用通过宏编译技术,有比较长的一段代码,我这里只是取出了当下linux平台可用代码放在了自己的Threads.h

 

更详细代码请关注个人另一博客:

或者github获取更新中的代码:

摘要 在上一篇博客《STL空间配置器那点事》简单介绍了空间配置器的基本实现 两级空间配置...

堆,就是那些由new分配的内存块,他们的释放编译器不去管,由我们的应用程序去控制,一般一个new就要对应一个delete。如果程序员没有释放掉,那么在程序结束后,操作系统会自动回收。

自由存储区,就是那些由malloc等分配的内存块,他和堆是十分相似的,不过它是用free来结束自己的生命的。

全局/静态存储区,全局变量和静态变量被分配到同一块内存中,在以前的C语言中,全局变量又分为初始化的和未初始化的,在C++里面没有这个区分了,他们共同占用同一块内存区。

本文由永利澳门平台发布于计算机资讯,转载请注明出处:c语言面试标题

您可能还会对下面的文章感兴趣: