SQLite locks the entire database during a write operation (i.e. when a record occurs in any table, no other record in any table anywhere can happen at the same time). Some databases provide simultaneous writes through table-level locks, or sometimes row-level locks. To compare this with the implementation of SQLite, table-level locking basically means that when you write data to a given table, no other thread can write to any record in this table at the same time (however, writes to other tables can occur simultaneously, in some cases). Similarly, row-level locks take it even more and only allow necessary rows to be locked, which allows simultaneous writing to the same table from multiple threads. The idea here is to minimize the amount of data that needs to be locked for a write operation, which effectively increases the number of simultaneous records available in the database, and depending on your implementation / how you use your database, this may significantly increase throughput.
Now back to your question ...
The fact that SQLite is thread safe does not mean that multiple threads can write to it at the same time - it means that it has a way to handle access from multiple threads - i.e. (a) allow timeouts / retries and (b), to return a useful error (SQLITE: Busy) when the lock is currently stored in the database. That is, threadsafe means nothing more than "Multiple threads can access this data in such a way as not to damage the data due to simultaneous access."
Basically, somewhere in the code, one thread tries to perform its update before another thread releases its lock in the database. This is a common hurdle with SQLite, because the authors / documentation will tell you that SQLite can handle concurrency like a champion. The reality is that SQLite believes that “w391 support” is an attempt to be very fast, so that database locks are only retained for a very short time, and therefore database locks are released before timeouts are removed. In many cases, this works great and never bothers you. However, the presence of very short circuits is not the same as actually allowing simultaneous recording from several streams.
Think of it as how iOS does multitasking (at least with iOS 5 when I write this) - indeed, this is what other applications pause and return to. This means that (a) the battery life is much better due to lower CPU usage and (b) you do not need to start the application from scratch every time you start it. That's great, but the actual word "multitasking" used in iOS doesn't technically mean the same thing as "multitasking" in other environments (even Mac OS X).
SQLite is similar. Do they have concurrency support? Well, it seems, but the way they define the word "concurrency" does not correspond to the fact that the rest of the database world defines "concurrency".
No one is mistaken, but in such cases, it adds to the confusion of implementation.