#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
void* ThreadStart(void* arg);
int main( int count, char** argv) {
pthread_t thread1, thread2;
int* threadArg1 = (int*)malloc(sizeof(int));
int* threadArg2 = (int*)malloc(sizeof(int));
*threadArg1 = 1;
*threadArg2 = 2;
pthread_create(&thread1, NULL, &ThreadStart, (void*)threadArg1 );
pthread_create(&thread2, NULL, &ThreadStart, (void*)threadArg2 );
pthread_join(thread1, NULL);
pthread_join(thread2, NULL);
free(threadArg1);
free(threadArg2);
}
void* ThreadStart(void* arg) {
int threadNum = *((int*)arg);
printf("hello world from thread %d\n", threadNum);
return NULL;
}
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <queue>
#include <semaphore.h>
#include <unistd.h>
void* ThreadStart(void* arg);
static std::queue<int> workunits;
static pthread_mutex_t workunitLock;
static sem_t workunitCount;
int main( int count, char** argv) {
pthread_t thread1, thread2;
pthread_mutex_init(&workunitLock, NULL);
sem_init(&workunitCount, 0, 0);
pthread_create(&thread1, NULL, &ThreadStart, NULL);
pthread_create(&thread2, NULL, &ThreadStart, NULL);
// Make a bunch of workunits while the threads are running.
for (int i = 0; i < 200; i++ ){
pthread_mutex_lock(&workunitLock);
workunits.push(i);
sem_post(&workunitCount);
pthread_mutex_unlock(&workunitLock);
// Pretend that it takes some effort to create work units;
// this shows that the threads really do block patiently
// while we generate workunits.
usleep(5000);
}
// Sometime in the next while, the threads will be blocked on
// sem_wait because they're waiting for more workunits. None
// of them are quitting because they never saw an empty queue.
// Pump the semaphore once for each thread so they can wake
// up, see the empty queue, and return.
sem_post(&workunitCount);
sem_post(&workunitCount);
pthread_join(thread1, NULL);
pthread_join(thread2, NULL);
pthread_mutex_destroy(&workunitLock);
sem_destroy(&workunitCount);
}
void* ThreadStart(void* arg) {
int workUnit;
bool haveUnit;
do{
sem_wait(&workunitCount);
pthread_mutex_lock(&workunitLock);
// Figure out if there's a unit, grab it under
// the lock, then release the lock as soon as we can.
// After we release the lock, then we can 'process'
// the unit without blocking everybody else.
haveUnit = !workunits.empty();
if ( haveUnit ) {
workUnit = workunits.front();
workunits.pop();
}
pthread_mutex_unlock(&workunitLock);
// Now that we're not under the lock, we can spend
// as much time as we want processing the workunit.
if ( haveUnit ) {
printf("Got workunit %d\n", workUnit);
}
}
while(haveUnit);
return NULL;
}
n <= 2 时，线程数 = n；当 2 < n <= 10 时，线程数 = n+1；当 n > 10 时，线程数 = n * 1.2。 - antiduh建议您使用线程池将解码任务交给线程池，不要自己创建和管理线程。线程池会根据系统的处理能力分配任务给尽可能多的线程。不同类型的线程池可以设置一些参数，比如强制使用特定数量的线程，或者是否允许线程池增加线程。
需要注意的是，线程数增多并不意味着它们会并行执行。正确的术语应该是同时执行，除非您保证每个线程在不同的CPU上运行（这才能实现真正的并行）
如果受阻于I/O操作，整个线程池也可能停止运行。
虽然你的问题有些含糊不清，但是怎么样考虑这个：
Create a list of audio files to convert.
While there is a free processor,
launch the decoder application with the next file in the queue.
Repeat until there is nothing else in the list
一般情况下，您可以使用线程，但锁定会有一些问题。我将以POSIX线程和锁为基础回答，但这是相当通用的，您可以将其移植到任何平台上。但如果您的工作需要任何类型的锁定，则可能会发现以下内容有用。此外，最好一直使用现有的线程，因为线程创建成本很高（请参见线程池）。
对于“实时”音频来说，锁定通常不是一个好主意，因为它会增加延迟，但对于解码/编码的实时作业来说，它们完全可以，甚至对于实时作业，您可以通过使用一些线程知识获得更好的性能并且不会丢帧。
对于音频而言，信号量是一个糟糕的选择。当我尝试使用它们时（POSIX信号量），它们在我的系统上太慢了，但如果您考虑跨线程锁定（不是在一个线程中锁定并在同一线程中解锁的类型），则需要它们。 POSIX互斥锁仅允许自锁定和自解锁（您必须在同一线程中执行两者），否则程序可能会工作，但这是未定义的行为，应该避免。
大多数无锁原子操作可能会为您提供足够的自由，以使用某些功能（如锁定），但具有更好的性能。