static variables in multithreading

Question

I found that declaring a variable as static makes no sense in Multi-Threading. I assume that, this is because of every thread has its own stack. Is this the only reason?

I know that static variables should be used within synchronized block. but why?

_I found that declaring a variable as static makes no sense in Multi-Threading_ `[citation needed]` — DaoWen, Jul 06 '13 at 06:30

Juned Ahsan · Accepted Answer · 2013-07-06T06:22:43.970

33

static makes no sense in Multi-Threading.

Im afraid you are making the reverse statement. Static variable is a shared resource, which can be used to exchange some information among different threads. And we need to be careful while accessing such a shared resource. Hence, we need to make sure that the access to static variables in multi-threaded environment is synchronized.

every thread has its own stack

This is a correct statement. Each thread has its own stack but they share the process heap. Stack holds only the local variables and not the variables on the heap. Static variables are stored in the PermGen section of the heap and hence the access to them should be well guarded.

edited Jul 06 '13 at 06:22

answered Jul 06 '13 at 06:16

Juned Ahsan

67,789
12
98
136

So would `static int a` go into heap or stack memory then? – Sep 28 '14 at 08:03
@Juned Ahsan , can you please let me know how can i verify - "threads share the process heap." – shivam Oct 24 '17 at 10:15
@shivam static variables are stored in heap, so you can check that using different threads. – Juned Ahsan Oct 24 '17 at 23:36

Divers · Answer 2 · 2017-04-11T10:31:22.580

Because first part of question is already answered, I will try to answer on second question.

I know that static variables should be used within synchronized block. but why?

Because if you don't use atomic, operations with variables are not atomic. That's why you should block variables while working with them. But in real world, you can use volatile keyword, that will guarantee you, that threads will have actual values of variable.

score 3 · Answer 3 · answered Jul 06 '13 at 06:54

If you change a variable in a multithreaded environment, the new value may not neccessarily visibile as it might be cached. This is also true for static variables of course. If you don't use a synchronized block you might consider using volatile instead. This will also guaruantee that the various threads get an updated copy, without the need of synchronizing. Wether volatile is enough four your application depends on your requirements.

score 2 · Answer 4 · answered Jul 06 '13 at 06:59

Add volatile to your static declaration.

volatile will guarantee any other thread will see the most recent value of the variable. So, with volatile it will make sense.

However, volatile will not guarantee atomicity. If you write to your variable from more than one thread you might want to use atomics or synchronize block.

I think volatile will be fine.

static variables in multithreading

4 Answers4

Linked