简单线程
#include <pthread.h>
#include <iostream>
void *task_a(void *arg)
{
auto no = reinterpret_cast<long int>(arg);
for (;;)
{
printf("Thread %ld precess pid: %u \t thread id = %lu\n", no, getpid(), pthread_self());
sleep(1);
}
}
void create_thread()
{
printf("Main precess pid: %u \t thread id = %lu\n", getpid(), pthread_self());
pthread_t tid;
for (int i = 0; i < 5; i++)
{
pthread_create(&tid, nullptr, task_a, reinterpret_cast<void *>(i));
}
sleep(1);
printf("Main thread exit \n");
// pthread_exit(nullptr);
// exit(0);
return;
}
带参线程
#include <pthread.h>
#include <iostream>
struct run_arg_t
{
int num;
char data[50];
};
typedef struct run_arg_t run_arg_t;
void thread_exit()
{
printf("Main precess pid: %u \t thread id = %lu\n", getpid(), pthread_self());
auto run = [](void *arg) -> void *
{
printf("this tid:%lu \n", pthread_self());
auto *runArg = (run_arg_t *) arg;
runArg->num = 123456789;
strcpy(runArg->data, "123456789");
usleep(2000);
pthread_testcancel();
pthread_exit(runArg);
return arg;
};
pthread_t tid;
pthread_attr_t attr;
pthread_attr_init(&attr);
size_t get_size;
pthread_attr_getstacksize(&attr, &get_size);
printf("thread default stack size:%ld\n", get_size);
size_t stack_size = 100000000;
void *stack = malloc(stack_size);
pthread_attr_setstack(&attr, stack, stack_size);
// pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
run_arg_t runArg = {123, "sdfsfsfsj"};
runArg.num = 1;
strcpy(runArg.data, "231423535634");
printf("num=%d, data = %s\n", runArg.num, runArg.data);
pthread_create(&tid, &attr, run, &runArg);
printf("Main tid:%lu \n", pthread_self());
printf("Child tid:%lu \n", tid);
pthread_cancel(tid);
pthread_attr_destroy(&attr);
run_arg_t *retArg;
int ret = pthread_join(tid, (void **) &retArg);
if (ret == 0)
{
printf("ret arg num=%d, data = %s\n", retArg->num, retArg->data);
} else
{
printf("detach recycle thread\n");
}
usleep(1000);
free(stack);
}
最大线程数
#include <pthread.h>
#include <iostream>
void create_max_thread()
{
struct run_arg_t
{
int num;
char data[50];
};
typedef struct run_arg_t run_arg_t;
printf("Main precess pid: %u \t thread id = %lu\n", getpid(), pthread_self());
auto run = [](void *arg) -> void *
{
printf("thread %ld tid:%lu \n", reinterpret_cast<long int>(arg), pthread_self());
// usleep(10);
for (;;);
pthread_exit(arg);
};
pthread_t tid;
void *stack = nullptr;
int ret;
for (int i = 0; i < 1000000; i++)
{
pthread_attr_t attr;
pthread_attr_init(&attr);
size_t get_size;
pthread_attr_getstacksize(&attr, &get_size);
printf("thread default stack size:%ld\n", get_size);
size_t stack_size = 100000000;
stack = malloc(stack_size);
pthread_attr_setstack(&attr, stack, stack_size);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
ret = pthread_create(&tid, &attr, run, reinterpret_cast<void *>(i));
if (ret == 0)
{
printf("create %lu thread %d \n", tid, i);
} else
{
static int count = 0;
count++;
perror(strerror(ret));
if (count < 5)
continue;
else
break;
}
pthread_attr_destroy(&attr);
}
free(stack);
}
mutex
c++版本
#include <pthread.h>
#include <iostream>
void thread_sync_mutex_whit_cxx()
{
struct Runnable
{
virtual void *run(void *) noexcept = 0;
};
struct Run : Runnable
{
pthread_mutex_t mutex;
int count;
inline Run() noexcept : count(0), mutex(pthread_mutex_t{})
{
pthread_mutex_init(&mutex, nullptr);
}
inline virtual ~Run() noexcept
{
pthread_mutex_destroy(&mutex);
}
inline void *run(void *arg) noexcept final
{
for (;;)
{
pthread_mutex_lock(&mutex);
auto index = reinterpret_cast<long>(arg);
if (index)
printf("count:%d \n", count);
else
count++;
// sleep(1);
pthread_mutex_unlock(&mutex);
}
pthread_exit(arg);
/*int ret;
for (;;)
if (ret = pthread_mutex_lock(&mutex) == 0)
{
auto index = reinterpret_cast<long>(arg);
if (index)
printf("count:%d \n", count);
else
count++;
pthread_mutex_unlock(&mutex);
} else
{
printf("Cant't lock, error:%s\n", strerror(ret));
}*/
}
inline void *operator()(void *arg) noexcept
{
return run(arg);
}
static void *running(void *arg) noexcept
{
static Run run{};
return run(arg);
}
};
pthread_t tids[2];
pthread_create(tids, nullptr, Run::running, (void *) 0);
pthread_create(tids + 1, nullptr, Run::running, (void *) 1);
usleep(1000);
pthread_join(tids[0], nullptr);
pthread_join(tids[1], nullptr);
}
纯c++版本
#include <thread>
#include <mutex>
#include <iostream>
void thread_sync_mutex_whit_pure_cxx()
{
class Running
{
virtual void run(int i) noexcept = 0;
};
class Runner : Running
{
private:
std::mutex mutex1{};
int count;
public:
Runner() : count(0) {}
inline void operator()(int i) noexcept
{
run(i);
}
inline void run(int i) noexcept override
{
for (;;)
{
mutex1.lock();
if (i % 2)
{
count++;
} else
{
std::cout << "thread id: " << std::this_thread::get_id() << "\t count = " << count << std::endl;
}
mutex1.unlock();
}
}
};
std::vector<std::thread> threads;
Runner runner{};
for (int i = 0; i < 5; i++)
{
threads.push_back(std::thread(std::ref(runner), i));
}
for (auto &th: threads)
th.join();
}
纯c版本
#include <pthread.h>
#include <iostream>
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static int count = 0;
void *running1(void *arg)
{
for (;;)
{
pthread_mutex_lock(&mutex);
count++;
pthread_mutex_unlock(&mutex);
}
pthread_exit(arg);
}
void *running2(void *arg)
{
for (;;)
{
pthread_mutex_lock(&mutex);
printf("count:%d \n", count);
pthread_mutex_unlock(&mutex);
}
pthread_exit(arg);
}
void thread_sync_mutex_with_c()
{
pthread_t tids[2];
pthread_create(tids, nullptr, running1, (void *) 0);
pthread_create(tids + 1, nullptr, running2, (void *) 1);
usleep(1000);
pthread_join(tids[0], nullptr);
pthread_join(tids[1], nullptr);
pthread_mutex_destroy(&mutex);
}
条件变量（condition）
#include <pthread.h>
#include <iostream>
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void *running_cond1(void *arg)
{
for (;;)
{
pthread_mutex_lock(&mutex);
pthread_cond_signal(&cond);
pthread_cond_wait(&cond, &mutex);
count++;
pthread_cond_signal(&cond);
pthread_mutex_unlock(&mutex);
}
pthread_exit(arg);
}
void *running_cond2(void *arg)
{
for (;;)
{
pthread_mutex_lock(&mutex);
pthread_cond_signal(&cond);
pthread_cond_wait(&cond, &mutex);
printf("count:%d \n", count);
pthread_cond_signal(&cond);
pthread_mutex_unlock(&mutex);
}
pthread_exit(arg);
}
void thread_cond_mutex_with_c()
{
pthread_t tids[2];
pthread_create(tids, nullptr, running_cond1, (void *) 0);
pthread_create(tids + 1, nullptr, running_cond2, (void *) 1);
usleep(1000);
pthread_join(tids[0], nullptr);
pthread_join(tids[1], nullptr);
pthread_mutex_destroy(&mutex);
pthread_cond_destroy(&cond);
}
信号量（semaphore）
#include <semaphore.h>
#include <pthread.h>
#include <iostream>
sem_t sem;
void *running_sem(void *arg)
{
for (;;)
{
sem_wait(&sem);
long int index = (long int) arg;
printf("thread %lu ...\n", index);
sem_post(&sem);
sleep(1);
}
pthread_exit(nullptr);
}
void thread_sem_with_c()
{
sem_init(&sem, 0, 1);
pthread_t tids[7];
for (int i = 0; i < 7; i++)
pthread_create(tids + i, nullptr, running_sem, reinterpret_cast<void *>(i));
usleep(1000);
for (int i = 0; i < 7; i++)
pthread_join(tids[i], nullptr);
sem_destroy(&sem);
}
屏障（barrier）
#include <pthread.h>
#include <iostream>
pthread_barrier_t barrier;
void *running_barrier1(void *arg)
{
sleep(1);
long int index = (long int) arg;
printf("thread %lu waiting.... \n", index);
pthread_barrier_wait(&barrier);
printf("thread %lu running.... \n", index);
for (int i = 0;; i++)
{
sleep(i % 3);
printf("thread %lu %d'th count waiting.... \n", index, i);
pthread_barrier_wait(&barrier);
printf("thread %lu %d'th count starting.... \n", index, i);
sleep(1);
count++;
pthread_barrier_wait(&barrier);
}
pthread_exit(arg);
}
void *running_barrier2(void *arg)
{
sleep(3);
long int index = (long int) arg;
printf("thread %lu waiting.... \n", index);
pthread_barrier_wait(&barrier);
printf("thread %lu running.... \n", index);
for (int i = 0;; i++)
{
sleep(i % 5);
printf("thread %lu %d'th print waiting.... \n", index, i);
pthread_barrier_wait(&barrier);
printf("thread %lu %d'th print starting.... \n", index, i);
sleep(1);
printf("thread %lu print count:%d \n", index, count);
pthread_barrier_wait(&barrier);
}
pthread_exit(arg);
}
void thread_barrier_with_c()
{
pthread_barrier_init(&barrier, nullptr, 2);
pthread_t tids[2];
pthread_create(tids, nullptr, running_barrier1, (void *) 0);
pthread_create(tids + 1, nullptr, running_barrier2, (void *) 1);
usleep(1000);
pthread_join(tids[0], nullptr);
pthread_join(tids[1], nullptr);
pthread_barrier_destroy(&barrier);
}
读写锁（rwlock）
once
网友评论