That's not a question we can answer from that little - the whole subject of multithreaded access is a complex one, and depends on what you are doing, how you are doing it, and what objects you use.
The problem is that not all objects are what is called "Thread safe" - which means that if two threads try to use the same object at the same time unpredictable results can occur, from data being returned wrongly, through the app crashing, right up to the data being hopelessly corrupted.
And it's because what most people thing of as an "atomic operation" in that it is a single instruction isn't in practice:
x = x + 1;
Is four operations: "Fetch the value of
", "Fetch the value of one", "Add them together", "Store the result to
" - so if two threads are accessing that single line of code together, they can be doing any of the four operations either at the same time (if they are on separate cores) or one can be "interrupted" at any point and the other runs (if they are on the same core) - either way, the result could be that x is incremented by one twice (as you'd expect), or once because one result was overwritten by the other.
That's a simple example: when you get to more complex structures than a basic integer it's gets to be orders of magnitude more complicated to work out what could be happening - hence "unpredictable results" may occur!
Threading is not (and never has been) a "magic bullet" that will make your code faster - it's a very complicated subject that needs long, hard thought before you ever go near code!
Start here: A gentle introduction to multithreading - Internal Pointers
] and expect to have to read a whole load more before you begin designing a multithreaded app!