Как использовать общие переменных в многопоточных программах с++?

Question

[Elijah Depp]

Всем привет.

Хотел проверить как работает многопоточность в с++, но с кодом ниже я всегда получаю "safe_mode: FALSE"

Идея того, что я хочу сделать это снимать показания сенсоров с больший скоростью (while loop) в нескольких параллельных процессах, но записывать их в общие переменные , которую читает главная функция (тоже while loop) и в зависимости от значений общих переменных ведет себя по разному. Как это лучше всего реализовать?

#include <thread>
#include <iostream>

using namespace std;

bool safe_mode = true;

bool *pnt_safe_mode = &safe_mode;

void stupidFunc() {
	int i = 0;

	while (i <= 10000)
	{
		if (*pnt_safe_mode == true)
		{
			*pnt_safe_mode = false;
		}
		else {
			*pnt_safe_mode = true;
		}
		i++;
	}
}


int main()
{
	std::thread t(stupidFunc);
	t.detach();

	for (int i = 0; i <= 10000; i++) {
		if (*pnt_safe_mode) {
			cout << "safe_mode: TRUE\n";
		}
		else {
			cout << "safe_mode: FALSE\n";
		}
	}

	system("pause");
	return 0;
}

Answer 1

[Александр Ананьев]

Для простых типов данных можно использлвать std::atomic
Например для вашей программы

std::atomic<bool> safe_mode = true;

void stupidFunc() {
  int i = 0;

  while (i <= 10000)
  {
    if (safe_mode == true)
    {
      safe_mode = false;
    }
    else {
      safe_mode = true;
    }
    i++;
  }
}

int main()
{
  std::thread t(stupidFunc);
  t.detach();

  for (int i = 0; i <= 10000; i++) {
    if (safe_mode) {
      cout << "safe_mode: TRUE\n";
    }
    else {
      cout << "safe_mode: FALSE\n";
    }
  }

  system("pause");
  return 0;
}

Comments

[MiiNiPaa]

С атомиками желательны явные load/store и указания memory order.

[Elijah Depp]

В вашем варианте я получаю тот же результат, что и у меня, что я делаю не так?

[Elijah Depp]

MiiNiPaa: Сделал так, вроде работает, на сколько коректен такой вариант?

#include
#include
#include

std::atomic safe_mode(true);

void stupidFunc() {
int i = 0;

while (true)
{
if (safe_mode.load())
{
safe_mode.store(false);
}
else {
safe_mode.store(true);
}
i++;
}
}

int main()
{
std::thread t(stupidFunc);
t.detach();

for (int i = 0; i > -1; i++) {
if (safe_mode.load()) {
std::cout << "safe_mode:\tTRUE" << "\t\t" << i << std::endl;
}
else {
std::cout << "safe_mode:\tFALSE" << "\t\t" << i << std::endl;
}
}

system("pause");
return 0;
}

Answer 2

[Олег Цилюрик]

как работает многопоточность в с++

в нескольких параллельных процессах

Вы уж как-то определитесь кто вас интересует: потоки или процессы.

В любом случае вам нужны блокировки для синхронизации.
Их есть большое разнообразие ... на любой вкус ;-)
Если вас интересуют потоки, то любого вида примитивы синхронизации вам подходят ... начиная с простейшего мютекса.
Если вас интересуют процессы, то вам нужны примитивы синхронизации с областью видимости операционной системы, это могут быть: блокировки на файлах, pipe, именованные семафоры и т.д.

Пытаться засинхронизироваться на простых переменных (как у вас safe_mode ... и любые изыски вокруг) - бессмысленно.

Comments

[Elijah Depp]

А можете подробнее подсказать, как лучше реализовать задачу которую я описал?

[Олег Цилюрик]

Elijah Depp:
для этого вы должны были бы начинать своё описание с того, в какой операционной системе вы хотите это получить (с этого любой вопрос полезно бы начинать) - в Windows и в POSIX-системах параллельность реализуется очень по-разному

[Олег Цилюрик]

Elijah Depp:
если вам не лень (там объём большенький), почитайте вот это: Параллелизм, конкурентность, многопроцессорность в... - там есть ответы на все ваши вопросы с примерами кода

[Elijah Depp]

Олег Цилюрик: Спасибо, почитаю. Это будет raspberry pi на raspbian, к ней будут подключены arduino, к которой подключены оптические сенсоры.

Answer 3

[Станислав Макаров]

Ну начнем с того, что 10000 итераций на современном процессоре выполнится настолько быстро, что вероятно уложится в отведенный потоку квант времени, и второй поток скорее всего даже не успеет получить процессорное время, чтобы поменять вашу переменную. Поэтому ИСКЛЮЧИТЕЛЬНО в целях эксперимента можете попробовать увеличить число итераций хотя бы до 10 миллионов, и отключить по максимуму оптимизации (не по причине скорости, а по причине потенциального выбрасывания кода компилятором), т.к. наверняка количество итераций есть причина неудачи в вашем эксперименте.

А если по-серьезному, вам уже дали советы как поступать - без нормальной синхронизации в многопоточной среде у вас никакие общие переменные результатов дать не могут. Если уж очень не хочется брать мьютекс (хотя чтобы его не брать, нужно четко знать что он не подходит), можете превратить вашу общий флажок в спинлок, но кодом на плюсах тут не отделаешься.

С архитектурной точки зрения, если у вас снятие показаний, то у вас просто классический случай producer-consumer - впилите потокобезопасную очередь, и пользуйтесь.

Comments

[romy4]

а может припасть на переключение контекста. откуда такая уверенность, что эти итерации выполнятся в одном "окне"?

[Владимир Мартьянов]

Блин, количество итераций в главном потоке я и упустил... Тогда и в самом деле есть шансы что поток не успеет ничего поменять :-)

[Станислав Макаров]

romy4 да, может и припасть на переключение. Под "наверняка" я имел в виду, что наверняка в этом причина, раз уж автор вопроса уже столкнулся с тем, что значение переменной не меняется.
Поправил ответ, спасибо.

Answer 4

[iv_k]

en.cppreference.com/w/cpp/thread/lock