几个线程对同一个全局变量读写时，需不需要锁定？

[66i88]

比如一个全局计数器，几个线程对其++ - - 时，
需不需要锁定这个全局变量？如果需要怎么锁定？

谢谢。

[worldy]

引用 楼主 66i88 的回复:

比如一个全局计数器，几个线程对其++ - - 时， 需不需要锁定这个全局变量？如果需要怎么锁定？ 谢谢。

一般需要锁定，因为内部指令不会在一个指令周期内完成

[oyljerry]

需要锁定，++, --都不是原子操作，需要加锁来进行保护。

[Eleven]

需要，可以使用临界区EnterCriticalSection/LeaveCriticalSection

[孤客天涯]

当然需要锁定

[zgl7903]

//CRITICAL_SECTION

typedef struct _tagMyCriticalSectionLock_t
{
  CRITICAL_SECTION m_sect;
  _tagMyCriticalSectionLock_t()
  {
    InitializeCriticalSection(&m_sect);
  }
  ~_tagMyCriticalSectionLock_t()
  {
    DeleteCriticalSection(&m_sect);
  }

  BOOL Unlock()
  {
    LeaveCriticalSection(&m_sect); return TRUE;
  }
  BOOL Lock()
  {
    EnterCriticalSection(&m_sect); return TRUE;
  }
}MYCRITICALSECTIONLOCK, *LPMYCRITICALSECTIONLOCK;

//应用 
MYCRITICALSECTIONLOCK MyLock;

void funA()
{
 MyLock.Lock();
  ……
 MyLocl.Unlock();
}

void funB()
{
 MyLock.Lock();
  ……
 MyLocl.Unlock();
}

[赵4老师]

需要。 仅供参考：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef WIN32
    #include <windows.h>
    #include <io.h>
    #include <process.h>
    #define  MYVOID             void
#else
    #include <unistd.h>
    #include <sys/time.h>
    #include <pthread.h>
    #define  CRITICAL_SECTION   pthread_mutex_t
    #define  _vsnprintf         vsnprintf
    #define  MYVOID             void *
#endif
//Log{
#define MAXLOGSIZE 20000000
#define ARRSIZE(x) (sizeof(x)/sizeof(x[0]))
#include <time.h>
#include <sys/timeb.h>
#include <stdarg.h>
char logfilename1[]="MyLog1.log";
char logfilename2[]="MyLog2.log";
char logstr[16000];
char datestr[16];
char timestr[16];
char mss[4];
CRITICAL_SECTION cs_log;
FILE *flog;
#ifdef WIN32
void Lock(CRITICAL_SECTION *l) {
    EnterCriticalSection(l);
}
void Unlock(CRITICAL_SECTION *l) {
    LeaveCriticalSection(l);
}
void sleep_ms(int ms) {
    Sleep(ms);
}
#else
void Lock(CRITICAL_SECTION *l) {
    pthread_mutex_lock(l);
}
void Unlock(CRITICAL_SECTION *l) {
    pthread_mutex_unlock(l);
}
void sleep_ms(int ms) {
    usleep(ms*1000);
}
#endif
void LogV(const char *pszFmt,va_list argp) {
    struct tm *now;
    struct timeb tb;


    if (NULL==pszFmt||0==pszFmt[0]) return;
    if (-1==_vsnprintf(logstr,ARRSIZE(logstr),pszFmt,argp)) logstr[ARRSIZE(logstr)-1]=0;
    ftime(&tb);
    now=localtime(&tb.time);
    sprintf(datestr,"%04d-%02d-%02d",now->tm_year+1900,now->tm_mon+1,now->tm_mday);
    sprintf(timestr,"%02d:%02d:%02d",now->tm_hour     ,now->tm_min  ,now->tm_sec );
    sprintf(mss,"%03d",tb.millitm);
    printf("%s %s.%s %s",datestr,timestr,mss,logstr);
    flog=fopen(logfilename1,"a");
    if (NULL!=flog) {
        fprintf(flog,"%s %s.%s %s",datestr,timestr,mss,logstr);
        if (ftell(flog)>MAXLOGSIZE) {
            fclose(flog);
            if (rename(logfilename1,logfilename2)) {
                remove(logfilename2);
                rename(logfilename1,logfilename2);
            }
            flog=fopen(logfilename1,"a");
            if (NULL==flog) return;
        }
        fclose(flog);
    }
}
void Log(const char *pszFmt,...) {
    va_list argp;

    Lock(&cs_log);
    va_start(argp,pszFmt);
    LogV(pszFmt,argp);
    va_end(argp);
    Unlock(&cs_log);
}
//Log}
static int volatile No_Loop=0;
static int volatile gLock = 0;
static int volatile gCounter = 0;
MYVOID testThread(void *pcn) {
    int n,i;

    n=(int)pcn;
    while (1) {
        if (No_Loop==2) {
            for (i = 0; i < 1000000; ) {
                //以下代码无效
//              if ( 0 == gLock ) {
//                  gLock = n;
//                  if( gLock == n ) {
//                      ++i;
//                      ++gCounter;
//                      //if (i%100000==0) Log("%d %d\n",n,gCounter);
//                      gLock = 0;
//                      //if (i%100000==0) sleep_ms(10*(rand()%50));
//                      continue;
//                  } else sleep_ms(100);
//              } else sleep_ms(100);

                //应改为以下代码
                InterlockedCompareExchange((void **)&gLock, (void *)n, 0);
                if( gLock == n ) {
                    ++i;
                    ++gCounter;
                    if (i%100000==0) Log("%d %d\n",n,gCounter);
                    InterlockedExchange((long *)&gLock, 0);
                    if (i%100000==0) sleep_ms(10*(rand()%50));
                    continue;
                } else sleep_ms(100);
            }
            sleep_ms(1000);
            No_Loop=1;
        }
    }
}
int main(int argc,char * argv[]) {
    int i;
	srand(time(NULL));
#ifdef WIN32
    InitializeCriticalSection(&cs_log);
#else
    pthread_mutex_init(&cs_log,NULL);
    pthread_t threads[4];
//  void *thread_result;
    int threadsN;
    int rc;
#endif
    Log("=========BEGIN==================\n");
#ifdef WIN32
    _beginthread((void(__cdecl *)(void *))testThread,0,(void *)1);
    _beginthread((void(__cdecl *)(void *))testThread,0,(void *)2);
    _beginthread((void(__cdecl *)(void *))testThread,0,(void *)3);
    _beginthread((void(__cdecl *)(void *))testThread,0,(void *)4);
#else
    threadsN=0;
    rc=pthread_create(&(threads[threadsN++]),NULL,testThread,(void *)1);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1);
    rc=pthread_create(&(threads[threadsN++]),NULL,testThread,(void *)2);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1);
    rc=pthread_create(&(threads[threadsN++]),NULL,testThread,(void *)3);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1);
    rc=pthread_create(&(threads[threadsN++]),NULL,testThread,(void *)4);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1);
#endif
    sleep_ms(1000);
    No_Loop=2;
    i=0;
    while (1) {
        sleep_ms(1000);
        if (No_Loop==1) break;//
    }
    sleep_ms(1000);
    Log("Result: %d\n",gCounter);
    Log("=========END====================\n");
#ifdef WIN32
    DeleteCriticalSection(&cs_log);
#else
    pthread_mutex_destroy(&cs_log);
#endif
    return 0;
}

[shenyi0106]

肯定要！ 如果只是对于一个常规类型进行操作（比如int long等），可以使用原子操作interlock系列的函数

[sichuanwww]

[homesos]

一般是需要加锁，安全第一，有性能要求的另说，主要看业务逻辑，这个变量充当一个什么角色，基本数据类型、任何时候值都不会产生错误的，可以考虑不需要，比如计数器、数据量统计、循环队列索引，什么的可以在读写的时候不需要加锁。

[liangxin509]

用临界区省事

[smwhotjay]

几个线程对其++ - - 这个数据是否重要？ 还是无所谓的统计而已 是否有操作依赖这个数据？那么就要线程安全控制了。 临界区，原子锁 都是你的选择

[sky065530]

肯定要的，原子访问，关键段，读写锁都可以的

[向立天]

当然需要