Linux线程概念和控制

Linux线程概念

Linux中线程如何理解

线程<=执行流<=进程

Linux中的线程模拟进程实现（线程就是轻量级进程）

与独立的进程相比，线程创建和销毁的开销较小，因为它们共享相同的内存空间和资源。

线程是进程内的执行分支，线程的执行粒度比进程要细（只需要运行一部分代码）

我们认为线程是操作系统调度的基本单位（进程内部执行流资源）

进程：承担分配系统资源的实体（分给线程）

Linux中用进程的内核数据结构模拟线程

在一个程序里的一个执行路线就叫做线程（thread）。更准确的定义是：线程是“一个进程内部的控制序列”

一切进程至少都有一个执行线程

线程在进程内部运行，本质是在进程地址空间内运行（任何执行流都要有资源，地址空间是资源窗口）

在Linux系统中，在CPU眼中，看到的PCB都要比传统的进程更加轻量化

透过进程虚拟地址空间，可以看到进程的大部分资源，将进程资源合理分配给每个执行流，就形成了线程 执行流

页表也有寄存器，帮忙找到页表 

地址空间：进程的资源窗口（进程通过地址空间看到资源）

如何理解资源分配给线程

线程分配资源本质就是分配地址空间范围

虚拟地址不是一个整体（分为10+10+12）

页表也不是一整块，被拆成了三部分，第一个10查找第一个页表（因为是全0——全1，直接充当了页表的下标）

一级页表（页目录）里存二级页表地址

二级页表存放页框起始地址

前两个找到页框

12的那个部分在页框内进行索引（偏移量）找到制定物理内存

访问虚拟地址时，虚拟地址有没有调用内存：

1.查页目录时，2级页表不存在（中间10位），没用被加载到内存就发生缺页中断，二级页表和页框没有建立映射关系

2.内存管理基本单位：4kb

c/c++中任意一个变量只有一个地址（取第一个字节为起始地址找偏移量。我们的地址只拿第一个就可以拿到数据（即使数据好几个字节），起始地址+类型=起始地址+偏移量

cr2寄存器存放上次引起缺页中断异常的虚拟地址 

cr3寄存器存放页目录的地址（页表创建好后可以没有后边两个，但是页目录一定要有）

Linux线程周边概念

创建线程只要创建pcb即可，只有最后一个pcb被干掉才会释放

线程在切换时一定要有上下文（页表地址空间不用切换）

线程执行的本质：进程调度

cache中的在进程切换时会更改

线程被创建时也有自己的时间片（来自进程）（不能重新分配）=》进程总时间片不变 

线程的优点

创建一个新线程的代价要比创建一个新进程小得多

与进程之间的切换相比，线程之间的切换需要操作系统做的工作要少很多

线程占用的资源要比进程少很多

能充分利用多处理器的可并行数量

在等待慢速I/O操作结束的同时，程序可执行其他的计算任务

计算密集型应用，为了能在多处理器系统上运行，将计算分解到多个线程中实现

I/O密集型应用，为了提高性能，将I/O操作重叠。线程可以同时等待不同的I/O操作。

线程的缺点

性能损失

一个很少被外部事件阻塞的计算密集型线程往往无法与共它线程共享同一个处理器。如果计算密集型 线程的数量比可用的处理器多，那么可能会有较大的性能损失，这里的性能损失指的是增加了额外的 同步和调度开销，而可用的资源不变。

健壮性降低

编写多线程需要更全面更深入的考虑，在一个多线程程序里，因时间分配上的细微偏差或者因共享了 不该共享的变量而造成不良影响的可能性是很大的，换句话说线程之间是缺乏保护的。

缺乏访问控制

进程是访问控制的基本粒度，在一个线程中调用某些OS函数会对整个进程造成影响。

编程难度提高

编写与调试一个多线程程序比单线程程序困难得多

线程异常

单个线程如果出现除零，野指针问题导致线程崩溃，进程也会随着崩溃

线程是进程的执行分支，线程出异常，就类似进程出异常，进而触发信号机制，终止进程，进程终止，该进程内的所有线程也就随即退出

线程用途

合理的使用多线程，能提高CPU密集型程序的执行效率

合理的使用多线程，能提高IO密集型程序的用户体验（如生活中我们一边写代码一边下载开发工具，就是多线程运行的一种表现）

Linux进程VS线程

进程是资源分配的基本单位

线程是调度的基本单位

线程共享进程数据，但也拥有自己的一部分数据: 线程ID 一组寄存器 栈 errno 信号屏蔽字 调度优先级

进程具有独立上下文（独立运行）和栈（运行时变量数据（临时））（线程执行不会出现错乱）

进程的多个线程共享 同一地址空间,因此Text Segment、Data Segment都是共享的,如果定义⼀个函数,在各线程中都可以调⽤,如果定义⼀个全局变量,在各线程中都可以访问到,除此之外,各线程还共享以下进程资源和环境：

⽂件描述符表
每种信号的处理⽅式(SIG_ GN、SIG_DFL或者⾃定义的信号处理函数)
当前⼯作⽬录
⽤⼾ id 和组 id
进程和线程的关系如下图：

Linux线程控制 

线程创建

Linux中没有很明确的线程概念，有轻量级进程概念，故没有直接提供线程的系统调用接口

我们需要使用第三方的pthread库

pthread_t *thread:输出型参数（thread id）

const pthread_atte_t（线程的属性）设为nullptr即可

void*(*start_routine)(void*)新线程执行入口函数，将函数入口地址传进来可以调用函数

void *arg：创建线程成功，新线程回调线程函数的时候，需要参数，这个参数就是给线程函数传递的 

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

LWP是系统层次概念，用户只用知道线程id

ps -aL查看所有轻量级进程

示例代码：

#include<iostream>
#include<unistd.h>
#include<pthread.h>using namespace std;
void* threadrun(void* args)
{while(1){cout<<"new thread:"<<getpid()<<endl;sleep(1);}return nullptr;
}int main()
{pthread_t tid;pthread_create(&tid,nullptr,threadrun,nullptr);while(1){cout<<"main thread"<<getpid()<<endl;sleep(1);}return 0;
}

问题分析

  1. 输出混乱的表现：

    • 输出内容混在一起（如"main thread201314new thread:"）

    • 换行符位置不正确

    • 输出顺序不可预测

  2. 根本原因：

    • 主线程和新线程同时向标准输出(stdout)写入数据

    • cout不是线程安全的，多个线程同时使用会导致输出内容交叉

    • 线程调度由操作系统决定，执行顺序不确定

  3. 具体解释：

    • cout << "main thread" << getpid() << endl; 不是原子操作

    • 它实际上分为多个步骤：

      1. 输出"main thread"

      2. 调用getpid()

      3. 输出PID值

      4. 输出换行符

    • 在这些步骤之间，另一个线程可能插入自己的输出

在后续可以用互斥锁保护输出

线程等待 

为什么需要线程等待？ 已经退出的线程，其空间没有被释放，仍然在进程的地址空间内。 创建新的线程不会复用刚才退出线程的地址空间。

在多线程程序中，主线程最后退出是良好的编程实践，主要原因包括：

  1. 资源管理：确保所有子线程完成资源释放

  2. 结果收集：获取子线程的执行结果或状态

  3. 程序稳定性：避免子线程因主线程退出而意外终止

  4. 有序关闭：实现优雅的进程终止流程

#include<iostream>
#include<unistd.h>
#include<pthread.h>using namespace std;int g_val = 100;
void show(const string& name)
{cout<<name<<"say:"<<"hello thread"<<endl;
}void *threadrun(void *args)
{const char *name = (const char*)args;int cnt = 5;while (true){printf("%s,  pid: %d, g_val: %d, &g_val: 0x%p\n", name,getpid(), g_val, &g_val);sleep(1);// int a = 10;// a /= 0;cnt--;if(cnt == 0) break;}return nullptr;
}int main()
{pthread_t tid;pthread_create(&tid,nullptr,threadrun,nullptr);// while(1)// {//     cout<<"main thread"<<getpid()<<endl;//     sleep(1);// }sleep(5);pthread_join(tid,nullptr);cout<<"main thread quit"<<endl;return 0;
}

任何变量传参都会产生临时变量

返回值的拿到要用二级指针，因为返回类型是void*

 线程终止

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参数。

return

#include<iostream>
#include<unistd.h>
#include<pthread.h>using namespace std;int g_val = 100;
void show(const string& name)
{cout<<name<<"say:"<<"hello thread"<<endl;
}void *threadrun(void *args)
{const char *name = (const char*)args;int cnt = 5;while (true){printf("%s,  pid: %d, g_val: %d, &g_val: 0x%p\n", name,getpid(), g_val, &g_val);sleep(1);// int a = 10;// a /= 0;cnt--;if(cnt == 0) break;}return (void*)1;
}int main()
{pthread_t tid;pthread_create(&tid,nullptr,threadrun,nullptr);// while(1)// {//     cout<<"main thread"<<getpid()<<endl;//     sleep(1);// }//sleep(5);void *retval;pthread_join(tid,&retval);//cout<<"main thread quit"<<endl;cout << "main thread quit ..., ret: " << (long long int)retval << endl;return 0;
}

 等待默认阻塞等待，不考虑异常情况（异常是进程考虑的）任何一个线程出异常整个进程都要被干掉，无法返回

exit是终止进程的，不能用来终止线程，任何一个线程调用exit直接整个进程退出了

可以用pthread_exit退出

void *threadrun(void *args)
{const char *name = (const char*)args;int cnt = 5;while (true){printf("%s,  pid: %d, g_val: %d, &g_val: 0x%p\n", name,getpid(), g_val, &g_val);sleep(1);// int a = 10;// a /= 0;cnt--;if(cnt == 0) break;}pthread_exit((void*)100);
}

线程取消 

#include<iostream>
#include<unistd.h>
#include<pthread.h>using namespace std;int g_val = 100;
void show(const string& name)
{cout<<name<<"say:"<<"hello thread"<<endl;
}void *threadrun(void *args)
{const char *name = (const char*)args;int cnt = 5;while (true){printf("%s,  pid: %d, g_val: %d, &g_val: 0x%p\n", name,getpid(), g_val, &g_val);sleep(1);// int a = 10;// a /= 0;cnt--;if(cnt == 0) break;}//pthread_exit((void*)100);
}int main()
{pthread_t tid;pthread_create(&tid,nullptr,threadrun,nullptr);sleep(1);pthread_cancel(tid);return 0;
}

 

线程的参数和返回值不仅可以传递一般参数，也可以传递对象

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include <string>using namespace std;class ThreadCalculator {
public:// 请求结构体struct Request {int start;int end;string threadname;Request(int s, int e, const string &name) : start(s), end(e), threadname(name) {}};// 响应结构体struct Response {int result;int exitcode;Response(int r = 0, int e = 0) : result(r), exitcode(e) {}};// 静态线程函数static void* threadFunc(void* arg) {Request* req = static_cast<Request*>(arg);Response* resp = new Response();for(int i = req->start; i <= req->end; ++i) {cout << req->threadname << " is running, calculating... " << i << endl;resp->result += i;usleep(100000); // 100ms延迟}delete req;return resp;}// 启动计算Response calculate(int start, int end, const string& name) {pthread_t tid;Request* req = new Request(start, end, name);pthread_create(&tid, nullptr, &ThreadCalculator::threadFunc, req);void* ret;pthread_join(tid, &ret);Response* resp = static_cast<Response*>(ret);Response result = *resp;delete resp;return result;}
};int main() {ThreadCalculator calculator;auto result = calculator.calculate(1, 100, "Worker Thread");cout << "Calculation result: " << result.result << ", Exit code: " << result.exitcode << endl;return 0;
}

语言已经把系统调用封装了

// 目前，我们的原生线程，pthread库，原生线程库
// // C++11 语言本身也已经支持多线程了 vs 原生线程库
void threadrun()
{while(true){cout << "I am a new thead for C++" << endl;sleep(1);}
}int main()
{thread t1(threadrun);t1.join();return 0;
}

线程id 

pthread_ create函数会产生一个线程ID，存放在第一个参数指向的地址中。该线程ID和前面说的线程ID 不是一回事。

前面讲的线程ID属于进程调度的范畴。因为线程是轻量级进程，是操作系统调度器的最小单位，所以需要 一个数值来唯一表示该线程。

pthread_ create函数第一个参数指向一个虚拟内存单元，该内存单元的地址即为新创建线程的线程ID， 属于NPTL线程库的范畴。线程库的后续操作，就是根据该线程ID来操作线程的。

线程库NPTL提供了pthread_ self函数，可以获得线程自身的ID：

#include <iostream>
#include <string>
#include <pthread.h>
#include <cstdlib>
#include <unistd.h>using namespace std;std::string toHex(pthread_t tid)
{char hex[64];snprintf(hex, sizeof(hex), "%p", tid);return hex;
}void *threadRoutine(void *args)
{while(true){cout << "thread id: " << toHex(pthread_self()) << endl;sleep(1);}
}int main()
{pthread_t tid;pthread_create(&tid, nullptr, threadRoutine, (void*)"thread 1");cout << "main thread create thead done, new thread id : " << toHex(tid) << endl;pthread_join(tid, nullptr);return 0;
}

 线程的概念是库给我们维护的，注定了线程库要维护多个线程属性集合，线程库要管理这些线程

原始线程库要加载到内存中

每一个线程的库级别的tcb的其实地址叫做线程的tid

除了主线程，其他线程的独立栈都在共享区，具体来说是pthread库中，tid指向的用户tcb中

tid指向的那一块就是tcb

每个线程是个执行流，为了不让受干扰，每个执行流要有自己的栈结构

多线程

__thread编译选项

只能定义内置类型，可以在线程启动前获得想要的属性，在线程内直接获取即可，不用再调系统调用了

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <vector>
#include <string>using namespace std;// 使用__thread修饰的线程局部变量
__thread int g_val = 100;void* threadRoutine(void* args) {int thread_num = *(int*)args;// 每个线程有自己的g_val副本g_val += thread_num;cout << "Thread " << thread_num << ": g_val = " << g_val << ", address: " << &g_val << endl;return nullptr;
}int main() {vector<pthread_t> tids;const int NUM = 3;for (int i = 0; i < NUM; i++) {pthread_t tid;int* arg = new int(i);pthread_create(&tid, nullptr, threadRoutine, arg);tids.push_back(tid);}for (auto tid : tids) {pthread_join(tid, nullptr);}cout << "Main thread g_val: " << g_val << endl;return 0;
}

全局变量是共享的：

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <vector>
#include <string>using namespace std;// 全局变量，所有线程共享
int g_val = 100;void* threadRoutine(void* args) {int thread_num = *(int*)args;// 每个线程都会修改同一个全局变量g_val += thread_num;cout << "Thread " << thread_num << ": g_val = " << g_val << ", address: " << &g_val << endl;sleep(1);return nullptr;
}int main() {vector<pthread_t> tids;const int NUM = 3;for (int i = 0; i < NUM; i++) {pthread_t tid;int* arg = new int(i);pthread_create(&tid, nullptr, threadRoutine, arg);tids.push_back(tid);sleep(1);}for (auto tid : tids) {pthread_join(tid, nullptr);}cout << "Final g_val: " << g_val << endl;return 0;
}

 

 每个线程有自己的栈空间

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <vector>using namespace std;// 全局变量，用于存储线程栈变量的地址
vector<void*> g_stack_addresses;void* threadRoutine(void* args) {int thread_num = *(int*)args;// 局部变量（栈变量）int stack_var = thread_num * 100;cout << "Thread " << thread_num << ": stack_var address = " << &stack_var << ", value = " << stack_var << endl;// 保存栈变量地址到全局vector（仅用于演示，实际开发中要小心）g_stack_addresses.push_back(&stack_var);// 模拟线程工作sleep(1);// 注意：这里stack_var的地址在函数返回后将无效// 只是演示每个线程有自己的栈空间return nullptr;
}int main() {const int NUM = 3;vector<pthread_t> tids;// 主线程的栈变量int main_stack_var = 999;cout << "Main thread: stack_var address = " << &main_stack_var << endl;// 创建子线程for (int i = 0; i < NUM; i++) {pthread_t tid;int* arg = new int(i); // 动态分配，避免栈地址共享问题pthread_create(&tid, nullptr, threadRoutine, arg);tids.push_back(tid);}// 等待所有线程结束for (auto tid : tids) {pthread_join(tid, nullptr);}// 打印所有线程的栈变量地址cout << "\nAll stack variable addresses:" << endl;for (size_t i = 0; i < g_stack_addresses.size(); i++) {cout << "Thread " << i << " stack_var @ " << g_stack_addresses[i] << endl;}return 0;
}

主线程和每个子线程数据地址不同 

但是栈与栈之间没有秘密

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <vector>
#include <string>using namespace std;// 全局指针，用于演示栈共享的危险性
int* shared_ptr = nullptr;void* threadRoutine(void* args) {int thread_num = *(int*)args;int stack_var = thread_num * 10; // 栈变量if (thread_num == 1) {shared_ptr = &stack_var; // 线程1将自己的栈变量地址暴露出去}sleep(1); // 确保线程1先运行if (thread_num == 2) {// 线程2尝试访问线程1的栈变量（危险！）if (shared_ptr) {cout << "Thread 2 accessing Thread 1's stack: " << *shared_ptr << endl;}}return nullptr;
}int main() {pthread_t t1, t2;int num1 = 1, num2 = 2;pthread_create(&t1, nullptr, threadRoutine, &num1);pthread_create(&t2, nullptr, threadRoutine, &num2);pthread_join(t1, nullptr);pthread_join(t2, nullptr);return 0;
}

线程分离 

默认情况下，新创建的线程是joinable的，线程退出后，需要对其进行pthread_join操作，否则无法释放资源，从而造成系统泄漏。

如果不关心线程的返回值，join是一种负担，这个时候，我们可以告诉系统，当线程退出时，自动释放线程资源。

线程的分离可以由主线程来做也可以由线程自己分离

共享一部分资源但不是“一家人”了，出了问题由系统自动回收

示例代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <unistd.h>
#include <pthread.h>using namespace std;#define NUM 3// int *p = NULL;// __thread int g_val = 100;
__thread unsigned int number = 0;
__thread int pid = 0;struct threadData
{string threadname;
};// __thread threadData td;string toHex(pthread_t tid)
{char buffer[128];snprintf(buffer, sizeof(buffer), "0x%lx", tid);return buffer;
}void InitThreadData(threadData *td, int number)
{td->threadname = "thread-" + to_string(number); // thread-0
}// 所有的线程，执行的都是这个函数？
void *threadRoutine(void *args)
{pthread_detach(pthread_self());// int test_i = 0;threadData *td = static_cast<threadData *>(args);// if(td->threadname == "thread-2") p = &test_i;string tid = toHex(pthread_self());int pid = getpid();int i = 0;while (i < 10){cout << "tid: " << tid << ", pid: " << pid << endl;// cout << "pid: " << getpid() << ", tid : "//     << toHex(number) << ", threadname: " << td->threadname//         << ", g_val: " << g_val << " ,&g_val: " << &g_val <<endl;sleep(1);i++;}delete td;return nullptr;
}int main()
{// 创建多线程！vector<pthread_t> tids;for (int i = 0; i < NUM; i++){pthread_t tid;threadData *td = new threadData;InitThreadData(td, i);pthread_create(&tid, nullptr, threadRoutine, td);tids.push_back(tid);//sleep(1);}sleep(1); // 确保复制成功// for(auto i : tids)// {//     pthread_detach(i);// }// cout << "main thread get a thread local value, val: " << *p << ", &val: " << p << endl;for (int i = 0; i < tids.size(); i++){int n = pthread_join(tids[i], nullptr);printf("n = %d, who = 0x%lx, why: %s\n", n, tids[i], strerror(n));}return 0;
}

 

关键特性

特性描述
自动资源回收分离线程终止后系统自动回收其资源（线程ID、栈等）
不可连接（join）分离后不能再使用pthread_join等待该线程
立即生效性若线程已终止，分离操作会立即触发资源回收

使用场景

  1. 不需要获取线程返回值时

  2. 不关心线程何时结束时

  3. 需要避免僵尸线程（类似僵尸进程的概念）

注意事项

  1. 不要重复分离：对同一线程多次detach会导致未定义行为

  2. 分离后禁止join：尝试join已分离线程会返回EINVAL错误

  3. 主线程退出影响：若主线程先退出，分离的子线程也会被强制终止

  4. 资源释放时机：分离线程的资源释放可能稍有延迟（由系统调度决定）

  5. 分离操作是不可逆的

分离 vs 非分离线程对比

特性分离线程非分离线程（默认）
资源回收自动需手动pthread_join
可连接性不可join可join
线程返回值无法获取可通过pthread_join获取
僵尸线程风险无未join时会产生

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

服务器出现问题，连接服务器出现3680 并删除数据库出现1192，请查看详细问题（运维）

服务器出现问题，连接服务器出现3680 并删除数据库出现1192，请查看详细问题（运维）

mysql连接服务器时&#xff0c;出现这个问题&#xff1a;3680 - Failed to create schema directory xxxx (errno: 28 - No space left on device) 第一步&#xff1a;诊断问题类型 检查磁盘空间 运行以下命令&#xff1a; bash df -h # 查看磁盘使用情况 如果输出中 Use% 接…
阅读更多...
uniapp：微信小程序胶囊「复制链接」灰色处理

uniapp：微信小程序胶囊「复制链接」灰色处理

在原生开发的小程序中默认是支持复制的 &#x1f424; 但是在 uniapp 开发的小程序中无法复制&#xff08;体验版与开发版都可以进行复制&#xff0c;但发布后不可&#xff09; 解决方法&#xff1a; methods: {onShareAppMessage: function() {// return custom share data …
阅读更多...
差分数组c++

差分数组c++

温度波动记录 每天记录温度&#xff0c;支持区间温度调整和单日查询 输入&#xff1a; 第一行&#xff1a;一个整数n表示有n个温度 第二行&#xff1a;n个数表示具体温度 第三行&#xff1a;三个整数&#xff1a;S&#xff0c;e&#xff0c;c&#xff0c;表示从…
阅读更多...
Vue.js 列表过滤实现详解（watch和computed实现）

Vue.js 列表过滤实现详解（watch和computed实现）

Vue.js 列表过滤实现详解 <!DOCTYPE html> <html lang"en"><head><meta charset"UTF-8"><meta http-equiv"X-UA-Compatible" content"IEedge"><meta name"viewport" content"widthd…
阅读更多...
性能测试-jmeter实战4

性能测试-jmeter实战4

课程&#xff1a;B站大学 记录软件测试-性能测试学习历程、掌握前端性能测试、后端性能测试、服务端性能测试的你才是一个专业的软件测试工程师 性能测试-jmeter实战4 jmeter环境搭建1. 安装Java环境&#xff08;必需&#xff09; JMeter环境搭建完整指南1. 安装Java&#xff0…
阅读更多...
GPPT（Graph Pre-training and Prompt Tuning）项目复现

GPPT（Graph Pre-training and Prompt Tuning）项目复现

GPPT（Graph Pre-training and Prompt Tuning）项目复现 项目概述 GPPT是一种创新的图神经网络预训练与提示调整框架，由MingChen-Sun等人提出。该项目通过将自然语言处理中的提示学习概念引入图领域，解决了图预训练模型在下游任务中的适应性问题。 环境配置 # 创建Python…
阅读更多...
anchor 智能合约 IDL 调用

anchor 智能合约 IDL 调用

简介&#xff1a;通过 IDL 生成代码 调用 anchor 智能合约。 全网首发 使用 anchor 可以快速开发 solana 上面的智能合约 &#xff0c; 在本案例中我们 先使用 anchor 创建一个只能合约&#xff08; 多个函数方法&#xff09;。 部署到 dev 链上。 通过 anchor 的 IDL 生成 代码…
阅读更多...
【Clickhouse系列】事务

【Clickhouse系列】事务

目录 1. 标准 ACID 支持场景 (MergeTree 引擎家族) 2. 非 ACID 场景 3. 实验性事务功能 (非云环境) 总结 参考文档 事务性 (ACID) 支持 | ClickHouse Docs ClickHouse ACID 支持核心要点 1. 标准 ACID 支持场景 (MergeTree 引擎家族) • 单分区插入 (原子块) • ✅ 原子性…
阅读更多...
在cursor中，配置jdk和maven环境，安装拓展插件

在cursor中，配置jdk和maven环境，安装拓展插件

目录 1.手动配置jdk和maven 2.安装java拓展插件 1.手动配置jdk和maven 第一步&#xff1a;按ctrl shift p, 搜索“Preferences: Open User Settings (JSON)” 并回车&#xff0c;打开 settings.json 文件 。然后添加或修改以下内容&#xff1a; "java.home": &qu…
阅读更多...
（线性代数最小二乘问题）Normal Equation（正规方程）

（线性代数最小二乘问题）Normal Equation（正规方程）

Normal Equation&#xff08;正规方程&#xff09; 是线性代数中的一个重要概念&#xff0c;主要用于解决最小二乘问题&#xff08;Least Squares Problem&#xff09;。它通过直接求解一个线性方程组&#xff0c;找到线性回归模型的最优参数&#xff08;如权重或系数&#xff…
阅读更多...
在架构设计中平衡动态语言与静态语言部署差异的策略分析

在架构设计中平衡动态语言与静态语言部署差异的策略分析

在软件架构设计过程中&#xff0c;语言的选型不仅仅关乎开发效率&#xff0c;更直接影响系统的部署速度、运行性能与维护成本。动态语言&#xff08;如 Python、Node.js&#xff09;部署快、开发灵活&#xff1b;静态语言&#xff08;如 Go、Java、Rust&#xff09;性能强、类型…
阅读更多...
我的VSCode中那些插件

我的VSCode中那些插件

前言 最近在研究VUE.JS&#xff0c;而VUE官方推荐使用VSCode作为开发工具&#xff0c;因此最近才开始大量使用这个工具。在使用过程中&#xff0c;总会遇到一些视频博主推荐某某插件&#xff0c;于是我都将其安装在我的VSCode上。这里记录一下&#xff0c;仅供参考。 插件列表…
阅读更多...
C# 时间格式日期格式使用合集

C# 时间格式日期格式使用合集

一、常用整理 C#时间使用整理,DateTime 使用整理_c#时间格式-CSDN博客 C# 本地时间格式&#xff0c;UTC时间格式&#xff0c;GMT时间格式处理 二、 C#如何获取今天零点的时间 C# 获取周一、周日 三、 C#计算两个时间年份月份差 C#时间点字符串转换为日期&#xff0c;当…
阅读更多...
Ribbon负载均衡的具体实现原理

Ribbon负载均衡的具体实现原理

Ribbon 是 Netflix 开源的一款客户端负载均衡工具&#xff0c;广泛应用于微服务架构中&#xff0c;用于在客户端选择目标服务实例。 以下是 Ribbon 负载均衡的具体实现原理&#xff1a; 1. 什么是 Ribbon Ribbon 是一个客户端负载均衡器&#xff0c;负责从服务注册中心&#…
阅读更多...
iOS APP上架App Store实践：通过自动化流程和辅助工具高效提

iOS APP上架App Store实践：通过自动化流程和辅助工具高效提

在现代开发流程中&#xff0c;持续集成&#xff08;CI&#xff09;已经成为必不可少的环节。对于iOS应用的开发与发布&#xff0c;持续集成不仅限于构建过程&#xff0c;还应该涵盖从代码提交到版本发布的整个生命周期。然而&#xff0c;由于iOS平台对开发环境的限制&#xff0…
阅读更多...
3443. K 次修改后的最大曼哈顿距离

3443. K 次修改后的最大曼哈顿距离

3443. K 次修改后的最大曼哈顿距离 题目链接&#xff1a;3443. K 次修改后的最大曼哈顿距离 代码如下&#xff1a; class Solution { public:int maxDistance(string s, int k) {int res 0;// 定义一个大小为 X&#xff08;88&#xff09;的数组&#xff0c;并初始化为 0int…
阅读更多...
【Ubuntu】Windows11安装虚拟机超详细图文教程（VMware17.6.1 + ubuntu-24.04.2）

【Ubuntu】Windows11安装虚拟机超详细图文教程（VMware17.6.1 + ubuntu-24.04.2）

目录 前言 一、准备工作 1、工具安装包 2、获取方式 3、本人的电脑安装环境介绍 二、虚拟机磁盘分区&#xff08;可选&#xff09; 1、分区助手安装 2、为虚拟机准备一个单独的磁盘分区 三、VMware安装 四、ubuntu镜像安装 1、Ubuntu镜像iso文件加载引导 2、Ubuntu…
阅读更多...
计算机视觉（Computer Vision, CV）

计算机视觉（Computer Vision, CV）

目录 一、核心任务 二、常见应用场景 三、主流技术框架与工具 四、热门算法简述 五、发展趋势 六、计算机视觉学习路线图&#xff08;从入门到实战&#xff09; 1.阶段总览 2.学习路径详解 阶段一&#xff1a;CV入门基础 学习目标&#xff1a; 推荐内容&#xff1a;…
阅读更多...
使用Dagster资产工厂模式高效管理重复ETL任务

使用Dagster资产工厂模式高效管理重复ETL任务

本文介绍了如何利用Dagster的资产工厂模式来高效管理和自动化重复的ETL&#xff08;提取、转换、加载&#xff09;任务。通过Python函数和YAML配置文件的结合&#xff0c;我们可以轻松地创建和管理大量相似的资产&#xff0c;同时提高代码的可维护性和可配置性。文章还探讨了如…
阅读更多...
浅谈开源在线客服系统与 APP 集成的技术方案与优劣势

浅谈开源在线客服系统与 APP 集成的技术方案与优劣势

在为移动端 App 接入在线客服系统的过程中&#xff0c;我经历了长时间的技术选型探索。最初&#xff0c;我也曾被一些“技术理想主义”选项所吸引&#xff0c;比如让用户自己研发界面我提供 API 以获得最高自由度&#xff0c;或集成 SDK 以追求原生体验。然而&#xff0c;随着项…
阅读更多...
最新文章

Copyright @ 2022~2023