Linux 多线程互斥与同步机制解析

Linux 多线程互斥与同步机制解析 | 极客日志

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#define N 5
using namespace std;

int ticket = 1000;

void* pthreadRun(void* arg) {
    char* name = static_cast<char*>(arg);
    int sum = 0;
    while (true) {
        if (ticket > 0) {
            usleep(2000);
            --ticket;
            cout << "线程:" << name << "抢票成功！" << "剩余：" << ticket << "票" << endl;
            sum++;
        } else {
            break;
        }
        usleep(2000);
    }
    cout << name << "抢了" << sum << "张票" << endl;
    delete[] name;
    return nullptr;
}

int main() {
    pthread_t pths[N];
    for (int i = 1; i <= N; ++i) {
        char* name = new char[64];
        snprintf(name, 64, "pthread-%d", i);
        pthread_create(&pths[i - 1], nullptr, pthreadRun, name);
    }
    for (int i = 1; i <= N; ++i) {
        int ret = pthread_join(pths[i - 1], nullptr);
        if (ret != 0) {
            perror("线程等待失败！");
            return 1;
        }
    }
    cout << "线程全部退出完毕" << "剩余票数:" << ticket << endl;
    return 0;
}

int ticket = 1000; // 临界资源
void* pthreadRun(void* arg) {
    char* name = static_cast<char*>(arg);
    int sum = 0;
    while (true) {
        // 临界区开始
        if (ticket > 0) {
            usleep(2000);
            --ticket;
            cout << "线程:" << name << "抢票成功！" << "剩余：" << ticket << "票" << endl;
            sum++;
        } else {
            break;
        }
        // 临界区结束
        usleep(2000);
    }
    cout << name << "抢了" << sum << "张票" << endl;
    delete[] name;
    return nullptr;
}

int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);

int pthread_mutex_destroy(pthread_mutex_t *mutex);

#include <iostream>
#include <unistd.h>
#include <pthread.h>
using namespace std;

int main() {
    pthread_mutex_t mtx; // 定义互斥锁
    pthread_mutex_init(&mtx, nullptr); // 初始化互斥锁
    // ...
    pthread_mutex_destroy(&mtx); // 销毁互斥锁
    return 0;
}

pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;

int pthread_mutex_lock(pthread_mutex_t *mutex);

int pthread_mutex_unlock(pthread_mutex_t *mutex);

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#define N 5
using namespace std;

int ticket = 10000;
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;

void* pthreadRun(void* arg) {
    char* name = static_cast<char*>(arg);
    int sum = 0;
    while (true) {
        pthread_mutex_lock(&mtx);
        if (ticket > 0) {
            usleep(2000);
            --ticket;
            cout << "线程:" << name << "抢票成功！" << "剩余：" << ticket << "票" << endl;
            sum++;
            pthread_mutex_unlock(&mtx);
        } else {
            pthread_mutex_unlock(&mtx);
            break;
        }
    }
    cout << name << "抢了" << sum << "张票" << endl;
    delete[] name;
    return nullptr;
}

int main() {
    pthread_t pths[N];
    for (int i = 1; i <= N; ++i) {
        char* name = new char[64];
        snprintf(name, 64, "pthread-%d", i);
        pthread_create(&pths[i - 1], nullptr, pthreadRun, name);
    }
    for (int i = 1; i <= N; ++i) {
        int ret = pthread_join(pths[i - 1], nullptr);
        if (ret != 0) {
            perror("线程等待失败！");
            return 1;
        }
    }
    cout << "线程全部退出完毕" << "剩余票数:" << ticket << endl;
    return 0;
}

#include <iostream>
#include <unistd.h>
#include <pthread.h>
using namespace std;

const int n = 5;
int ticket = 1000;

class ThreadData {
public:
    ThreadData(string name, pthread_mutex_t& mtx): _name(name), _mtx(mtx) {}
    ~ThreadData() {}
public: 
    string _name; 
    pthread_mutex_t& _mtx;
};

void* threadRun(void* arg) {
    ThreadData* td = static_cast<ThreadData*>(arg);
    int sum = 0;
    while (true) {
        pthread_mutex_lock(&td->_mtx);
        if (ticket > 0) {
            usleep(1000);
            ticket--;
            cout << "线程：" << td->_name << "抢票成功" << "剩余：" << ticket << "张票" << endl;
            sum++;
            pthread_mutex_unlock(&td->_mtx);
        } else {
            pthread_mutex_unlock(&td->_mtx);
            break;
        }
        usleep(1000);
    }
    cout << "线程：" << td->_name << "抢票数量：" << sum << endl;
    delete td;
    return nullptr;
}

int main() {
    pthread_t pts[n];
    pthread_mutex_t mtx;
    pthread_mutex_init(&mtx, nullptr);
    for (int i = 0; i < n; ++i) {
        char* name = new char[64];
        snprintf(name, 64, "Thread-%d", i);
        ThreadData* td = new ThreadData(name, mtx);
        pthread_create(pts + i, nullptr, threadRun, td);
    }
    for (int i = 0; i < n; ++i) {
        int ret = pthread_join(pts[i], nullptr);
        if (ret != 0) {
            perror("线程回收失败");
            return 1;
        }
    }
    pthread_mutex_destroy(&mtx);
    cout << "所有线程回收完毕，剩余票数为：" << ticket << endl;
    return 0;
}

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>

pthread_mutex_t lock1;
pthread_mutex_t lock2;

void* thread1(void* arg) {
    pthread_mutex_lock(&lock1);
    printf("Thread 1: locked lock1\n");
    sleep(1); // 模拟处理时间
    pthread_mutex_lock(&lock2);
    printf("Thread 1: locked lock2\n");
    pthread_mutex_unlock(&lock2);
    pthread_mutex_unlock(&lock1);
    return NULL;
}

void* thread2(void* arg) {
    pthread_mutex_lock(&lock2);
    printf("Thread 2: locked lock2\n");
    sleep(1); // 模拟处理时间
    pthread_mutex_lock(&lock1);
    printf("Thread 2: locked lock1\n");
    pthread_mutex_unlock(&lock1);
    pthread_mutex_unlock(&lock2);
    return NULL;
}

int main() {
    pthread_t t1, t2;
    pthread_mutex_init(&lock1, NULL);
    pthread_mutex_init(&lock2, NULL);
    pthread_create(&t1, NULL, thread1, NULL);
    pthread_create(&t2, NULL, thread2, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_mutex_destroy(&lock1);
    pthread_mutex_destroy(&lock2);
    return 0;
}

void* thread1(void* arg) {
    pthread_mutex_lock(&lock1);
    printf("Thread 1: locked lock1\n");
    pthread_mutex_lock(&lock2);
    printf("Thread 1: locked lock2\n");
    pthread_mutex_unlock(&lock2);
    pthread_mutex_unlock(&lock1);
    return NULL;
}
void* thread2(void* arg) {
    pthread_mutex_lock(&lock1);
    printf("Thread 2: locked lock1\n");
    pthread_mutex_lock(&lock2);
    printf("Thread 2: locked lock2\n");
    pthread_mutex_unlock(&lock2);
    pthread_mutex_unlock(&lock1);
    return NULL;
}

#include <pthread.h>
int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);

#include <pthread.h>
int pthread_cond_destroy(pthread_cond_t *cond);

#include <pthread.h>
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);

#include <pthread.h>
int pthread_cond_signal(pthread_cond_t *cond);

pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

#include <iostream>
#include <unistd.h>
#include <pthread.h>

int ticket = 100;
using namespace std;

const int N = 5;
// 定义全局的，自动初始化和释放
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

void* pthreadRun(void* arg) {
    char* name = static_cast<char*>(arg);
    int sum = 0;
    while (true) {
        pthread_mutex_lock(&mtx);
        if (ticket > 0) {
            // 等待条件满足
            pthread_cond_wait(&cond, &mtx);
            // usleep(2000);
            // --ticket;
            // cout << "线程:" << name << "抢票成功！" << "剩余：" << ticket << "票" << endl;
            cout << "线程:" << name << "正在抢票" << endl;
            sum++;
            pthread_mutex_unlock(&mtx);
        } else {
            pthread_mutex_unlock(&mtx);
            break;
        }
    }
    cout << name << "抢了" << sum << "张票" << endl;
    delete[] name;
    return nullptr;
}

int main() {
    pthread_t pths[N];
    for (int i = 1; i <= N; ++i) {
        char* name = new char[64];
        snprintf(name, 64, "pthread-%d", i);
        pthread_create(&pths[i - 1], nullptr, pthreadRun, name);
    }
    // 等待所有次线程就位
    sleep(1);
    // 主线程唤醒子线程
    while (true) {
        cout << "主线程正在唤起子线程!" << endl;
        pthread_cond_signal(&cond); // 单个唤醒
        sleep(1);
    }
    for (int i = 1; i <= N; ++i) {
        int ret = pthread_join(pths[i - 1], nullptr);
        if (ret != 0) {
            perror("线程等待失败！");
            return 1;
        }
    }
    cout << "线程全部退出完毕" << "剩余票数:" << ticket << endl;
    return 0;
}

Linux 多线程互斥与同步机制解析

Linux 多线程互斥与同步机制解析

1. 多线程抢票

2. 原因分析 - 资源共享问题

3. 知识补充 - 临界资源

4. 知识补充 - '锁'

5. 线程互斥

5.1 常见的线程互斥机制

5.1.1 `pthread_mutex_init` 函数

5.1.2 `pthread_mutex_destroy` 函数

5.2 加锁与解锁

5.2.1 `pthread_mutex_lock` 函数

5.2.2 `pthread_mutex_unlock` 函数

5.3 重写抢票程序

5.4 细节补充—锁是不是临界资源？

5.5 知识补充 - 死锁问题

6. 线程同步

6.1 知识补充 - 饥饿问题

6.2 条件变量

6.2.1 同步相关操作

6.2.1.1 `pthread_cond_init` 函数

6.2.1.2 `pthread_cond_destroy` 函数

6.2.1.3 `pthread_cond_wait` 函数

6.2.1.4 `pthread_cond_signal` 函数

6.3 简单的线程同步代码

7. 总结

更多推荐文章

相关免费在线工具

Linux 多线程互斥与同步机制解析

Linux 多线程互斥与同步机制解析

1. 多线程抢票

2. 原因分析 - 资源共享问题

3. 知识补充 - 临界资源

4. 知识补充 - '锁'

5. 线程互斥

5.1 常见的线程互斥机制

5.1.1 pthread_mutex_init 函数

5.1.2 pthread_mutex_destroy 函数

5.2 加锁与解锁

5.2.1 pthread_mutex_lock 函数

5.2.2 pthread_mutex_unlock 函数

5.3 重写抢票程序

5.4 细节补充—锁是不是临界资源？

5.5 知识补充 - 死锁问题

6. 线程同步

6.1 知识补充 - 饥饿问题

6.2 条件变量

6.2.1 同步相关操作

6.2.1.1 pthread_cond_init 函数

6.2.1.2 pthread_cond_destroy 函数

6.2.1.3 pthread_cond_wait 函数

6.2.1.4 pthread_cond_signal 函数

6.3 简单的线程同步代码

7. 总结

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具

5.1.1 `pthread_mutex_init` 函数

5.1.2 `pthread_mutex_destroy` 函数

5.2.1 `pthread_mutex_lock` 函数

5.2.2 `pthread_mutex_unlock` 函数

6.2.1.1 `pthread_cond_init` 函数

6.2.1.2 `pthread_cond_destroy` 函数

6.2.1.3 `pthread_cond_wait` 函数

6.2.1.4 `pthread_cond_signal` 函数