C ++多线程和互斥锁
c++ multithreading and mutex
我有点熟悉 C/Linux 多线程,但这次我必须在 Windows 上使用 C++ 做一些工作,但我无法掌握它。在我的程序中,我有 2 个函数,它们不断尝试访问同一个文件来执行一些打印操作,但其中一个函数永远无法工作,这让我认为一个函数永远无法打开文件,因为另一个函数总是可以写在上面。我怎样才能实现线程来完成这项工作?代码大致是这样的:
std:mutex mut;
main(){
while(1){
//get mychar from user
print1(mychar, "my.txt");
print2();
}
}
print1(int i, char* file){
FILE *f = fopen(file, "a");
/*print operations
..
.*/
fclose(f);
return 0;
}
void print2(){
/*getting a string
...
Sleep(200);
getting another string
...*/
char getX[]; //fill buffers with the strings accordingly
char getY[]; //basically i want to know if the initial string has changed
if(*getX != *getY){
std::Lock_guard<std::mutex> guard(mut);
FILE *f = fopen("my.txt", "a");
fprintf(f, "%s ", getY);
fclose(f);
}
getX = NULL;
getY = NULL;
}
第一个问题是你的互斥量是在 main 中本地声明的。它们需要可供您的函数访问。如果您的程序中的所有相关内容都发生在这个文件中,那么使用全局声明的互斥锁就完全没问题了。
第二个问题是您没有正确锁定任何一个线程。如果您要打开两个文件进行追加,那么最安全的做法是在打开时锁定并在关闭时解锁。您可以通过在函数入口处使用全局互斥锁初始化锁守卫来完成此操作:
std::mutex mut;
main(){
while(1){
//get mychar from user
print1(mychar, "my.txt");
print2();
}
}
print1(int i, char* file){
std::lock_guard<std::mutex> guard(mut);
FILE *f = fopen(file, "a");
/*print operations
..
.*/
fclose(f);
return 0;
}
void print2(){
/*getting a string
...
Sleep(200);
getting another string
...*/
char getX[]; //fill buffers with the strings accordingly
char getY[]; //basically i want to know if the initial string has changed
if(*getX != *getY){
std::lock_guard<std::mutex> guard(mut);
FILE *f = fopen("my.txt", "a");
fprintf(f, "%s ", getY);
fclose(f);
}
getX = NULL;
getY = NULL;
}
正如其他人所指出的,您在这里甚至没有使用并发。这只是一个接一个的函数调用。如果你想使用线程,你可以在你的 while(1)
循环中这样做:
while(1){
std::thread thread1(print1, mychar, "my.text");
std::thread thread2(print2);
thread1.join();
thread2.join();
}
编辑:我已经编辑了您的print2
函数以仅在需要写入文件时打开文件。这使得并发性在您的应用程序结构中更加合理。
我有点熟悉 C/Linux 多线程,但这次我必须在 Windows 上使用 C++ 做一些工作,但我无法掌握它。在我的程序中,我有 2 个函数,它们不断尝试访问同一个文件来执行一些打印操作,但其中一个函数永远无法工作,这让我认为一个函数永远无法打开文件,因为另一个函数总是可以写在上面。我怎样才能实现线程来完成这项工作?代码大致是这样的:
std:mutex mut;
main(){
while(1){
//get mychar from user
print1(mychar, "my.txt");
print2();
}
}
print1(int i, char* file){
FILE *f = fopen(file, "a");
/*print operations
..
.*/
fclose(f);
return 0;
}
void print2(){
/*getting a string
...
Sleep(200);
getting another string
...*/
char getX[]; //fill buffers with the strings accordingly
char getY[]; //basically i want to know if the initial string has changed
if(*getX != *getY){
std::Lock_guard<std::mutex> guard(mut);
FILE *f = fopen("my.txt", "a");
fprintf(f, "%s ", getY);
fclose(f);
}
getX = NULL;
getY = NULL;
}
第一个问题是你的互斥量是在 main 中本地声明的。它们需要可供您的函数访问。如果您的程序中的所有相关内容都发生在这个文件中,那么使用全局声明的互斥锁就完全没问题了。
第二个问题是您没有正确锁定任何一个线程。如果您要打开两个文件进行追加,那么最安全的做法是在打开时锁定并在关闭时解锁。您可以通过在函数入口处使用全局互斥锁初始化锁守卫来完成此操作:
std::mutex mut;
main(){
while(1){
//get mychar from user
print1(mychar, "my.txt");
print2();
}
}
print1(int i, char* file){
std::lock_guard<std::mutex> guard(mut);
FILE *f = fopen(file, "a");
/*print operations
..
.*/
fclose(f);
return 0;
}
void print2(){
/*getting a string
...
Sleep(200);
getting another string
...*/
char getX[]; //fill buffers with the strings accordingly
char getY[]; //basically i want to know if the initial string has changed
if(*getX != *getY){
std::lock_guard<std::mutex> guard(mut);
FILE *f = fopen("my.txt", "a");
fprintf(f, "%s ", getY);
fclose(f);
}
getX = NULL;
getY = NULL;
}
正如其他人所指出的,您在这里甚至没有使用并发。这只是一个接一个的函数调用。如果你想使用线程,你可以在你的 while(1)
循环中这样做:
while(1){
std::thread thread1(print1, mychar, "my.text");
std::thread thread2(print2);
thread1.join();
thread2.join();
}
编辑:我已经编辑了您的print2
函数以仅在需要写入文件时打开文件。这使得并发性在您的应用程序结构中更加合理。