【lesson53】线程控制

文章目录

  • 线程控制

线程控制

线程创建
代码：
在这里插入图片描述
运行代码：
在这里插入图片描述
强调一点，线程和进程不一样，进程有父进程的概念，但在线程组里面，所有的线程都是对等关系。
在这里插入图片描述
错误检查:

  • 传统的一些函数是，成功返回0，失败返回-1，并且对全局变量errno赋值以指示错误。
  • pthreads函数出错时不会设置全局变量errno（而大部分其他POSIX函数会这样做）。而是将错误代码通过返回值返回
  • pthreads同样也提供了线程内的errno变量，以支持其它使用errno的代码。对于pthreads函数的错误，建议通过返回值业判定，因为读取返回值要比读取线程内的errno变量的开销更小

进程ID和线程ID
在Linux中，目前的线程实现是Native POSIX Thread Libaray,简称NPTL。在这种实现下，线程又被称为轻量级进程(Light Weighted Process),每一个用户态的线程，在内核中都对应一个调度实体，也拥有自己的进程描述符(task_struct结构体)。
没有线程之前，一个进程对应内核里的一个进程描述符，对应一个进程ID。但是引入线程概念之后，情况发生了变化，一个用户进程下管辖N个用户态线程，每个线程作为一个独立的调度实体在内核态都有自己的进程描述符，进程和内核的描述符一下子就变成了1：N关系，POSIX标准又要求进程内的所有线程调用
getpid函数时返回相同的进程ID，如何解决上述问题呢？
Linux内核引入了线程组的概念。
在这里插入图片描述
多线程的进程，又被称为线程组，线程组内的每一个线程在内核之中都存在一个进程描述符（task_struct）与之对应。进程描述符结构体中的pid，表面上看对应的是进程ID，其实不然，它对应的是线程ID;进程描述
符中的tgid，含义是Thread Group ID,该值对应的是用户层面的进程ID
在这里插入图片描述

线程异常
我们之前学到线程一旦异常那么整个进程都会退出，那么真的是如此吗？
演示：
代码

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

void *threadRoutine(void *arg)
{
    const std::string name = (char *)arg;
    while (true)
    {
        std::cout << name << " pid:" << getpid() << "\n"
                  << std::endl;
        
        int a = 100;
        a /= 0;//除0错误
        sleep(1);
    }

    return nullptr;
}
int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoutine, (void *)"thread 1");

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

运行代码：
在这里插入图片描述
我们发现线程一旦异常确实会影响到整个进程。

结论：
1.线程谁先运行与调度器相关
2.随便哪个线程一旦异常，都可能导致整个进程整体退出
3.线程在创建并执行的时候，线程也需要进行等待的，如果主线程不等待，也会引起类似于僵尸进程问题，导致内存泄漏。

线程等待
已经退出的线程，其空间没有被释放，仍然在进程的地址空间内。
创建新的线程不会复用刚才退出线程的地址空间。
在这里插入图片描述
调用该函数的线程将挂起等待,直到id为thread的线程终止。thread线程以不同的方法终止,通过pthread_join得到的终止状态是不同的，总结如下:

  1. 如果thread线程通过return返回,value_ ptr所指向的单元里存放的是thread线程函数的返回值。
  2. 如果thread线程被别的线程调用pthread_ cancel异常终掉,value_ ptr所指向的单元里存放的是常数PTHREAD_CANCELED。
  3. 如果thread线程是自己调用pthread_exit终止的,value_ptr所指向的单元存放的是传给pthread_exit的参数。
  4. 如果对thread线程的终止状态不感兴趣,可以传NULL给value_ ptr参数。

在这里插入图片描述

在这里插入图片描述
参数解释：
thread：线程id
retval：输出型参数，下面再解释用处
pthread_join默认阻塞等待。
代码：

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

void *threadRoutine(void *arg)
{
    const std::string name = (char *)arg;
    int i = 0;
    while (true)
    {
        std::cout << name << "runing....." << std::endl;
        sleep(1);

        if(i++ == 10)
        {
            break;
        }
    }

    std::cout << "new thread quit....." << std::endl;
    return nullptr;
}
int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoutine, (void *)"thread 1");

    pthread_join(tid,nullptr);
    std::cout << "main thread wait done .... main quit!" << std::endl;

    return 0;
}

运行代码：
在这里插入图片描述
我们知道pthread_create里面有一个回调函数，而回调函数里面有一个返回值我们之前一直返回nullptr
在这里插入图片描述
这个返回值，一般是给主线程的，那么主线程该如何获取到？用pthread_join。
在这里插入图片描述
pthread_join的第二个参数，是输出型参数，用来获取放回值的。
代码：

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

void *threadRoutine(void *arg)
{
    const std::string name = (char *)arg;
    int i = 0;
    while (true)
    {
        std::cout << name << "runing....." << std::endl;
        sleep(1);

        if (i++ == 10)
        {
            break;
        }
    }

    std::cout << "new thread quit....." << std::endl;
    return (void *)10;
}
int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoutine, (void *)"thread 1");

    void *ret = nullptr;
    pthread_join(tid, &ret);
    std::cout << "ret: " << (long long)ret << std::endl;
    std::cout << "main thread wait done .... main quit!" << std::endl;

    return 0;
}

我们运行的时候会这样
我们只要在g++后面加-fpermissive即可

g++ -o mythread mythread.cc -std=c++11 -lpthread -fpermissive

在这里插入图片描述
再运行代码：
在这里插入图片描述
可以看到，我们成功获取到了返回值。
我们不仅仅只能返回变量，我们还能返回其它内容。
代码：

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

void *threadRoutine(void *arg)
{
    const std::string name = (char *)arg;
    int i = 0;
    int *data = new int[10];
    while (true)
    {
        std::cout << name << "runing....." << std::endl;
        sleep(1);

        data[i] = i;
        if (i++ == 10)
        {
            break;
        }
    }

    std::cout << "new thread quit....." << std::endl;
    return (void *)data;
}
int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoutine, (void *)"thread 1");

    void *ret = nullptr;
    pthread_join(tid, &ret);

    int *data = (int *)ret;

    for (int i = 0; i < 10; i++)
    {
        std::cout << data[i] << " ";
    }
    std::cout << std::endl;
    std::cout << "main thread wait done .... main quit!" << std::endl;
    return 0;
}

运行结果：
在这里插入图片描述
线程终止
如果需要只终止某个线程而不终止整个进程,可以有三种方法:

  1. 从线程函数return。这种方法对主线程不适用,从main函数return相当于调用exit。
  2. 线程可以调用pthread_ exit终止自己。
  3. 一个线程可以调用pthread_ cancel终止同一进程中的另一个线程。
    能不能用exit终止线程呢？

代码：

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

void *threadRoutine(void *arg)
{
    const std::string name = (char *)arg;
    int i = 0;
    int *data = new int[10];
    while (true)
    {
        std::cout << name << "runing....." << std::endl;
        sleep(1);

        data[i] = i;
        if (i++ == 10)
        {
            break;
        }
    }

    std::cout << "new thread quit....." << std::endl;
    exit(10);
    return (void *)data;
}
int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoutine, (void *)"thread 1");

    void *ret = nullptr;
    pthread_join(tid, &ret);

    int *data = (int *)ret;

    for (int i = 0; i < 10; i++)
    {
        std::cout << data[i] << " ";
    }
    std::cout << std::endl;
    std::cout << "main thread wait done .... main quit!" << std::endl;

    return 0;
}

运行结果：
在这里插入图片描述
我们发现整个进程都被终止了，因为exit是终止进程的，绝对不要用exit终止线程。
那么我们如何终止新线程而不影响main线程呢？
pthread_exit()OS提供的终止线程的函数
在这里插入图片描述
在这里插入图片描述
参数retval就是之前的返回值。
代码

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

void *threadRoutine(void *arg)
{
    const std::string name = (char *)arg;
    int i = 0;
    int *data = new int[10];
    while (true)
    {
        std::cout << name << "runing....." << std::endl;
        sleep(1);

        data[i] = i;
        if (i++ == 10)
        {
            break;
        }
    }

    std::cout << "new thread quit....." << std::endl;
    pthread_exit((void*)data);
}
int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoutine, (void *)"thread 1");

    void *ret = nullptr;
    pthread_join(tid, &ret);

    int *data = (int *)ret;

    for (int i = 0; i < 10; i++)
    {
        std::cout << data[i] << " ";
    }
    std::cout << std::endl;
    std::cout << "main thread wait done .... main quit!" << std::endl;
    return 0;
}

运行结果：
在这里插入图片描述
我们看到线程终止成功。

线程取消
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
代码：

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

void *threadRoutine(void *arg)
{
    const std::string name = (char *)arg;
    while (true)
    {
        std::cout << name << "runing....." << std::endl;
        sleep(1);
    }

    std::cout << "new thread quit....." << std::endl;
}
int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoutine, (void *)"thread 1");

    int count = 3;
    while (true)
    {
        std::cout << "main thread pid:" << getpid() << std::endl;
        if(count++ > 5) break;
        sleep(2);
    }

    pthread_cancel(tid);
    std::cout << "pthread cancle tid: " << tid << std::endl; 

    void *ret = nullptr;
    pthread_join(tid, &ret);

    std::cout << "ret: " << (long long)ret << std::endl;
    std::cout << "main thread wait done .... main quit!" << std::endl;
    sleep(5);

    return 0;
}

运行结果：
在这里插入图片描述
我们看到最后main线程确实等待了5秒
在这里插入图片描述
然后退出了。
我们看到其中tid为啥这么大呢？之后再讲解。
而我们看到线程被取消，我们join的时候，退出码是-1.
而-1其实是：
在这里插入图片描述

线程ID的探索
我们之前看到线程ID是一个很大的值
格式化输出线程ID：
代码：

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

void *threadRoutine(void *arg)
{
    const std::string name = (char *)arg;
    while (true)
    {
        std::cout << name << "runing....." << std::endl;
        sleep(1);
    }

    std::cout << "new thread quit....." << std::endl;
}
int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoutine, (void *)"thread 1");

    printf("%u,%p\n",tid,tid);
    int count = 3;
    while (true)
    {
        std::cout << "main thread pid:" << getpid() << std::endl;
        if(count++ > 5) break;
        sleep(2);
    }

    pthread_cancel(tid);
    std::cout << "pthread cancle tid: " << tid << std::endl; 

    void *ret = nullptr;
    pthread_join(tid, &ret);

    std::cout << "ret: " << (long long)ret << std::endl;
    std::cout << "main thread wait done .... main quit!" << std::endl;
    sleep(5);
    return 0;
}

运行结果：
在这里插入图片描述
我们看到线程ID值很大，tid的本质是一个地址。
为什么tid不用Linux中的LWP呢？
因为目前用的不是Linux自带的创建线程的接口，我们用的是pthread库中的接口。
我们知道线程共享进程的地址空间
在这里插入图片描述
但是线程有自己独立的栈结构，那么如何保证栈区是每一个线程独占的呢？---->原本的栈给main线程使用，而其余线程把共享区当做栈区。所以每个线程的tid就是自己栈区的起始地址
在这里插入图片描述
见一见
在这里插入图片描述
pthread库时通过clone做到上面的那点。
在这里插入图片描述
那么我们如何获取线程的id呢？
在这里插入图片描述
代码：

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

void *threadRoutine(void *arg)
{
    const std::string name = (char *)arg;
    while (true)
    {
        std::cout << name << "runing..... id: " << pthread_self() << std::endl;
        sleep(1);

    }

    std::cout << "new thread quit....." << std::endl;
}
int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoutine, (void *)"thread 1");

    int count = 3;
    while (true)
    {
        std::cout << "main thread id:" << pthread_self() << std::endl;
        if(count++ > 5) break;
        sleep(2);
    }

    void *ret = nullptr;
    pthread_join(tid, &ret);

    std::cout << "ret: " << (long long)ret << std::endl;
    std::cout << "main thread wait done .... main quit!" << std::endl;
    sleep(5);

    return 0;
}

运行代码：
在这里插入图片描述
我们看到我们获取到了不同的线程id

大部分线程的代码是共享的！
一个小实验：
代码：

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

int g_val = 0;
void *threadRoutine(void *arg)
{
    const std::string name = (char *)arg;

    while(true)
    {
        std::cout << name << " g_val: " << g_val << " &g_val" << &g_val << std::endl;
        g_val++;
        sleep(1);
    }

}
int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoutine, (void *)"thread 1");

    while(true)
    {
        std::cout << "main thread g_val: " << g_val << " &g_val" << &g_val << std::endl;
        sleep(1);
    }

    return 0;
}

运行结果：
在这里插入图片描述
我们看到g_val被大家所共享，大家都可以看到g_val，一个线程对其进程改变，其它线程都看的到。
那么如果线程想要自己是私有的变量呢？该如何？
只要在变量前加__thread即可。
代码：

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

__thread int g_val = 0;
void *threadRoutine(void *arg)
{

    while(true)
    {
        std::cout << (char*)arg << ": "<< g_val << " &: " << &g_val << std::endl;
        g_val++;
        sleep(1);
    }
}
int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoutine, (void *)"thread 1");

    while(true)
    {
        std::cout << "main thread: " << g_val << " &: " << &g_val << std::endl;
        sleep(1);
    }

    return 0;
}

运行代码：
在这里插入图片描述
这里运行的时候是并行执行的所以会看不清，但是我们也能看到，两个变量的地址不一样的。

__thread：修饰全局变量，带来的结果就是让每一个线程各自拥有一个全局变量---->线程的就不存储。

我们之前学过进程替换，如果线程进行进程替换会如何？
代码：

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

__thread int g_val = 0;
void *threadRoutine(void *arg)
{
    execl("/bin/ls","ls",nullptr);
    while(true)
    {
        std::cout << (char*)arg << ": "<< g_val << " &: " << &g_val << std::endl;
        g_val++;
        sleep(1);
    }

}
int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoutine, (void *)"thread 1");

    while(true)
    {
        std::cout << "main thread: " << g_val << " &: " << &g_val << std::endl;
        sleep(1);
    }
    return 0;
}

运行结果：
在这里插入图片描述
我们看到ls确实被执行了，但是整个进程的代码都被替换掉了。

分离线程
默认情况下，新创建的线程是joinable的，线程退出后，需要对其进行pthread_join操作，否则无法释放资源，从而造成系统泄漏。
如果不关心线程的返回值，join是一种负担，这个时候，我们可以告诉系统，当线程退出时，自动释放线程资源。

测试代码：

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <cstdio>
#include <cerrno>
#include <cstring>

__thread int g_val = 0;
void *threadRoutine(void *arg)
{
    pthread_detach(pthread_self());
    while(true)
    {
        std::cout << (char*)arg << ": "<< g_val << " &: " << &g_val << std::endl;
        g_val++;
        sleep(1);
    }
}
int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoutine, (void *)"thread 1");

    while(true)
    {
        std::cout << "main thread: " << g_val << " &: " << &g_val << std::endl;
        sleep(1);
        break;
    }

    int n = pthread_join(tid,nullptr);
    std::cout << "n:" << n << " errstring: " << strerror(n) << std::endl;
    return 0;
}

运行结果：
在这里插入图片描述
我们看到join异常进程直接退出。

所以线程分离后线程异常也会影响整个进程

C++语言提供的线程，而语言级别的线程库必须调用原生线程库---->本质是对原生线程库的封装
代码：
在这里插入图片描述
运行：
在这里插入图片描述
进程线程间的互斥相关背景概念
临界资源：多线程执行流共享的资源就叫做临界资源
临界区：每个线程内部，访问临界自娱的代码，就叫做临界区
互斥：任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用
原子性（后面讨论如何实现）：不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完成

如果多个线程访问同一个全局变量，并对它进行数据计算，多线程会互相影响吗？
测试代码：
抢票代码

#include <iostream>
#include <thread>
#include <pthread.h>
#include <unistd.h>
#include <cstdio>
#include <cerrno>
#include <cstring>

int tickets = 10000;
void *GetTickets(void *args)
{
    while (true)
    {
        if (tickets > 0)
        {
            usleep(1000);
            printf("%p : %d\n", pthread_self(), tickets);
            tickets--;
        }
        else
        {
            break;
        }
    }

    return nullptr;
}

int main()
{
    pthread_t t1;
    pthread_t t2;
    pthread_t t3;

    pthread_create(&t1, nullptr, GetTickets, nullptr);
    pthread_create(&t2, nullptr, GetTickets, nullptr);
    pthread_create(&t3, nullptr, GetTickets, nullptr);

    pthread_join(t1, nullptr);
    pthread_join(t2, nullptr);
    pthread_join(t3, nullptr);

    return 0;
}

运行结果：
在这里插入图片描述
我们发现票抢到-1了，这肯定是错的！
每次运行的结果都不一定一样：
在这里插入图片描述
所以tickets在并发访问的时候，导致了我们数据不一致的问题。之后再解决这个歌问题。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/386685.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

TeamCity创建git项目Timed out 超时的一个解决办法

TeamCity创建git项目Timed out 超时的一个解决办法

问题&#xff1a; 当自己&#xff1a; ping github.com从本地推送到远程仓库浏览器浏览www.github.com ——都没有问题 但是在teamcity创建工程的时候就超时&#xff1a; 或者多试几次&#xff0c;终于成功了&#xff0c;然后构建的时候半途超时报错。。。。。 一种解决办…
阅读更多...
Spring GateWay

Spring GateWay

概述简介 能干什么 反向代理 鉴权 流量控制 熔断 日志监控 Spring Cloud Gateway 与Zuul的区别 在SpringCloud Finchley正式版之前&#xff0c;Spring Cloud推荐的网关是 Netflix提供的Zuul: 1、Zuul 1.x&#xff0c;是一个基于阻塞Ⅳ/O的APl Gateway 2、Zuul 1.x基于Servl…
阅读更多...
linux系统zabbix监控配置钉钉告警

linux系统zabbix监控配置钉钉告警

zabbix配置钉钉告警 配置钉钉告警环境准备配置钉钉脚本文件钉钉日志目录编写脚本浏览器配置钉钉告警中文消息告警模版为用户添加报警媒介添加监控项》添加触发器》 添加玩监控项和触发器后添加动作 配置钉钉告警 环境准备 创建钉钉内部群创建自定义机器人记录加签地址和webho…
阅读更多...
thinkphp5.0提示不支持redis,not support: redis

thinkphp5.0提示不支持redis,not support: redis

安装PHP扩展 例如宝塔&#xff0c;其他环境请用命令行&#xff0c;安装 redis配置完成以后&#xff0c;修改php.ini把redis扩展打开即可&#xff0c;重启环境
阅读更多...
【AI视野·今日CV 计算机视觉论文速览 291期】Wed, 17 Jan 2024

【AI视野·今日CV 计算机视觉论文速览 291期】Wed, 17 Jan 2024

AI视野今日CS.CV 计算机视觉论文速览 Wed, 17 Jan 2024 Totally 182 papers &#x1f449;上期速览✈更多精彩请移步主页 Daily Computer Vision Papers MultiPLY: A Multisensory Object-Centric Embodied Large Language Model in 3D World Authors Yining Hong, Zishuo Zhe…
阅读更多...
深入探索Pandas读写XML文件的完整指南与实战read_xml、to_xml【第79篇—读写XML文件】

深入探索Pandas读写XML文件的完整指南与实战read_xml、to_xml【第79篇—读写XML文件】

深入探索Pandas读写XML文件的完整指南与实战read_xml、to_xml XML&#xff08;eXtensible Markup Language&#xff09;是一种常见的数据交换格式&#xff0c;广泛应用于各种应用程序和领域。在数据处理中&#xff0c;Pandas是一个强大的工具&#xff0c;它提供了read_xml和to…
阅读更多...
第二十八回 施恩重霸孟州道 武松醉打蒋门神-可用于生产环境的Python Web框架：Pyramid

第二十八回 施恩重霸孟州道 武松醉打蒋门神-可用于生产环境的Python Web框架：Pyramid

施恩给武松讲了他的烦心事&#xff0c;他在快活林的酒肉店被蒋门神霸占了。希望武松能帮他出气。施恩的父亲也从屏风后走出来&#xff0c;让施恩拜武松为兄长。 武松要去打蒋门神&#xff0c;跟施恩约好了“无三不过望”&#xff0c;望子就是酒旗&#xff0c;意思看到酒旗就要…
阅读更多...
H12-821_74

H12-821_74

74.在某路由器上查看LSP&#xff0c;看到如下结果&#xff1a; A.发送目标地址为3.3.3.3的数据包时&#xff0c;打上标签1026&#xff0c;然后发送。 B.发送目标地址为4.4.4.4的数据包时&#xff0c;不打标签直接发送。 C.当路由器收到标签为1024的数据包&#xff0c;将把标签…
阅读更多...
【JavaEE】_HTTP请求与响应

【JavaEE】_HTTP请求与响应

目录 1. HTTP协议 1.1 HTTP简介 1.2 Fiddler 2. HTTP请求 2.1 首行 2.2 请求头&#xff08;header&#xff09; 2.3 空行 2.4 正文&#xff08;body&#xff09; 3. HTTP响应 3.1 首行 3.2 响应头&#xff08;header&#xff09; 3.3 空行 3.4 正文&#xff08;bo…
阅读更多...
跟廖雪峰老师学习Git（持续更新）

跟廖雪峰老师学习Git（持续更新）

Git简介 创建版本库 第一步&#xff0c;创建一个新目录 第二步&#xff0c;通过git init变成Git可以管理的仓库 把文件添加到文本库&#xff0c;不要使用Windows自带的记事本&#xff01; 我用的是VS code 创建readme.txt 放入库中 commit可以一次提交很多文件&#xff0…
阅读更多...
酒店押金预授权怎么开通？微信酒店押金+房态+门锁关联 +电子押金单 解决方案

酒店押金预授权怎么开通？微信酒店押金+房态+门锁关联 +电子押金单 解决方案

一、酒店押金管理有哪些&#xff1f; 1.渠道有银行预授权 2.微信押金支付 3.酒店押金系统 4.支付押金管理 二、银行预授权模式 酒店押金预授权通常是在客人办理入住时进行的&#xff0c;酒店会要求客人提供信用卡或借记卡的卡号、有效期、持卡人姓名等信息&#xff0c;然后…
阅读更多...
Django学习全纪录：Django开发环境的搭建

Django学习全纪录：Django开发环境的搭建

导言 对于Django&#xff0c;它是Python的一个开发框架&#xff0c;之前系统地学习过。遗憾的是&#xff0c;对于一些遇到的问题&#xff0c;没有及时地记录下来。因此&#xff0c;我将它重新捡起&#xff0c;进行学习和实践。从搭建环境开始&#xff0c;重新去学习它&#xff…
阅读更多...
应用进程跨越网络的通信

应用进程跨越网络的通信

目录 1 系统调用和应用编程接口 应用编程接口 API 几种应用编程接口 API 套接字的作用 几种常用的系统调用 1. 连接建立阶段 2. 传送阶段 3. 连接释放阶段 1 系统调用和应用编程接口 大多数操作系统使用系统调用 (system call ) 的机制在应用程序和操作系统之间传递控制…
阅读更多...
Kafka 之生产者（Producer）

Kafka 之生产者（Producer）

目录 一. 前言 二. 生产消息 三. 幂等和事务 四. send() 发送消息 五. 原理解析 一. 前言 Kafka生产者是一个应用程序&#xff0c;它负责向 Kafka 主题发送消息。这些消息可以用于多种目的&#xff0c;如记录用户活动、收集物联网设备数据、保存日志消息或缓存即将写入数据…
阅读更多...
66万个 全国行政区划代码表

66万个 全国行政区划代码表

66万个全国各级行政区划代码表 提供的数据一览 简介 一共有66万个全国各级行政区划&#xff0c;一共有5个级别的行政单位级别 表格头部数据 表格尾部数据 全国行政单位各省份数量统计 数据下载地址 数据整理不易 百度云盘 链接: https://pan.baidu.com/s/1o1C2piYj2wu…
阅读更多...
C#，数值计算，矩阵的行列式（Determinant）、伴随矩阵（Adjoint）与逆矩阵（Inverse）的算法与源代码

C#，数值计算，矩阵的行列式（Determinant）、伴随矩阵（Adjoint）与逆矩阵（Inverse）的算法与源代码

本文发布矩阵&#xff08;Matrix&#xff09;的一些初级算法。 一、矩阵的行列式&#xff08;Determinant&#xff09; 矩阵行列式是指矩阵的全部元素构成的行列式&#xff0c;设A(a)是数域P上的一个n阶矩阵&#xff0c;则所有A(a)中的元素组成的行列式称为矩阵A的行列式&…
阅读更多...
仰暮计划|“​他们艰苦半生，但真的希望祖国安祥，山河无恙”

仰暮计划|“​他们艰苦半生，但真的希望祖国安祥，山河无恙”

自述&#xff0c;自赎 我没有在那个年代生活过&#xff0c;我一出生就是盛世中国&#xff0c;看遍了祖国的大好河山。但我没想到&#xff0c;走了这么远的路&#xff0c;吃了这么多的苦的爷爷会一直跟我说“不是国家不好&#xff0c;只是中国的钱拿去还债了&#xff0c;过了那…
阅读更多...
Linux释放内存

Linux释放内存

free -m是Linux上查看内存的指令&#xff0c;其中-m是以兆&#xff08;MB&#xff09;为单位&#xff0c;如果不加则以KB为单位。 如下图表示&#xff0c;&#xff08;total&#xff09;总物理内存是809MB&#xff0c;&#xff08;used&#xff09;已使用167MB&#xff0c;&…
阅读更多...
零基础学Python（10）— 序列通用操作

零基础学Python（10）— 序列通用操作

前言&#xff1a;Hello大家好&#xff0c;我是小哥谈。本节课就带大家认识下Python语言中常见的序列通用操作&#xff01;~&#x1f308; 目录 &#x1f680;1.索引 &#x1f680;2.切片 &#x1f680;3.序列加法 &#x1f680;4.序列乘法 &#x1f680;5.检查某个元素是…
阅读更多...
Python：Pygame游戏编程简述

Python：Pygame游戏编程简述

Python是一种广泛使用的编程语言&#xff0c;它简洁、易懂并且功能强大。在Python的世界中&#xff0c;有许多库和模块可供选择&#xff0c;其中之一就是Pygame。Pygame是一个Python库&#xff0c;用于开发2D游戏&#xff0c;它提供了许多工具和函数&#xff0c;使得游戏开发变…
阅读更多...
最新文章

Copyright @ 2022~2023