Importing pandas module breaks expected behavior of Thread[ed] script
Importing pandas into a script running two thread instances, of Thread from the threading module, breaks the expected behavior. The threads do not seem to wake up after they initially start. Moving the import statement into the threaded class seems to be a workaround, in some cases, but the behavior is not documented so it might be difficult to both find the bug and implement the workaround.

#### Code Sample
Copy and paste the following sample to reproduce the issue

```python
#!/usr/bin/env python
from threading import Thread
from time import sleep

import pandas as pd # [1]
# from pandas import DataFrame # [2]

class A_Thread(Thread):
    def run(self):
        print "A is running"
        while True:
            sleep(1)
            print "A"

class B_Thread(Thread):
    def run(self):
        # import pandas as pd # [3]
        print "B is running"
        while True:
            sleep(1)
            print "B"

t1 = A_Thread()
t1.daemon = True
t1.start()

t2 = B_Thread()
t2.daemon = True
t2.start()

raw_input("Press Enter to quit...\n")
```
##### Actual Output
If I use the import statements at [1] or [2] I see this:
```
A is running
B is running
 Press Enter to quit...
```
or sometimes this:
```
A is running
B is running
Press Enter to quit...

B A
```
If I instead use import statement at [3] I see this:
```
A is running
Press Enter to quit...
B is running
A
B
A
B
```
Adding the import statement into the run method of one or the other (or both at the same time) will produce a similar result.

With statement [3] I've also encountered a segmentation fault when stopping the script (both by pressing Enter or ctrl+c), this behavior I could not reproduce though.

#### Problem description
It is a problem since one would expect that importing a module would not break the expected behavior of a script. One does not expect an import statement to cause problems, which makes it a difficult bug to find.

The expected output is better as one would not have to worry about importing a module and have the threading not work properly. Being able to only import Pandas once and have access to it in all classes in a script also seems like a basic thing to expect.

#### Expected Output
```
A is running
B is running
Press Enter to quit...
A
B
A
B
```
Where both threads have started, are printing in the while loop and has access to pandas.

#### Output of ``pd.show_versions()``

<details>
INSTALLED VERSIONS
------------------
commit: None
python: 2.7.12.final.0
python-bits: 64
OS: Linux
OS-release: 4.4.0-77-generic
machine: x86_64
processor: x86_64
byteorder: little
LC_ALL: None
LANG: en_US.UTF-8
LOCALE: en_US.UTF-8

pandas: 0.20.1
pytest: None
pip: 9.0.1
setuptools: 20.7.0
Cython: None
numpy: 1.12.1
scipy: 0.19.0
xarray: None
IPython: 5.3.0
sphinx: None
patsy: None
dateutil: 2.6.0
pytz: 2017.2
blosc: None
bottleneck: None
tables: None
numexpr: None
feather: None
matplotlib: 2.0.0
openpyxl: None
xlrd: None
xlwt: None
xlsxwriter: None
lxml: None
bs4: None
html5lib: None
sqlalchemy: None
pymysql: None
psycopg2: None
jinja2: None
s3fs: None
pandas_gbq: None
pandas_datareader: None
</details>

#### Comments
Running pandas version 0.19.2 results in expected behavior both on python 2.7.13 (on Windows 10) and python 2.7.12 (on Ubuntu 16.04, as in the print out of show_versions()). The bug seems to have been introduced in pandas 0.20.1