多线程和线程同步基础篇学习笔记(Linux)

大丙老师教学视频:10-线程死锁_哔哩哔哩_bilibili

目录

大丙老师教学视频:10-线程死锁_哔哩哔哩_bilibili

 线程概念

为什么要有线程

线程和进程的区别

在处理多任务的时候为什么线程数量不是越多越好?

Linux提供的线程API

主要接口

 线程创建 pthread_create()

分别获取主子线程的id pthread_self()

线程退出  pthread_exit()

线程回收pthread_join()

线程分离  pthread_detach()

​编辑

几个不重要的接口

线程取消 pthread_cancel()​编辑

线程Id比较  pthread_equal()

线程同步

同步的方式

互斥锁 ​编辑

​编辑

死锁​编辑

加锁后忘记解锁​编辑

重复加锁,造成死锁

存在多个共享资源,随意加锁造成相互阻塞

那么如何在多线程中避免死锁情况呢?​编辑

读写锁​编辑​编辑​编辑​编辑​编辑

条件变量

条件变量的作用

条件变量和锁的区别

 什么是生产者和消费者模型

条件变量的函数接口

模拟生产者和消费者模型​编辑

信号量


 线程概念

为什么要有线程

为了效率更高.

线程和进程的区别

进程是自愿分配的最小单位,线程是系统调度执行的最小单位.

进程有自己独立的地址空间,就是说一个人住一个房间.线程共享同一个地址空间就像多个人住在同一个房间,节省了系统资源,但是效率却没有下降.

虽然住一个房间,但是并不是所有的东西都是共享的,比如牙刷都是各用各的.每个线程都有自己的栈区和寄存器.

每个进程对应一个虚拟地址空间,一个进程只能抢一个时间片。但是如果这个进程有10个子线程,那么就可以由这10个线程交错去抢这1个时间片,效率并不会低。

下图演示了进程是如何去抢占时间片的:因为多个线程共享一个进程地址空间,所以销毁的时候只销毁一个地址空间就行了,启动快,退出也会,对系统资源的冲击小。

在处理多任务的时候为什么线程数量不是越多越好?

多线程的本地就是多个线程分时复用,来回切换抢时间片。线程切换也是需要消耗时间和资源的.线程的数量太多效率自然就慢了。

Linux提供的线程API

主要接口

 线程创建 pthread_create()

想要创建线程就调用pthread_create()函数

我们可以看见pthread_create()有四个参数。第一个参数是用来返回线程ID的,类型是pthread_t。第二个参数是pthread_attr_t 是一个结构体,用于设置线程属性,例如线程栈的大小、线程的分离状态等。我们用默认的就可以了,一般设置为nullptr.第三个参数是一个函数指针,指向线程启动时调用的函数。函数指针一般都是用来回调用的。我们创建子线程就是为了让子线程去执行任务.这个回调函数就是子线程要执行的任务。第四个参数指向一个 void 的指针,它包含传递给 start_routine 函数的参数。

线程演示:

#include<iostream>
#include<pthread.h>
#include<unistd.h>void* ThreadRountine(void* args)
{while(1){std::cout<<"新线程"<<std::endl;sleep(1);}
}
int main()
{pthread_t tid;pthread_create(&tid,nullptr,ThreadRountine,nullptr);while(true){std::cout<<"主线程"<<std::endl;sleep(1);}return 0;
}

如何给线程传参

我们上面说了pthread_create()​​​的第四个参数void *args可以给第三个参数void *(*start_routine)了传参.

#include<iostream>
#include<pthread.h>
#include<unistd.h>
#include<string>
void* ThreadRountine(void* args)
{std::string threadname=(const char*) args;while(1){std::cout<<threadname<<" "<<"新线程"<<std::endl;sleep(1);}
}
int main()
{pthread_t tid;pthread_create(&tid,nullptr,ThreadRountine,(void *)"thread1");while(true){std::cout<<"主线程"<<std::endl;sleep(1);}return 0;
}

 但是上面那种方法只能传字符串,而我还想传其他东西.比如对象.

 我们可以定义一个类对象,把这个类对象作为pthread_create()的第四个参数传过去:

#include<iostream>
#include<pthread.h>
#include<unistd.h>
#include<string>
#include<functional>
#include<time.h>using func_t =std::function<void()>;
class ThreadData
{ 
//构造函数
public:ThreadData(const std::string &name,const uint64_t &ctime,func_t f):threadname(name),createtime(ctime),func(f){} public:std::string threadname;uint64_t createtime;func_t func;
};
void Print()
{std::cout<<"我是线程执行的大任务的一部分"<<std::endl;
}void* ThreadRountine(void* args)
{ThreadData *td=static_cast<ThreadData*>(args);while(1){std::cout<<"thread name: "<<td->threadname<<" "<<"creatime: "<<td->createtime<<std::endl;td->func;sleep(1);}
}
int main()
{pthread_t tid;ThreadData *td=new ThreadData("thread1",(uint64_t)time(nullptr),Print);pthread_create(&tid,nullptr,ThreadRountine,td);while(true){std::cout<<"主线程"<<std::endl;sleep(3);}return 0;
}

如何创建多个线程

可以通过for循环创建多个线程

#include<iostream>
#include<pthread.h>
#include<unistd.h>
#include<string>
#include<functional>
#include<time.h>
#include<vector>const int threadnum=5;
using func_t =std::function<void()>;
class ThreadData
{ 
//构造函数
public:ThreadData(const std::string &name,const uint64_t &ctime,func_t f):threadname(name),createtime(ctime),func(f){} public:std::string threadname;uint64_t createtime;func_t func;
};
void Print()
{std::cout<<"我是线程执行的大任务的一部分"<<std::endl;
}void* ThreadRountine(void* args)
{std::cout<<"新线程"<<std::endl;ThreadData *td=static_cast<ThreadData*>(args);while(1){std::cout<<"thread name: "<<td->threadname<<" "<<"creatime: "<<td->createtime<<std::endl;td->func;sleep(1);}
}
int main()
{pthread_t tid;std::vector<pthread_t> pthreads;for(int i=1;i<=threadnum;i++){char threadname[64];snprintf(threadname,sizeof(threadname),"%s-%d","thread",i);ThreadData *td=new ThreadData(threadname,(uint64_t)time(nullptr),Print);pthread_create(&tid,nullptr,ThreadRountine,td);pthreads.push_back(tid); //每创建成功一个线程就加入到vector里}while(true){std::cout<<"主线程"<<std::endl;sleep(1);}return 0;
}

分别获取主子线程的id pthread_self()

每个线程都有一个Id,这个id类型是pthread_t类型的,想要获取当前线程id就调用pthread_self()接口,

ppthread_self()函数用来返回子线程的id

写如下代码

#include<iostream>
#include<pthread.h>
#include<unistd.h>
#include<string>
#include<functional>
#include<time.h>
#include<vector>void *threadRoutine(void *args)
{const char* name = static_cast<const char*>(args);while(true){std::cout <<name<<": "  << pthread_self() <<std::endl;sleep(1);}
}int main()
{pthread_t id;const char* threadName = "new thread"; // Correctly passing a const char*pthread_create(&id, nullptr, threadRoutine, (void*)threadName);while(true){std::cout << "main thread id: " << id << std::endl;sleep(1);}return 0;
}

我们发现,主线程的id和子线程的id值一样,也就是说pthread_self()是一个输出型参数,可以把子线程的id带出去

我们也可以通过pthread_self()把主线程的id也打印出来看看:

int main()
{pthread_t id;const char* threadName = "new thread"; // Correctly passing a const char*pthread_create(&id, nullptr, threadRoutine, (void*)threadName);while(true){std::cout << "main thread sub thread: " << id<<"main thread: "<<pthread_self()<<std::endl;sleep(1);}return 0;
}

线程退出  pthread_exit()

1.我们想让子线程执行完任务后退出不可以直接调用exit()函数来退出.因为exit()函数是用来结束进程的,整个程序就会被结束掉.我们可以用return nullptr的方式结束子线程,也可以调用线程结束函数pthread_exit().

2.子线程退出不会影响主线程,但是主线程1退出会销毁进程地址空间,子线程的资源也会被释放.

观察下列代码和现象,为什么子线程只输出了一次线程id就退出了?

#include<pthread.h>
#include<iostream>void *callback(void *args)
{for(int i=0;i<5;i++){std::cout<<"子线程执行"<<i<<std::endl;}std::cout<<"子线程id: "<<pthread_self()<<std::endl;
}
int main()
{pthread_t tid;pthread_create(&tid,nullptr,callback,nullptr);for(int i=0;i<5;i++){std::cout<<"主线程执行"<<i<<std::endl;}std::cout<<"主线程id: "<<pthread_self()<<std::endl;return 0;
}

这是因为主线程先被执行(main函数从上到下依次执行,主线程先抢到了时间片),当主函数在执行的时候子线程去抢时间片,有可能在子线程还没抢到时间片的时候,主线程就执行完就退出了,那么进程地址空间就被销毁了.子线程自然也就结束了.

解决方案

1.让主线程sleep()挂起,等子线程一下.

2.在进程主函数(main())中调用pthread_exit(),只会使主函数所在的线程(可以说是进程的主线程)退出;而如果是return,编译器将使其调用进程退出的代码(如_exit()),从而导致进程及其所有线程结束运行。

理论上说,pthread_exit()和线程宿体函数退出的功能是相同的,函数结束时会在内部自动调用pthread_exit()来清理线程相关的资源。但实际上二者由于编译器的处理有很大的不同。

按照POSIX标准定义,当主线程在子线程终止之前调用pthread_exit()时,子线程是不会退出的。

线程回收pthread_join()

主线程有义务回收子线程结束后释放的资源.可以调用pthread_join()函数来回收资源:

同时主线程还可以获取子线程的返回值.子线程其实就是在执行callback()函数,但是我们知道它是void*类型的,无法返回值.那么主线程如何获取子线程的返回值呢?

我们可以在子线程中调用pthread_exit()函数,我们注意到pthread_exit()函数的参数是一个void  *类型的 名字为retval类型的实参

而pthread_join()函数的第二个参数是void** 类型的同名形参.

二级指针保留一级指针的地址,我们在子线程中把要传递的值的地址传给pthread_exit(),在主线程中调用pthread_join()函数等待子线程结束时回收其资源,如果不获取子线程返回值,第二个参数来获取返回值.

#include<pthread.h>
#include<iostream>
#include<string>struct Point {std::string name;int age;
};void* callback(void* args) {struct Point* P = (struct Point*)args;P->name = "张三"; // 初始化字符串P->age = 18;std::cout << "子线程id: " << pthread_self() << std::endl;pthread_exit((void*)P); // 返回 Point 结构体指针
}int main() {pthread_t tid;struct Point P; // 定义全局或动态分配的结构体pthread_create(&tid, nullptr, callback, &P); // 传递 Point 结构体的地址void* pt;pthread_join(tid, &pt); // 正确地使用 &ptstruct Point* ans = (struct Point*)pt; // 转换回 Point 结构体指针std::cout << ans->name << " " << ans->age << std::endl; // 正确地打印return 0;
}

线程分离  pthread_detach()

为什么要分离?

主线程在回收子线程资源的时候需要阻塞等待子线程执行完任务结束(因为主线程不等待一旦退出,那么虚拟进程地址空间就会被销毁,子线程资源也就就被释放了),那么此时主线程就无法再做其他事情了.为了给主线程减负,可以用线程分离技术.把主子线程分离开来,各做各的事情,主线程无需阻塞等待回收子线程资源,自己做完自己的任何自行退出即可.子线程的资源由内核去回收.

#include<iostream>
#include<pthread.h>
#include<unistd.h>
#include<string>
#include<functional>
#include<time.h>
#include<vector>void *threadRoutine(void *args)
{const char* name = static_cast<const char*>(args);for(int i=0;i<2;i++){std::cout <<name<<": "  << pthread_self() <<std::endl;sleep(1);}std::cout<<"子线程退出"<<std::endl;
}int main()
{pthread_t id;const char* threadName = "子线程"; // Correctly passing a const char*pthread_create(&id, nullptr, threadRoutine, (void*)threadName);for(int i=0;i<1;i++){std::cout << "主线程id: " << id << std::endl;sleep(1);}pthread_detach(id);    //线程分离std::cout<<"主线程退出"<<std::endl;pthread_exit(nullptr);   //主线程退出不销毁进制地址空间,不影响子线程return 0;
}

几个不重要的接口

线程取消 pthread_cancel()

这个接口用来在主线程中杀死子线程用的.

线程Id比较  pthread_equal()

线程同步

什么是线程同步?为什么要进行线程同步?

在多线程编程中,多个线程可以同时访问共享资源。线程同步是为了保证多个线程之间对共享资源的访问顺序和结果的正确性。当多个线程同时访问共享资源时,如果没有进行适当的同步措施,可能会导致数据不一致、竞争条件和死锁等问题。

总之就是一句话,线程同步就是为了解决数据读取先后顺序问题

举个例子,因为当我们有多个线程要同时访问一个变量或对象时,如果这些线程中既有读又有写操作时,就会导致变量值或对象的状态出现混乱,从而导致程序异常。举个例子,如果一个银行账户同时被两个线程操作,一个取100块,一个存钱100块。假设账户原本有0块,如果取钱线程和存钱线程同时发生,会出现什么结果呢?取钱不成功,账户余额是100.取钱成功了,账户余额是0.那到底是哪个呢?很难说清楚。因此多线程同步就是要解决这个问题。

那么线程同步就要明确这个答案,就是规定好线程的顺序---先存钱再取钱,这样就只有一个结果-----取钱成功,余额为0.

例如下面就是一个线程异步造成的问题:

#include<iostream>
#include<pthread.h>
#include<unistd.h>
#include<string>
#include<functional>
#include<time.h>
#include<vector>int number;
void *callA(void* args)
{for(int i=0;i<5;i++){int cur=number;cur++;number=cur;usleep(5);printf("A thread: %lu, %d\n",pthread_self(),number);}return nullptr;
}void *callB(void* args)
{for(int i=0;i<5;i++){int cur=number;cur++;number=cur;printf("B thread: %lu, %d\n",pthread_self(),number);usleep(5);}return nullptr;
}
int main()
{pthread_t t1,t2;pthread_create(&t1,nullptr,callA,nullptr);pthread_create(&t2,nullptr,callB,nullptr);pthread_join(t1,nullptr);pthread_join(t2,nullptr);return 0;
}

现象1 

 我们发现B线程抢到时间片给Number加上1之后,A线程结束.B线程抢到时间片给number+1,增值完后结果竟然和线程A增值结果一样,而不是比线程A增值后的结果大1.

这个现象问题是典型的多线程并发中的竞态条件(race condition)。在您的代码中,两个线程 t1 和 t2 都在尝试读取、修改并回写全局变量 number。由于线程调度的不确定性,两个线程可能会同时读取到相同的 number 值,然后各自递增,导致最终的 number 值比预期少。

下面是发生竞态条件的步骤:

  1. 线程 A 读取 number 的值,比如当前是 2。
  2. 线程 B 也读取 number 的值,同样是 2。
  3. 线程 A 将其值增加 1 并写回,number 现在是 3。
  4. 线程 B 也将其值增加 1 并写回,number 变成 3(期望是 4)。

由于线程 B 的操作覆盖了线程 A 的结果,所以实际的增量比预期的少。

现象2

线程A打印完是7,线程B打印为什么是9呢?

首先我们要知道number存储在硬盘里,cpu现在想对它做增值操作,需要先读取它,把它从硬盘读取到内存里, 从内存到cpu还需要经过3级缓存和一个寄存器.。

  • 在线程 A 打印 7 之后,线程 B 获得了 CPU 时间,并读取了 number 的值。
  • 线程 B 将 number 递增到 8,但在它有机会打印之前,线程 A 可能已经再次执行,将 number 的值从 8 递增到 9 。但是还没有来得及打印,线程B就又抢到了时间片。
  • 此时number 值为8,线程B对其进行增值变为9,并打印输出。

为了解决上面出现的多个线程可能同时修改同一数据,可能会导致数据处于不一致的状态。以及当多个线程访问共享资源,并且至少有一个线程对资源进行写操作时,如果没有适当的同步机制,就可能出现竞态条件,导致程序行为不可预测。于是有了线程同步这一概念。

同步的方式

常见的线程同步有四种方式:互斥锁,读写锁,条件变量,信号变量。

锁可以保证多个线程按照线程顺序依次执行。加锁就是在临界资源上方枷锁,在临界资源下方解锁。

什么是临界资源?

所谓共享资源就是多个线程共同访问的变量,这些变量通常为全局数据区变量或堆区变量,被称为临界资源,这些变量对应的共享资源也被称之为临界资源。

 什么是临界区?

临界区就是上锁和解锁中间的代码段(不希望被其他线程数据污染的部分都可以放进临界区)

互斥锁 

ps:

  • restrict:这个关键字告诉编译器,mutex指针是访问它所指向的pthread_mutex_t对象的唯一方式。这意味着在pthread_mutex_lock函数执行期间,不会有其他指针指向同一个互斥锁对象。

例如说有一个mutex_t类型的变量: mutex_t mut; 该变量加锁了一个线程。

此时p=mut,p是不能进行对该线程进行解锁的。因为除mutex,arrtr两个互斥锁对象外不能有其他指针指向同一个互斥锁对象。

例如还是上文的代码,我们给线程A和线程B都加上互斥锁后运行结果就达到了我们的预期效果:

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <string>
#include <functional>
#include <time.h>
#include <vector>int number = 0;
pthread_mutex_t lock;void* callA(void* arg) {for (int i = 0; i < 5; ++i) {//加锁pthread_mutex_lock(&lock);number++;std::cout << "A thread: " << pthread_self() << ", " << number << std::endl;//解锁pthread_mutex_unlock(&lock);}return nullptr;
}void* callB(void* arg) {for (int i = 0; i < 5; ++i) {//加锁pthread_mutex_lock(&lock);number++;std::cout << "B thread: " << pthread_self() << ", " << number << std::endl;//解锁pthread_mutex_unlock(&lock);}return nullptr;
}int main() {pthread_t t1, t2;//初始化互斥锁pthread_mutex_init(&lock, nullptr);pthread_create(&t1, nullptr, callA, nullptr);pthread_create(&t2, nullptr, callB, nullptr);pthread_join(t1, nullptr);pthread_join(t2, nullptr);//释放互斥锁pthread_mutex_destroy(&lock);return 0;
}

死锁
加锁后忘记解锁

 在func1()中因为忘记解锁,所以在进入第二层for循环时就进不去了,该线程就会被阻塞在这把互斥锁上。

在fun2()中所以没有忘记解锁,但是在临界区里进行了条件判断,一但满足条件就会立即退出,不再进行解锁操作.那么当下次该线程抢到时间片再进就进不来了。

重复加锁,造成死锁

funcA()中上了两层锁,当上完第一层锁进入临界区后,内部还有一个锁,但是此时已经进不去了(没有进行解锁操作,无钥匙)。

funB()中上了一层锁,也有解锁操作,但是在临界区里调用了funA(),funA()上面说了阻塞,因为funB()进入funA()后也会被阻塞祝,回不来了。

存在多个共享资源,随意加锁造成相互阻塞

 如上图所示,假设线程A对临界资源X进行了加锁。线程B对临界资源Y进行了加锁。

现在,线程A又想对资源Y进行加锁,同时,线程B又想对资源X加锁。那么,两个线程都会被阻塞(假设都用的pthread)_mutex_lock())

那么如何在多线程中避免死锁情况呢?

读写锁

条件变量

条件变量的作用

条件变量是用来阻塞线程的。

条件变量和锁的区别

线程是用来并发线程的,条件变量是用来阻塞线程的。

 什么是生产者和消费者模型

生产者消费者模型-CSDN博客

条件变量的函数接口

模拟生产者和消费者模型

#include<iostream>
#include<cstdio>
#include<pthread.h>
#include<unistd.h>pthread_mutex_t mutex;pthread_cond_t cond;
struct Node
{int value;struct Node* next;
};
struct Node* head=nullptr;
//生产者
void* producer(void* args)
{while(1){   pthread_mutex_lock(&mutex);//创建新节点struct Node* newnode=(struct Node*)malloc(sizeof(struct Node));//初始化newnode->value=rand()%1000;newnode->next=head;head=newnode;printf("生产者: id:%ld , value:%d\n",pthread_self(),newnode->value);pthread_mutex_unlock(&mutex); pthread_cond_broadcast(&cond);sleep(rand()%3); //随机休息0~3秒}return nullptr;
}
//消费者
void* consumer(void* args)
{while(1){pthread_mutex_lock(&mutex);while(head==nullptr){pthread_cond_wait(&cond,&mutex);}struct Node* node=head;printf("消费者: id:%ld , value:%d\n",pthread_self(),node->value);head=head->next;free(node);pthread_mutex_unlock(&mutex);sleep(rand()%3);}return nullptr;
}
int main()
{pthread_t ptid[5],ctid[3];pthread_mutex_init (&mutex,nullptr);pthread_cond_init(&cond,nullptr);for(int i=0;i<5;i++)  //5个生产者{pthread_create(&ptid[i],nullptr,producer,nullptr);}for(int i=0;i<3;i++)  //三个消费者{pthread_create(&ctid[i],nullptr,consumer,nullptr);}for(int i=0;i<5;i++)  //5个生产者{pthread_join(ptid[i],nullptr);  //第二个参数用来带出子线程的返回值}for(int i=0;i<3;i++)  //三个消费者{pthread_join(ctid[i],nullptr);}pthread_cond_destroy(&cond);pthread_mutex_destroy(&mutex);return 0;
}

我们可以看到一个现象:

生产者去生产,生产完了之后全部放到商店。然后消费者去消费,生产者先休息一会。当消费者把商品清空之后生产者接着去生产。 

那么我有一个问题, 消费者在把产品清空时无商品可买会陷入阻塞等待:

那么生产者此时就能把产品生产出来吗?

根据代码上下文来看消费者因为被阻塞没有向下执行解锁,那么此时Mutex这把锁就是上锁状态。生产者也无法进入:


 

 但是根据我们的运行现象来看,生产者在消费者阻塞等待时确实是继续生产产品了。

这是因为消费者在阻塞等待的时候调用了pthread_cond_wait(&cond,&mutex),所以会自动释放该互斥锁的拥有权,第二个参数会自行给mutex解锁。

那么被解锁后,生产者就开始生产,生产完后调用pthread_cond_broadcast()唤醒多个消费者线程。

需要注意的是消费者线程被唤醒之后,会抢时间片,抢到的消费者线程通过pthread_cond_wait(&cond,&mutex)接着加上锁,向下执行,没有加锁成功的消费者线程会继续阻塞。

信号量

信号量也是用来处理生产者和消费者模型的,但是比条件变量更加简单。

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

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

相关文章

DDRPHY数字IC后端设计实现系列专题

在对 LPDDR3 物理层接口模块进行后端设计之前&#xff0c;需要对该模块的功能结 构以及后端物理设计流程的相关理论进行深入的分析和研究。本章第一节详细分 析了本次 LPDDR3 物理层接口模块的结构&#xff0c;为该模块的布图布局的合理规划奠 定了理论基础&#xff0c;并且分析…

【笔记】数据结构与算法

参考链接&#xff1a;数据结构(全) 参考链接&#xff1a;数据结构与算法学习笔记 一些PPT的整理&#xff0c;思路很不错&#xff0c;主要是理解角度吧&#xff0c;自己干啃书的时候结合一下会比较不错 0.总论 1.数据 注&#xff1a;图是一种数据结构&#xff01;&#xff01;…

无人机救援系统基本组成

无人机救援系统基本组成 1. 源由2. 组成2.1 无人机载具2.1.1 多旋翼2.1.2 垂起固定翼2.1.3 智能避障2.1.4 物资投递 2.2 智能吊舱2.2.1 云台2.2.2 高清摄像2.2.3 红外热成像2.2.4 激光测距2.2.5 目标跟踪 2.3 通讯链路2.3.1 超长距离通信2.3.2 长距离通信2.3.3 中等距离通信 2.…

拍拍贷鸿蒙版H5容器之路

背景介绍 业务背景 2024年1月18日华为宣布&#xff1a;HarmonyOS NEXT 将不再支持 Android系统&#xff0c;基于以上背景及国内信贷业务现状&#xff0c;公司决定启动借款App鸿蒙化项目。 下图是2024年6月华为HDC大会上&#xff0c;华为宣布 HarmonyOS NEXT 将面向开发者和先…

微信小程序服务通知

项目中用到了小程序的服务消息通知&#xff0c;通知订单状态信息&#xff0c;下边就是整理的一下代码&#xff0c;放到项目中&#xff0c;把项目的小程序appid和小程序的secret写进去&#xff0c;直接运行即可 提前申请好小程序服务信息通知短信模板&#xff0c;代码需要用到模…

3000字帮你彻底搞懂Java抽象类与接口的区别(含JDK8接口新增三种方法与丰富案例)

Java-OOP 1-Final 1.1简介 final关键字是最终的意思&#xff0c;可以修饰&#xff1a;类、方法、变量。 修饰类&#xff1a;该类被成为最终类&#xff0c;特点是不能被继承了。修饰方法&#xff1a;该方法被称为最终方法&#xff0c;特点是不能被重写了。修饰变量&#xff…

有没有噪音低的宠物空气净化器推荐?希喂、IAM性能PK

有一说一&#xff0c;随着清洁家电市场的不断发展&#xff0c;市面上的各种清洁家电品类也是越来越多&#xff0c;像是吸尘器、洗地机、扫地机等等这些产品估计大家都很熟悉了。 但&#xff01;如果你家也跟我家一样也是养了几只猫猫狗狗&#xff0c;那你就会发现到&#xff0…

vscode摸鱼学习插件开发

不知道大家在摸鱼的时候&#xff0c;会不会想要学习&#xff1f; 或者有没有考公人&#xff0c;下班要学习的&#xff1f; 上班时间摸鱼&#xff0c;下班时间不够学习&#xff1f; 为此&#xff0c;我决定开发一个vscode插件&#xff0c;来刷粉笔题 粉笔插件名称&#xff1a;…

hive将包含逗号的字段拆分为多列

目录 一、概述 二、行动 1.准备数据 2.数据清洗 3.substring_index函数 4.split函数实现 一、概述 想将hive表中包含逗号的字段按逗号做分隔符进行分列操作 二、行动 1.准备数据 --1 select {1,2,3,4,5,6,7,8} as num_str --使用的数据2.数据清洗 --2 select num_s…

文心一言 VS 讯飞星火 VS chatgpt (381)-- 算法导论24.5 1题

一、给出图24-2的与图中两棵最短路径树不同的另外两棵最短路径树。如果要写代码&#xff0c;请用go语言。 文心一言&#xff1a; 在图论中&#xff0c;最短路径树&#xff08;Shortest Path Tree, SPT&#xff09;是一种从单个源点到所有其他节点的最短路径形成的树。给定一个…

故障诊断 | MTF-TLSSA-DarkNet-GRU-MSA迁移学习故障识别程序(t分布+莱维飞行改进麻雀优化)

故障诊断 | 故障诊断实例代码 目录 故障诊断 | 故障诊断实例代码效果一览基本介绍程序设计参考资料 效果一览 基本介绍 利用了迁移学习和多项技术改进&#xff0c;包括麻雀搜索法、DarkNet19、GRU、多头注意力机制等&#xff0c;以提高故障识别的准确性和效率 模型框架&#x…

在Bash脚本中 set -e 是什么意思

问题 我正在研究这个预安装(preinst)脚本的内容&#xff0c;该脚本会在从 Debian 软件包(.deb)文件解压该包之前执行。 脚本包含以下代码&#xff1a; #!/bin/bash set -e # Automatically added by dh_installinit if [ "$1" install ]; thenif [ -d /usr/share…

使用yolov3配置文件训练自己的数据

目录 前言 一、准备数据集 二、创建文件结构 三、格式化文件 1.data文件夹 2.config文件夹 四、修改yolo的配置文件 1.train文件 2.json2yolo文件 3.datasets文件 前言 使用yolov3框架训练自己的数据大致分为这四步&#xff1a; 准备数据集创建文件结构格式化文件 …

【小白学机器学习29】 概率统计与图形 ( hist, bar, pie , box ,scatter ,line)

目录 1 频度/次数 1.1 频度统计表&#xff1a;频度分布表 1.2 频数分布图直方图 histogram / hist 1.3 对比&#xff0c;柱状图 bar graph /column chart 2 饼图 pie chart 2.1饼图特点 3 南丁格尔玫瑰图 4 茎叶图 stem-and-leaf display 5 箱型图 box plot 6 …

springboot098基于web的网上摄影工作室的开发与实现(论文+源码)_kaic

网上摄影工作室 摘要 随着信息技术在管理上越来越深入而广泛的应用&#xff0c;管理信息系统的实施在技术上已逐步成熟。本文介绍了网上摄影工作室的开发全过程。通过分析网上摄影工作室管理的不足&#xff0c;创建了一个计算机管理网上摄影工作室的方案。文章介绍了网上摄影工…

【再谈设计模式】单例模式~唯一性的守护者

一、引言 在软件工程中&#xff0c;软件开发&#xff0c;设计模式是提高代码复用性和可维护性的有效工具。单例模式&#xff08;Singleton Pattern&#xff09;作为一种创建型设计模式&#xff0c;旨在确保一个类只有一个实例&#xff0c;并提供对该实例的全局访问。这一模式在…

UDP-鼠李糖合成酶基因的克隆与鉴定-文献精读76

何首乌中UDP-鼠李糖合成酶基因FmRHM1/2的克隆与鉴定 摘要 UDP-鼠李糖是一种由UDP-鼠李糖合酶&#xff08;RHM&#xff09;催化合成的鼠李糖供体&#xff0c;而鼠李糖是鼠李糖苷化合物的重要组成部分&#xff0c;植物中只有少数基因编码的酶参与UDP-鼠李糖生物合成。本研究基于…

创建多维数组的全部元素的索引np.indices

【小白从小学Python、C、Java】 【考研初试复试毕业设计】 【Python基础AI数据分析】 创建多维数组的 全部元素的索引 np.indices [太阳]选择题 根据题目代码&#xff0c;执行的结果是&#xff1f; import numpy as np arr np.arange(6).reshape((2, 3)) print(&quo…

C/C++ 矩阵的QR分解

#include <iostream> #include <vector> using namespace std;int main() /* 矩阵A的QR分解*/ {// 动态分配内存int m 3; // 行数int n 3; // 列数// 初始化矩阵Adouble A[3][3] {{1, 2, 2},{2, 1, 2},{1, 2, 1}};double R[3][3] { 0 };double Q[3][3] { 0 };…

2023-2024年教育教学改革、教学成果奖等项目申请书合集-最新出炉 附下载链接

2023-2024年教育教学改革、教学成果奖等项目申请书合集 下载链接-点它&#x1f449;&#x1f449;&#x1f449;&#xff1a;2023-2024年教育教学改革、教学成果奖等项目申请书合集-最新出炉.zip 资源介绍 本资源展示了2023-2024年高等教育领域的教育教学改革项目以及教学成…