Are static variables shared memory between threads?

Question

0.00/5 (No votes)

See more:

[Detai of logic code as below]

C++

- In C++ project(TestProject.exe)
  private ref class TestStaticClass
  {
      static int _testStaticVariable = 5;
  }

  int main()
  {
      cli::array<string^>^ arguments = Environment::GetCommandLineArgs();
      String^ fileName = arguments[0];

      ofstream* ofstreamTest = new ofstream();
      ofstreamTest->open(String::Concat(fileName, ".txt"), ios::out | ios::app);
      if (ofstreamTest->is_open())
      {
          cout.rdbuf(ofstreamTest->rdbuf());
      }
      for (int i = 0; i < 1000000; i++)
      {
          cout << TestStaticClass::_testStaticVariable; (*)
          cout << "\n";
          TestStaticClass::_testStaticVariable++; (**)
      }
      if (ofstreamTest != NULL)
      {
          ofstreamTest->close();
          delete ofstreamTest;
      }
  }

=> Run below command by Command Prompt
[TestProject.exe "TestFile"]
Then, TestFile.txt is outputted with below content:
5
6
...
1000004

- In C# project, logic code as below:

C#

public void ExecOne(string fileName)
  {
     ProcessStartInfo processStartInfo = new ProcessStartInfo("TestProject.exe");
     processStartInfo.WorkingDirectory = "C:\TestApplication\";
     processStartInfo.Arguments = $"\"{fileName}\"";
     processStartInfo.CreateNoWindow = true;
     processStartInfo.UseShellExecute = false;
     processStartInfo.RedirectStandardInput = false;
     processStartInfo.RedirectStandardOutput = true;

     Process process = Process.Start(processStartInfo);
  }

  public void ExecAutoCheck()
  {
     ParallelOptions parallelOptions = new ParallelOptions();
     parallelOptions.MaxDegreeOfParallelism = 3;
     
     var action1 = () => ExecOne("FileNameTest1");
     var actions = () => ExecOne("FileNameTest2");
     var action3 = () => ExecOne("FileNameTest3");
     List<action> listActionParallel = new List<action>();  
     listActionParallel.Add(action1);
     listActionParallel.Add(action2);
     listActionParallel.Add(action3);

     Parallel.Invoke(parallelOptions, listActionParallel.ToArray());
  }

=> After call ExecAutoCheck() method, 3 TestProject.exe will be executed parallel.
then these below files will be outputted with same content.
- FileNameTest1.txt
- FileNameTest2.txt
- FileNameTest3.txt
=> I try to run ExecAutoCheck() method about 5 times however result is the same.
With this test code i think that static variables are not shared memory between threads.
But I have not been found a clue to prove this.

I would be very grateful if someone explained this to me!!!

What I have tried:

Static variable will be stored in static area (static) similar to global variable.
In multi thread, i am understanding that static variables are being shared among threads.
However, with below code is seem that they are not shared.
So does that mean that on Managed C++ Multi thread will be different?

Posted 6-Apr-21 19:10pm

alex giulio

Updated 6-Apr-21 22:15pm

Richard MacCutchan

v2

Add a Solution

Comments

Richard MacCutchan 7-Apr-21 3:27am

You are not multithreading there, you are running three separate applications. Multiple threads run in a single address space.

alex giulio 7-Apr-21 7:13am

Yes, i got it.
OriginalGriff helped me explain this question.
Thank you for your reply!!

1 solution

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

OriginalGriff · Accepted Answer · 2021-04-06T20:05:00

That's complicated. Yes, they are shared between threads - a static variable has one single instance for the whole life of the application - but that doesn't mean you can blindly change it's value in different thread simultaneously.

Think about it: in cmahine code terms, x++ is not a single operation - it's a form of "syntactic sugar" which expands several to lines of code:

C#

int y = x;
x = x + 1;
return y;

And if you have multiple threads executing that code at the same time, then some of them are going to get the wrong value, or return the wrong value because you have no control over which of those three lines any thread is executing at the same time.
The technical terms for this is that the operation is not thread safe.

So while static variables are "shared between threads" you have to be very careful what you do with them, or things get very unpredictable, very quickly.
Be aware that multithreading is not a simple magic bullet to fix performance problems: it needs to be thought about and planned massively in advance or it will give you more problems than it solves!

Have a look here: Managed Threading Best Practices | Microsoft Docs[^]