of having a bunch of thread
es which exist within the same address space
) working in tandem
and generally not muck
ing up each others' data
. Proper multithreading requires the artful use of lock
s and/or pipe
s, or an algorithm
which isn't sensitive
to race condition
The easiest way to make an object-oriented system threadsafe is to have all object classes which may be accessed by multiple threads at once only use accessor functions which lock and unlock a mutex (or similar locking device) when they begin and end. pthreads takes a lot of work out of this. However, deadlock can occur if you're not careful; the best way to avoid that is to not allow an accessor function to call another locking accessor function without first unlocking itself (which means that chained accessor functions can't be called from within a critical section).
Another good way to make things have pervasive multithreading while also adding major scalability is to make each object a server of some sort which atomically takes in and responds to requests; this is the model adopted by CORBA. However, requests are generally executed serially within each message server unless you make it multithreaded (which goes back to the first bit), and the message-passing scheme doesn't scale well to many problems.
Personally, I think that with good coding practices combined with responsible usage of object-oriented languages such as C++ or Java, it's relatively simple to make pervasively-multithreaded applications.