【linux学习】多线程（1）

线程的概念

在Linux中，线程（Thread）是程序执行流的最小单位，是进程中的一个实体，负责在程序中执行代码。线程本身不拥有系统资源，但它可以访问其所属进程的资源，包括内存空间、文件句柄等。线程与进程的主要区别在于线程是共享进程资源的，而进程之间则是独立的。

线程与进程

在Linux中，线程有时被称为轻量级进程（Lightweight Process, LWP）。从内核的角度来看，线程和进程在很大程度上是相似的，它们都通过task_struct结构体来描述。但是，线程与父进程（或其他线程）共享某些资源，如地址空间和文件描述符表，而进程则拥有自己的独立资源。

PCB（Process Control Block）即进程控制块。
虽然线程和进程都使用task_struct来描述，但Linux内核通过一些特定的字段来区分它们。例如，每个task_struct都有一个pid（进程ID）和一个tgid（线程组ID）。对于主线程（也就是我们通常所说的“进程”），其pid和tgid是相同的。但是，对于该进程创建的其他线程，它们的pid是唯一的，但tgid与主线程的tgid（也就是该进程的ID）相同。通过这种方式，内核可以区分一个task_struct描述的是进程还是线程。
进程与线程关系图：
（波浪线代表一个线程）

线程的用法

线程的创建

需要pthread_creart函数来创建线程。

#include <iostream>
#include <unistd.h>
#include <pthread.h>
void *ThreadRoutine(void *args)
{
    const char *threadname = (const char *)args;
    while (true)
    {
        std::cout << "i am a new: " << threadname << std::endl;
        sleep(1);
    }
}
int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, ThreadRoutine, (void *)"thread 1");
    while(true)
    {
        std:: cout << "i am main thread" << std::endl;
        sleep(1);
    }
    return 0;
}

看图可以得知我们创建了一个线程，主线程仍然在继续运行。

多线程

void *ThreadRoutine(void *args)
{
    const char *threadname = (const char *)args;
    while (true)
    {
        std::cout << "i am a new: " << threadname << std::endl;
        sleep(3);
    }
}
int main()
{
    pthread_t tid1;
    pthread_create(&tid1, nullptr, ThreadRoutine, (void *)"thread 1");
    sleep(3);

    pthread_t tid2;
    pthread_create(&tid2, nullptr, ThreadRoutine, (void *)"thread 2");
    sleep(3);

    pthread_t tid3;
    pthread_create(&tid3, nullptr, ThreadRoutine, (void *)"thread 3");
    sleep(3);

    pthread_t tid4;
    pthread_create(&tid4, nullptr, ThreadRoutine, (void *)"thread 4");
    sleep(3);

    while (true)
    {
        std::cout << "i am main thread" << std::endl;
        sleep(3);
    }
    return 0;
}

可以看出线程2,3,4都正常运行。

线程的等待

pthread_t thread：这是你想要等待的线程的标识符。这个标识符是在调用pthread_create时返回的。
**void retval：这是一个指向指针的指针，用于获取被等待线程的返回值。如果retval不是NULL，那么pthread_join会将终止线程的返回值放在*retval所指向的位置。如果你对线程的返回值不感兴趣，可以将这个参数设置为NULL。

#include <iostream>
#include <unistd.h>
#include <pthread.h>
void *ThreadRoutine(void *args)
{
    int cnt = 5;
    const char *threadname = (const char *)args;
    while (cnt)
    {
        std::cout << "i am a new: " << threadname << std::endl;
        sleep(1);
        cnt--;
    }
    return args;
}
int main()
{
    pthread_t tid1;
    pthread_create(&tid1, nullptr, ThreadRoutine, (void *)"thread 1");
    void *ret = nullptr;
    pthread_join(tid1,&ret);
    std:: cout << (char *)ret << std::endl;
    sleep(3);
    //while ()
    //{
        std::cout << "i am main thread" << std::endl;
        sleep(1);
    //}
    return 0;
}

在函数体内，我们将args作为返回值，可以看到将函数的返回值通过pthread_join()函数传送到ret这个指针上.

线程锁

线程锁（Thread Lock）是一种同步机制，主要用于解决多线程访问共享资源时可能出现的并发问题。

#include <iostream>
#include <unistd.h>
#include <pthread.h>
int ticket = 10000;
void *ThreadRoutine(void *args)
{
    const char *threadname = (const char *)args;
    while (ticket > 0)
    {
        std::cout << "i am : " << threadname << "getticket:" << ticket-- << std::endl;
    }
    return args;
}
int main()
{
    pthread_t tid1;
    pthread_create(&tid1, nullptr, ThreadRoutine, (void *)"thread 1");
    pthread_t tid2;
    pthread_create(&tid2, nullptr, ThreadRoutine, (void *)"thread 2");
    pthread_t tid3;
    pthread_create(&tid3, nullptr, ThreadRoutine, (void *)"thread 3");
    pthread_t tid4;
    pthread_create(&tid4, nullptr, ThreadRoutine, (void *)"thread 4");
    void *ret1 = nullptr;
    void *ret2 = nullptr;
    void *ret3 = nullptr;
    void *ret4 = nullptr;

    pthread_join(tid1, &ret1);
    pthread_join(tid2, &ret2);
    pthread_join(tid3, &ret3);
    pthread_join(tid4, &ret4);
    std::cout << "i am main thread,Finish" << std::endl;
    return 0;
}

如以上代码，我们模拟一个多个线程抢车票的的进程。代码中设计当车票为零时，则退出while循环，并且退出函数，退出线程。
但经过我们多次试验发现图下现象：

票数竟会变成负数？
假设ticket值为1当一个线程已经进入while循环内，但对于ticket值并没有做出改变，此时另一个线程就会用相同的ticket值也进入了while循环，两个进程又都进行了减减操作，导致ticket值变为-1.
这时就要用上锁，来保证多线程防止同时访问共享资源。
代码实现：

#include <iostream>
#include <unistd.h>
#include <pthread.h>
int ticket = 10000;
pthread_mutex_t lock;//全局锁
void *ThreadRoutine(void *args)
{
    const char *threadname = (const char *)args;
    pthread_mutex_lock(&lock);//上锁
    while (ticket > 0)
    {
        std::cout << "i am : " << threadname << "getticket:" << ticket-- << std::endl;
    }
    pthread_mutex_unlock(&lock);//解锁
    return args;
}
int main()
{
    pthread_mutex_init(&lock, nullptr);

    pthread_t tid1;
    pthread_create(&tid1, nullptr, ThreadRoutine, (void *)"thread 1");
    pthread_t tid2;
    pthread_create(&tid2, nullptr, ThreadRoutine, (void *)"thread 2");
    pthread_t tid3;
    pthread_create(&tid3, nullptr, ThreadRoutine, (void *)"thread 3");
    pthread_t tid4;
    pthread_create(&tid4, nullptr, ThreadRoutine, (void *)"thread 4");
    void *ret1 = nullptr;
    void *ret2 = nullptr;
    void *ret3 = nullptr;
    void *ret4 = nullptr;

    pthread_join(tid1, &ret1);
    pthread_join(tid2, &ret2);
    pthread_join(tid3, &ret3);
    pthread_join(tid4, &ret4);
    std::cout << "i am main thread,Finish" << std::endl;
    return 0;
}

通过给区间上锁，来防止多线程同时访问资源。

死锁

如上图,线程A，线程B，倘若线程A中申请到了LOCK1，而线程B中申请到了LOCK2，线程A等待LOCK2的释放，线程B等待LOCK1的释放，就会导致互相等待，两个线程都进行不下去，导致死锁
如何避免：

避免嵌套锁：尽量不在持有锁的同时请求另一个锁。如果必须这样做，确保加锁的顺序在所有线程中都是一致的。
保持锁的顺序一致：多个线程在尝试获取多个锁时，总是以相同的顺序请求它们。这可以防止循环等待条件的发生，即线程A等待线程B释放锁，而线程B又在等待线程A释放另一个锁。
使用超时机制：在尝试获取锁时设置超时。如果线程不能在规定的时间内获得锁，它将放弃并稍后重试。这可以防止线程无限期地等待，从而增加了系统的灵活性。
减少锁的粒度：尽量只锁定需要保护的最小资源范围。例如，如果你可以只锁定一个数据结构的一部分而不是整个数据结构，那么这将减少死锁的可能性。
避免长时间持有锁：尽量缩短持有锁的时间。这意味着你应该在获得锁后尽快完成你的工作并释放锁。