moderate to large groupby computations hang in multithreading
Since I am running calculations on very large sets of data, I have broken the data into moderate-sized chunks (using MutliIndex) and run the calculation in parallel. I first tried doing this using threading, but ended up using multiprocessing because some calculations 'hung' when I used threading. 

Here is my system information: 
## INSTALLED VERSIONS

commit: None
python: 2.7.8.final.0
python-bits: 64
OS: Windows
OS-release: 7
machine: AMD64
processor: Intel64 Family 6 Model 26 Stepping 4, GenuineIntel
byteorder: little
LC_ALL: None
LANG: None

pandas: 0.15.2
nose: 1.3.6
Cython: 0.21
numpy: 1.9.2
scipy: 0.15.1
statsmodels: 0.5.0
IPython: 2.2.0
sphinx: 1.2.3
patsy: 0.3.0
dateutil: 2.4.0
pytz: 2014.10
bottleneck: None
tables: 3.1.1
numexpr: 2.3.1
matplotlib: 1.4.0
openpyxl: 1.8.5
xlrd: 0.9.3
xlwt: 0.7.5
xlsxwriter: 0.5.7
lxml: 3.4.0
bs4: 4.3.2
html5lib: None
httplib2: None
apiclient: None
rpy2: None
sqlalchemy: 0.9.7
pymysql: None
psycopg2: 2.5.3 (dt dec pq3 ext)
## EXAMPLE

I have isolated the issue into the following example:

(this code block is the setup, I have further explanations with more code snippets following)

``` python
import numpy
import pandas
import threading


def test_fn_lock(name,data,lock,output=True):
    gp = data.groupby(level=1,sort=False)
    m = gp.mean()
    if output:
        print name + ' - before lock'
    lock.acquire()  
    data.ge(m)
    lock.release()
    if output:
        print name + ' - done'

def test_fn_no_lock(name,data,output=True):
    gp = data.groupby(level=1,sort=False)
    m = gp.mean()
    if output:
        print name + ' - before lock (no lock)'
    data.ge(m)
    if output:
        print name + ' - done'

array = ['bar', 'baz', 'foo', 'qux', 'rad','lol','other','again','diff']
dates = pandas.date_range(start='2014-01-01',end='2015-01-01')
tuples = []
for a in array:
    for d in dates:
        tuples.append((a,d))

index = pandas.MultiIndex.from_tuples(tuples, names=['first', 'second'])

cols = []
for i in xrange(100):
    cols.append("col%s" % i)

df = pandas.DataFrame(numpy.random.random((3294,100)),columns=cols,index=index)

cols = []
for i in xrange(100):
    cols.append("col%s" % (i+200))

df2 = pandas.DataFrame(numpy.random.random((3294,100)),columns=cols,index=index)

lock = threading.Lock()
```

The grouped function `ge` in `test_fn_lock` and `test_fn_no_lock` is not the only function where an issue occurs, I have also found problems with `sub`, and I assume the issue exists for `mul`, `div`, `mod`, `add`, etc. 

To demonstrate that `test_fn_lock` and `test_fn_no_lock` have no meaningful difference in performance,  I ran each of the functions for each of the DataFrames in the console: 

``` python
%timeit test_fn_lock('test', df, lock, False)
%timeit test_fn_lock('test', df2, lock, False)
%timeit test_fn_no_lock('test', df, False)
%timeit test_fn_no_lock('test', df,2 False)
```

All of them took approximately the same amount of time. 

Now to demonstrate the problem: 
If I run 

``` python
t = threading.Thread(target=test_fn_lock, args=('thread1', df, lock))
t2 = threading.Thread(target=test_fn_lock, args=('thread2', df2, lock))
t.start()
t2.start()
```

both threads finish without issue. But if I run

``` python
t = threading.Thread(target=test_fn_no_lock, args=('thread1', df))
t2 = threading.Thread(target=test_fn_no_lock, args=('thread2', df2))
t.start()
t2.start()
```

then neither thread ever finishes. 

While I could put locks around all my calculations, doing so would defeat the purpose of running them in parallel.

I think that the above situation needs to at least produce an exception so that the threads stop processing. 
