How many make threads to use?

When I (re-)build large systems on a desktop/laptop computer, I tell make to use more than one thread to speed up the compilation speed, like this:

Multi-threaded application design

I’m currently planning a Windows service. It will be a multi-threaded application which will continuously check for database records and process them. My first thoughts were to set a number of max available threads and create new thread for each process. This works OK but since I’m creating a new thread for every new process I fear that its overhead will multiply if there are lots of records to process. My question is, is this a good design or would you recommend any other solutions?

Multi cores/CPUs with locks

I’m not sure how the locks will work with multi processors/cores, I’m going to use shared memory in my application or FIFO, what worries me is the locks, I have a server with 2-CPU, how the lock will be able to lock a variable on one CPU while the another operation went to the 2nd CPU for the same variable?
I’m in Linux environment using C, I’ve searched the web for some useful info, appreciate your help

Clients with multiple proxy and multithreading callbacks

I created a sessionful web service using WCF, and in particular I used the NetTcpBinding binding. In addition to methods to initiate and terminate a session, other methods allow the client to send to one or more tasks to be performed (the results are returned via callback, so the service is duplex), but they also allow you to know the status of the service.

Lock-free IPC in Linux for multi-core processors

I’m trying to find a way to write an application with lock-free IPC on Linux, in C, with multi-core processors.

Good reasons for destroying mutexes with waiting threads

I’d like to see some valid examples of needing to let a thread enter a locked, non-re entrant mutex, then destroying the mutex (which supposedly terminates the thread).

How could one make a reasonably efficient, pointer-sized mutex?

I have my own ideas about how a pointer-sized mutex could be made: The integer is used as a set of flags, counter, index, and a spinlock that guards an entry in a table of pre-allocated kernel objects given to mutexes only when threads are contending, and released afterward (only need at most N table entries for N threads).

Algorithm for appointment reminders

My program allows users to store appointments in a calendar. What has been requested of me is the ability for SMS reminders to be sent to people to remind them of their appointment. The SMS would need to be sent out about 2 days prior to their appointment.

Cloud computing platforms often default to one CPU. Does this mean I shouldn’t use Parallel Programming?

Almost every cloud instance I can find defaults one CPU. Why is this only one CPU now, and should I expect this to increase in the future?

Multiple readers on FIFO

I’ve asked a question here before about multiple writers on a FIFO, and I know now that the write is thread safe as long as I write less than the PIPE_BIF, here is the link for that limit.