Should I declare variable into thread or make a global In Android?

Question

In Android, what is good a global variable in public class or declare it within a thread?

I implement the threading from a very good Thread, here, String updateWords is declared every time the thread is triggered.

So, will this be affecting the memory?

I am declaring no. of variables, so, I am asking.

Any help will be appreciated. Thank you.

score 2 · Answer 1 · answered Nov 13 '13 at 12:53

2

You should only use global variables when the alternative is far, far worse.

Starting a Thread is 1000x more expensive than creating a reference to a String. If you are concerned about the usage of a single String, or even a small number, you shouldn't be creating a Thread at all.

Even if you have a few thousand Strings they will use the same amount of memory as global variables as they do local variables. The only differences is the global variables use heap and the local variables use the stack and heap with most of the usage still on the heap.

answered Nov 13 '13 at 12:53

Peter Lawrey

525,659
79
751
1,130

Thank you for the quick Reply.I will be using Global. If you can give more info how to image stack and heap? – Kapil M Nov 14 '13 at 01:48
I don't think that's what @PeterLawrey was saying. "Global" variables are bad because they tend to be hard to troubleshoot since anyone can change the value. If you are going to use a Global, you will need to put tight controls in place to ensure access to that variable is restricted, like making the variable private and wrapping the getter/setter in sync blocks. The expense of doing that FAR outweighs the cost of one `String` var. Plus, `String` literals in Java actually become a single value anyhow. I think you are breaking a good pattern for little or no gain. – CodeChimp Nov 14 '13 at 12:02
Yes, you are right too, about the management of the Global var and one have to take very good care of where and how it should be used. – Kapil M Nov 15 '13 at 13:58

score 0 · Answer 2 · answered Nov 13 '13 at 12:55

Good Object Oriented programming usually shys away from "global" variables, tending rather to encapsulate variables in an object. There are times when this is OK to break, like when you have constants or something, but there are patterns for that.

That said, yes, if you are creating multiple threads, each with it's own updateWords, then you would be creating more objects, and thus more garbage collection. However, since updateWords is a String, if it is set to the same value across all the Threads, Java should only create one String, since Strings are literal in Java.

but, here while is running, so, won't it be creating String over and over again? — Kapil M, Nov 14 '13 at 01:51

score 0 · Answer 3 · answered Nov 13 '13 at 12:58

0

Create a public static property, and initialize on Main Class like this:

public class foo {
    public static final string name = "Stack Overflow";
}

answered Nov 13 '13 at 12:58

Lucas Argate

329
2
11

score 0 · Answer 4 · answered Nov 13 '13 at 13:34

0

the memory will be consumed as far as the thread is not destroyed. see whether the string is property of your class (according to Object oriented design ).

answered Nov 13 '13 at 13:34

Salahuddin

1

TwoThe · Answer 5 · 2013-11-13T15:53:22.920

There are several memory areas in Java (and other languages) that are used for various tasks.

The most expensive one is the heap memory, basically everything created using the new keyword goes to the heap.
Then there is the Stack, a local "heap" so to speak, but without most of the cost associated with the creation of heap variables and therefore much faster. Almost all local variables like updateWords are located in the stack.
Registers are processor internal variables that are lightning fast. The JVM optimizer will always try to put things into internal registers whenever they fit, but since the amount of registers is very limited, only very frequently used variables go there.

But expensive means something like 0.0000000001 seconds of execution time difference between heap and register.

Then you should know what you are actually reserving when declaring a local String or any Object: a pointer. Effectively a 32/64 bit "integer" that holds the address of where to actually find the String/Object. So the instruction String updateWords = updateAuto(); will not create a new string nor copy it anywhere, all that happens is that the updateAuto() function returns a pointer ("integer") and updateWords is set to that value. This is as fast as writing int updateWords = 42 and completely done on the stack or even the register if the optimizer feels like.

Usually you should worry much more about visibility and what is most convenient/produces the least errors for your application than how the memory is organized internally. For once hand-optimization usually increases your application speed by no more than 0.0000001% and second the only stupid thing to do when reserving memory is to do it pointlessly in a loop like this:

for (int i = 0; i < 1000; ++i) {
  new MyReallyStupidMemoryWastingObject();
}

But even that is handled gracefully by the Garbage Collector (as long as you do not save all those pointers by putting them in a list or something like that).

Therefore: use globals if that simplifies your code and especially reduces bugs. Examples are global constants like enumerations or widely used string keywords. Otherwise use local or class-local variables and rely on the JVM to do things properly.

One common thing is to give the JVM a usage hint with the word final. This allows the JVM to do full optimizations on this variable, even completely removing it by putting it into a register, because it knows that you will never change it.

Should I declare variable into thread or make a global In Android?

5 Answers5