The
art of having a bunch of
threads (
processes which exist within the same
address space) working in
tandem and generally not
mucking up each others'
data. Proper multithreading requires the artful use of
locks,
barriers and/or
pipes/
sockets, or an
algorithm which isn't
sensitive to
race conditions.
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.