精华内容
下载资源
问答
  • C#多线程互斥实例 多线程获取同一变量(不重复)。是一个很好的学习例子
  • 线程操作同一变量

    千次阅读 2018-06-13 15:37:16
    最近做的项目需要上传数据给服务器,为防止因网络延迟给每条数据加一个...因为发送数据的地方很多,都是线程操作,本人技术有限,所以选择了最简单的WaitForSingleObject(mMutex,INFINITE)来解决变量互斥问题。 ...

            最近做的项目需要上传数据给服务器,为防止因网络延迟导致服务器收到数据重复,给每条数据加一个批次号batchId由服务器判断,批次号由当前时间年月日加一个计数器组成,例如2018061300001,计数器iCount累加,每天0点清零。因为发送数据的地方很多,都是线程操作,本人技术有限,所以选择了最简单的WaitForSingleObject(mMutex,INFINITE)来解决变量互斥问题。

    先定义全程变量 

    HANDLE mMutex ;

    程序启动时候初始化mMutex 。

    mMutex =CreateMutex(NULL, FALSE, NULL);

    线程里操作变量之前锁定

    UINT      ThreadSendAlarmInfomation (LPVOID lpParam)
    {
    
    	WaitForSingleObject(mMutex ,INFINITE);
    	iCount++;
    	ReleaseMutex(mMutex );
            CStringA currentTime,sbatchId;
    	CTime t=CTime::GetCurrentTime(); 
    	sbatchId.Format(_T("%s%05d"),t.Format("%Y%m%d"),iCount);
    }
    展开全文
  • 线程访问同一变量是否需要加锁

    千次阅读 2015-09-08 21:49:06
    对于多线程访问同一变量是否需要加锁的问题,先前大家都讨论过。今天用代码验证了一下之前的猜想:32位CPU与内存的最小交换数据为4字节/次,这也是结构体要对齐4字节的原因。在物理上,CPU对于同一4字节的内存单元,...
    对于多线程访问同一变量是否需要加锁的问题,先前大家都讨论过。今天用代码验证了一下之前的猜想:32位CPU与内存的最小交换数据为4字节/次,这也是结构体要对齐4字节的原因。在物理上,CPU对于同一4字节的内存单元,不可能写2个字节的同时,又读了3字节。
    

    测试环境为:

    XEON 2CPU*2
    Windows7

    采用50,50,50线程交叉读写,试验代码如下:
    C/C++ code
    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    int  g_test;
    int  temp;
    BOOL  g_bRunning;
    DWORD  WINAPI thWriteProc1( LPVOID  lParam)
    {
         while (g_bRunning)
         {
             g_test = 12345678;
             Sleep(1);
         }
         return  0;
    }
    DWORD  WINAPI thWriteProc2( LPVOID  lParam)
    {
         while (g_bRunning)
         {
             g_test = 13579246;
             Sleep(1);
         }
         return  0;
    }
     
    DWORD  WINAPI thReadProc( LPVOID  lParam)
    {
         while (g_bRunning)
         {
             temp = g_test; //读取值
             if  ( temp != 12345678 && temp != 13579246 )
             {
                 g_bRunning = FALSE;
                 CString str;
                 str.Format( "read error!%d" , temp);
                 AfxMessageBox(str);
                 break ;
             }
             Sleep(1);
         }
         return  0;
    }
    void  CTestMultiyAccessIntDlg::OnButton1() 
    {
         g_bRunning = TRUE;
         for  int  i = 0; i < 50; i++ )
         {
             //创建50个写线程1
             CreateThread( NULL, 0, thWriteProc1, NULL, 0, NULL );
         }
         for  int  i = 0; i < 50; i++ )
         {
             //创建50个写线程2
             CreateThread( NULL, 0, thWriteProc2, NULL, 0, NULL );
         }
         for  int  i = 0; i < 50; i++ )
         {
             //创建50个读线程
             CreateThread( NULL, 0, thReadProc, NULL, 0, NULL );
         }
    }


    测试方法:
    改变g_test的类型,给g_test赋予不同的值(不要超过类型的上限值)

    测试现象:
    当g_test为int,short char时,不存在多线程交叉读写错误的问题
    当g_test为double, float, __int64时,存在多线程交叉读写错误的问题,对于__int64,当赋值小于0xFFFFFFFF时不出错,当大于0xFFFFFFFF时出错
    当g_test为CString时,存在交叉读写错误,有时候程序崩溃
    另:不加Sleep(1)机器卡死过,CPU占用率达到100%,4个核心占用率全满,可以保证运行在多核环境下

    现象分析:
    (1)int short char均为小于4字节的连续内存块,CPU一条指令就可以读写它们的值,CPU不可能同一个时间执行两条指令
    (2)double为8字节,如果写线程先写了4字节,读线程读了8字节,这自然导致数据被破坏
    (3)float也为4字节,我也不是太清楚为什么不行,可能是VC对浮点数的处理比较特殊有关,浮点数具有复杂内存结构
    (4)__int64为8字节,存在和(2)相同的情况,如果__int64小于等于0xFFFFFFFF,相当于只改变了低4字节,因此就没有问题
    (5)CString为类类型,具有复杂结构,显然不行

    结论:
    1.对于int,short,char,BOOL等小于等于4字节的简单数据类型,如果无逻辑上的先后关系,多线程读写可以完全不用加锁
    2.尽管float为4字节,多线程访问时也需要加锁
    3.对于大于4字节的简单类型,比如double,__int64等,多线程读写必须加锁。
    4.对于所有复杂类型,比如类,结构体,容器等类型必须加锁

    尽管对int等类型的多线程读写不需要加锁,但是逻辑上有必要加锁的还是应该加锁
    例如:对于一个多线程访问的全局变量int g_test
    int count = g_test/1024;
    int mod = g_test%1024;
    由于是两条语句,执行完第一条之后,别的线程很可能已经修改了g_test的值,如果希望这两条语句执行时,g_test不发生变化,就必须加锁,以保证两条语句执行的整体性。
    Lock();
    int count = g_test/1024;
    int mod= g_test%1024;
    UnLock();
    如果不加锁,也可以改为先保存到一个临时变量里
    int temp = g_test;
    int count = temp/1024;
    int mod = temp%1024;
    展开全文
  • 对于多线程访问同一变量是否需要加锁的问题,先前大家都讨论过。今天用代码验证了一下之前的猜想:32位CPU与内存的最小交换数据为4字节/次,这也是结构体要对齐4字节的原因。在物理上,CPU对于同一4字节的内存单元,...
    对于多线程访问同一变量是否需要加锁的问题,先前大家都讨论过。今天用代码验证了一下之前的猜想:32位CPU与内存的最小交换数据为4字节/次,这也是结构体要对齐4字节的原因。在物理上,CPU对于同一4字节的内存单元,不可能写2个字节的同时,又读了3字节。
    

    测试环境为:

    XEON 2CPU*2
    Windows7

    采用50,50,50线程交叉读写,试验代码如下:
    C/C++ code
    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    int  g_test;
    int  temp;
    BOOL  g_bRunning;
    DWORD  WINAPI thWriteProc1( LPVOID  lParam)
    {
         while (g_bRunning)
         {
             g_test = 12345678;
             Sleep(1);
         }
         return  0;
    }
    DWORD  WINAPI thWriteProc2( LPVOID  lParam)
    {
         while (g_bRunning)
         {
             g_test = 13579246;
             Sleep(1);
         }
         return  0;
    }
     
    DWORD  WINAPI thReadProc( LPVOID  lParam)
    {
         while (g_bRunning)
         {
             temp = g_test; //读取值
             if  ( temp != 12345678 && temp != 13579246 )
             {
                 g_bRunning = FALSE;
                 CString str;
                 str.Format( "read error!%d" , temp);
                 AfxMessageBox(str);
                 break ;
             }
             Sleep(1);
         }
         return  0;
    }
    void  CTestMultiyAccessIntDlg::OnButton1() 
    {
         g_bRunning = TRUE;
         for  int  i = 0; i < 50; i++ )
         {
             //创建50个写线程1
             CreateThread( NULL, 0, thWriteProc1, NULL, 0, NULL );
         }
         for  int  i = 0; i < 50; i++ )
         {
             //创建50个写线程2
             CreateThread( NULL, 0, thWriteProc2, NULL, 0, NULL );
         }
         for  int  i = 0; i < 50; i++ )
         {
             //创建50个读线程
             CreateThread( NULL, 0, thReadProc, NULL, 0, NULL );
         }
    }


    测试方法:
    改变g_test的类型,给g_test赋予不同的值(不要超过类型的上限值)

    测试现象:
    当g_test为int,short char时,不存在多线程交叉读写错误的问题
    当g_test为double, float, __int64时,存在多线程交叉读写错误的问题,对于__int64,当赋值小于0xFFFFFFFF时不出错,当大于0xFFFFFFFF时出错
    当g_test为CString时,存在交叉读写错误,有时候程序崩溃
    另:不加Sleep(1)机器卡死过,CPU占用率达到100%,4个核心占用率全满,可以保证运行在多核环境下

    现象分析:
    (1)int short char均为小于4字节的连续内存块,CPU一条指令就可以读写它们的值,CPU不可能同一个时间执行两条指令
    (2)double为8字节,如果写线程先写了4字节,读线程读了8字节,这自然导致数据被破坏
    (3)float也为4字节,我也不是太清楚为什么不行,可能是VC对浮点数的处理比较特殊有关,浮点数具有复杂内存结构
    (4)__int64为8字节,存在和(2)相同的情况,如果__int64小于等于0xFFFFFFFF,相当于只改变了低4字节,因此就没有问题
    (5)CString为类类型,具有复杂结构,显然不行

    结论:
    1.对于int,short,char,BOOL等小于等于4字节的简单数据类型,如果无逻辑上的先后关系,多线程读写可以完全不用加锁
    2.尽管float为4字节,多线程访问时也需要加锁
    3.对于大于4字节的简单类型,比如double,__int64等,多线程读写必须加锁。
    4.对于所有复杂类型,比如类,结构体,容器等类型必须加锁

    尽管对int等类型的多线程读写不需要加锁,但是逻辑上有必要加锁的还是应该加锁
    例如:对于一个多线程访问的全局变量int g_test
    int count = g_test/1024;
    int mod = g_test%1024;
    由于是两条语句,执行完第一条之后,别的线程很可能已经修改了g_test的值,如果希望这两条语句执行时,g_test不发生变化,就必须加锁,以保证两条语句执行的整体性。
    Lock();
    int count = g_test/1024;
    int mod= g_test%1024;
    UnLock();
    如果不加锁,也可以改为先保存到一个临时变量里
    int temp = g_test;
    int count = temp/1024;
    int mod = temp%1024;
    展开全文
  • 线程 《多线程操作同一变量

    千次阅读 2014-05-08 16:26:24
    两个线程“Window1”和“Window2”操作同一变量ticketCount(卖票)。 【代码示例】 1、MyThread.java package com.wcs.java.thread; public class MyThread implements Runnable{ private int...

    【代码说明】

    两个线程“Window1”和“Window2”操作同一变量ticketCount(卖票)。


    【代码示例】

    1、MyThread.java

    package com.wcs.java.thread;
    
    
    public class MyThread implements Runnable{
        
        private int ticketCount;
        
        public MyThread(int ticketCount) {
            this.ticketCount = ticketCount;
        } 
        
        public synchronized int sellTicket() {
            return --ticketCount;
        }
    
        @Override
        public void run() {
            while(ticketCount > 0) {
                System.out.println(Thread.currentThread().getName() + " sell one ticket,remainder ticket count is : " + sellTicket());
            }
        }
    
    }

    2、TestMyThread.java

    package com.wcs.java.thread;
    
    
    public class TestMyThread {
    
        public static void main(String[] args) {
            MyThread myThread = new MyThread(10);
            Thread t1 = new Thread(myThread, "Window 1");
            Thread t2 = new Thread(myThread, "Window 2");
            t1.start();
            t2.start();
        }
    
    }


    【运行结果】

    Window 1 sell one ticket,remainder ticket count is : 9
    Window 1 sell one ticket,remainder ticket count is : 7
    Window 1 sell one ticket,remainder ticket count is : 6
    Window 2 sell one ticket,remainder ticket count is : 8
    Window 2 sell one ticket,remainder ticket count is : 4
    Window 2 sell one ticket,remainder ticket count is : 3
    Window 2 sell one ticket,remainder ticket count is : 2
    Window 2 sell one ticket,remainder ticket count is : 1
    Window 2 sell one ticket,remainder ticket count is : 0
    Window 1 sell one ticket,remainder ticket count is : 5

    展开全文
  • 在Java中,如果启动多个线程对同一个对象或者变量时候,在没有安全保护前提下有可能会抛出并异常 java.util.ConcurrentModificationException 当方法检测到对象的并发修改,但不允许这种修改时,抛出此异常(并发...
  • 同一进程中可以包含多个线程,由于进程中的多个线程可以共享进程中的资源,所以使同一进程中的多个线程之间通信相对比较简单。 当需要有多个线程来访问一个全局变量时,通常我们会在这个全局变量前加上volatile声明...
  • 情况首先要肯定的是ThreadLocal和局部变量线程安全的,静态和实例变量都是不安全的。我们常常在系统中会用一些 静态变量 作为 共同的状态标记。但在多线程中常常发现这个 变量的增减 会出现错乱 并不是预期中的...
  • 很简单的逻辑,就是for循环开新的线程然后每个线程执行static静态变量count的修改。 在inc()方法中,count用for循环执行操作很重要。因为现在的电脑性能都应经很好(一般情况下资源都浪费了),所以如果简单...
  • 早在Java 1.2推出之时,Java平台中就引入了一个新的支持:java.lang.ThreadLocal,给我们在编写多线程程序时提供了一种新的选择。使用这个工具类可以很简洁地编写出优美的多线程程序,虽然ThreadLocal非常有用,但是...
  • 有网友提出多个线程操作多个变量不能明确显示是否做到异步操作,现在我们来看下多个线程操作同一变量,是不是有序的进行呢? #include #include #include int CVICALLBACK ThreadFunction (void *functionData);...
  • 使用两个线程调用同一静态方法(该静态方法不引用静态变量)、第一个线程被阻塞的时间大于第二个线程被阻塞的时间,若第一个线程与第二个线程的输出结果相同,则两个线程调用同一静态方法存在线程安全问题,若第一个...
  • 程序中通常将多线程同时访问的某个资源作为临界区,需要定义一个CRITICAL_SECTION类型的变量,然后调用InitializeCriticalSection函数对变量进行初始化; 函数声明: VOID InitializeCriticalSection(LPCRITICAL_...
  • 一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务。 每个进程都会有自己的虚拟地址空间,同一个进程中的每个线程都会在这个虚拟空间中,并被分配相应的...
  • 线程访问同一函数

    千次阅读 2017-08-07 21:58:06
    多个线程访问同一函数时,一般情况下是互不影响的,但是当函数中存在全局变量或是static静态变量时,各个线程会得到不确定的结果
  • java多线程操作同一资源

    千次阅读 2019-06-05 23:08:04
    java多线程操作同一资源
  • 在web应用中,每次请求都是不同线程,因此,当统一数据进行访问更新的时候,有可能会引发数据问题。 举个例子:有一个apple表,里面有个字段count,表示某种apple的数量。同时,后台提供获取这种苹果的服务,...
  • lock 的目的: 不想在自己使用的时候别人也使用这段代码。体现在多线程情况下,只允许当前线程执行该代码区域,其他线程等待直到该线程执行结束;...但当不同线程都需要访问某个资源的时候,就需要同步机制了。
  • 只要在静态函数中没有处理多线程共享数据,就不存在着多线程访问同一个静态方法会出现资源冲突的问题,静态方法是否引起线程安全问题主要看该静态方法是否全局变量(静态变量static member)进行修改操作
  • 在C中,经常用到全局变量的概念,可以方便地不同函数中需要重复调用的变量进行赋值操作。而在单片机的应用中,经常会有若干个对应的执行文件,如何使一个变量在这些文件中都能进行对应的赋值操作呢? 我们需要...
  • ssm框架下多线程操作同一对象

    千次阅读 2018-01-19 18:37:59
    前几天遇到这样一个问题,在ssm框架下如何让多个人对同一篇文章的同一个段落排队进行编辑,排队很容易就想到java中的queue队列,经过查阅才知道只要是框架它都会自动给你处理线程问题,每一个用户是一个线程,当用户...
  • 线程访问同一资源时冲突

    千次阅读 2019-03-11 16:08:23
    多个线程同时访问一个资源并进行读写操作时,资源改变在多个线程中同时操作,会造成冲突 public class Test implements Runnable{ private static int count=10; public /*synchronized*/ void run(){ count--; ...
  • 在Java程序中,每当启用一个线程时,JVM就为他分配一个Java栈,栈是以帧为单位保存当前线程的运行状态。今天我们继续深入Java核心,探秘JVM中的栈和局部变量。 Java开发中,每当我们在程序中使用new生成一个对象,...
  • 线程执行同一方法问题

    千次阅读 2018-04-09 12:36:36
    前言当多个线程启动,访问一个实例中的一个方法时,执行情况如何,是等待一个线程执行完成还是同时处理?数据又该如何处理?Java虚拟机运行时数据区的组成由五个部分组成,分别是:方法区,堆,栈,本地方法栈,程序...
  • Java是线程安全的,即任何方法(包括静态方法)都可以不考虑线程冲突,但有一个前提,就是不能全局变量(共享资源)进行写操作。 如果有,则需要使用同步机制:synchronized关键字。
  • 一、在说明多线程对全局变量的影响之前,我们需要了解下面的一些基础知识: 1、线程是CPU分配时间片的最小单位,通常一个CPU内核可以处理一个线程,如果是双核双线程,那么同一时刻可以处理两个线程。 2、进程是...
  • 我知道C#.NET可以用 ...方式避免多线程同时访问同一变量的方法,但是我用在C++.NET就不好使了, 请示例如何在C++.NET中,多线程同时实现textBox1->Text = textBox1 + "success"功能,示例哈,谢谢

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 214,816
精华内容 85,926
关键字:

不同线程对同一变量