Question: Am newbie to thread concept. I have little confusion over thread.

What is the difference between normally calling the method and calling the method using threading. What is the use of thread.join?

Example:
In the code behind file: normally calling the method

```
Getdata();

```

By using thread am calling this methd:

```
Thread th=new Thread(new ThreadStart(Getdata));

th.Start();

```

Which one yields high performance

Answer: 
Main reason to have more than one thread is to speed up calculations. Each thread would perform one part of complex calculation, on one part of input data. If you have as many threads as there are processor cores each thread will run freely, and number of calculations per second will increase. Increasing the number of threads above this point (number of cores) will not give much benefit. Care must be taken about other parts of processor architecture (memory, processor cache, some other shared resource) so that it does not become a bottleneck and force all the threads to wait on it most of the time.

Second reason to have threads is to remove all lengthy operations away from main thread, which is usually GUI thread. Application is then more user friendly, and user will not experience window "freeze".

Third reason to have threads is to make the code both a little bit faster and simpler at the same time. Let's say you have a complex operation with your data and with shared resources (web service, database, some specialized hardware, printer), and the complex operation can be separated in several simpler operations, and parts of the operation are omitted depending on the data. You could have a "pipeline" of threads, where each thread does one simple stuff with the data, has an exclusive access to some resource, and sends the result to other thread in the pipeline. Overall process would run faster than if you would have only one thread that runs every bit data from start to the end, but the code would also not be too much complex.
Lets boil this down to a simple case. You have a dual core processor in your computer. Lets say each core can only process one thread at a time (in reality, they can switch between many, very quickly). 

In order to run two pieces of code at once, you would need 2 threads. If you simply appended the code from the 2nd thread to the end of the first, the 2nd thread would have to wait for the 1st thread's code to complete. Thread 1 is said to be *blocking*. Thread 2 is said to be *waiting*.

Threads have great application. Consider games, where the rendering of the scene is performed in a loop. Any heavy processing between each frame will cause the frame-rate to slow down. You want to avoid this. What do you do? You do your heavy processing on another thread and trust that the operating system will make the best use of the available CPU cores.