SQLite :memory: is not working in threads
In-memory databases only exist for the connection that opened them. Peewee, by default, uses a connection-per-thread, so each thread has it's own connection (and hence its own in-memory database). You can disable this by passing `threadlocals=False` to the db when initializing it. You might also need to pass `check_same_thread=False`, which is required to use pysqlite when you're sharing a connection across threads. thanks for the clarification! If i run this:
```
db = SqliteDatabase(':memory:', threadlocals=False, check_same_thread=False)
```

I get:
```
TypeError: 'threadlocals' is an invalid keyword argument for this function
```

Can someone help me how to get it work? If you're using peewee 3.x, you do not need to pass the threadlocals keyword argument anymore. The error indicates this. But i have the same problem without passing it. You can use `thread_safe=False`. Sorry, I should have read the original issue description.

In 3.x, `thread_safe=True` means all threads have their own connection. You can pass `thread_safe=False` to make all your threads share the same connection to the underlying memory database.
The following doesn't work:

```
import datetime
import threading
import time

import peewee

from playhouse import test_utils
from playhouse import sqlite_ext

db = sqlite_ext.SqliteExtDatabase('werd.sql')
test_db = sqlite_ext.SqliteExtDatabase(':memory:')


class SomeTable(peewee.Model):

    created_at = peewee.DateTimeField(default=datetime.datetime.now)

    class Meta:
        database = test_db


threads = []


def worker():
    print('db_instance', id(SomeTable._meta.database))  # same id here
    print('SomeTable count', SomeTable.select().count())  # will fail here
    return


peewee.create_model_tables([SomeTable], fail_silently=True)

SomeTable.create()
print('db_instance', id(SomeTable._meta.database), SomeTable.select().count())

for i in range(2):
    t = threading.Thread(target=worker)
    threads.append(t)
    t.start()

    time.sleep(2)  # just so we don't exit before the worker is done
```

is SQLite in memory not meant for threading?
