Программирование потокобезопасности

Question

Я продолжаю слышать о потокобезопасности. Что именно так и как и где я могу научиться программировать потокобезопасный код?

Также предположим, что у меня есть 2 потока, которые записывают в структуру и другую, которая читает с нее. Это опасно? Есть ли что-нибудь, что я должен искать? Я не думаю, что это проблема. Оба потока не будут (а не могут) получать доступ к структуре в то же самое время.

Кроме того, может кто-нибудь скажет мне, как в этом примере: https://stackoverflow.com/a/5125493/1248779 мы делаем лучшую работу в вопросах параллелизма. Я не понимаю.

Answer 1

резьбы безопасность является одним из аспектов более широкого набора вопросов под общим заголовком «Параллельное программирование». Я бы предложил прочитать эту тему.

Ваше предположение, что два потока не могут получить доступ к структуре в одно и то же время, не является хорошим. Во-первых: сегодня у нас есть многоядерные машины, поэтому два потока могут работать в одно и то же время. Во-вторых: даже на одной основной машине срезы времени, заданные для любой другой нити, являются непредсказуемыми. Вы должны предвидеть, что муравей любое произвольное время, которое может обрабатывать «другой» поток. См. Ниже пример «окна возможностей».

Концепция безопасности потока - это точно ответить на вопрос «это опасно в любом случае». Ключевой вопрос заключается в том, возможно ли, чтобы код, работающий в одном потоке, получал противоречивое представление о некоторых данных, эта несогласованность возникает, поскольку во время запуска другой поток находился в середине изменения данных.

В вашем примере один поток читает структуру и в то же время пишет другую. Предположим, что существуют два смежных областях:

{ foreground: red; background: black } 

и писатель находится в процессе изменения этих

foreground = black; 
      <=== window of opportunity 
    background = red; 

Если читатель считывает значения в только, что окно возможностей, то он видит «нонсенс "сочетание

{ foreground: black; background: black } 

Эта сущность этой модели является то, что в течение короткого времени, в то время как мы делаем изменения, система становится непоследовательной и читатели не должны использовать значение. Как только мы закончим наши изменения, станет безопаснее читать снова.

Следовательно, мы используем API CriticalSection, упомянутые Stefan, чтобы предотвратить поток, наблюдающий несогласованное состояние.

Answer 2

При написании многопоточных программ на C++ на платформах WIN32 вам необходимо защитить определенные общие объекты, чтобы только один поток мог получить к ним доступ в любой момент времени из разных потоков. Для достижения этой цели вы можете использовать 5 системных функций. Это InitializeCriticalSection, EnterCriticalSection, TryEnterCriticalSection, LeaveCriticalSection и DeleteCriticalSection.

Кроме того, возможно, это ссылки могут помочь: how to make an application thread safe?

http://www.codeproject.com/Articles/1779/Making-your-C-code-thread-safe

Answer 3

Безопасная защита потоков, когда определенный блок кода защищен от доступа более чем одним потоком. Это означает, что обрабатываемые данные всегда остаются в постоянном состоянии.

Типичного пример является производителем потребительской проблемы, когда один поток считывает из структуры данных, в то время как другой поток записывает в ту же структуру данных: Detailed explanation

Answer 4

Это очень глубокая тема. В самом сердце нити, как правило, делают все быстрее, используя несколько ядер одновременно; или о выполнении длинных операций в фоновом режиме, когда у вас нет хорошего способа чередования операций с «первичным» потоком. Последнее очень распространено в программировании пользовательского интерфейса.

Ваш сценарий является одним из классических проблемных мест, и один из первых сталкивается. Для меня редко бывает структура, в которой члены действительно независимы. Очень часто требуется изменить несколько значений в структуре, чтобы поддерживать согласованность. Без каких-либо предосторожностей очень возможно изменить первое значение, затем другой поток прочитает структуру и начнет работать до того, как будет записано второе значение.

Простым примером будет структура «point» для 2d-графики. Вы хотите переместить точку с [2,2] до [5,6]. Если бы у вас был другой поток, который рисовал бы линию до этой точки, вы могли бы легко рисовать на [5,2].

Это верхушка айсберга. Есть много замечательных книг, но изучение этого пространства обычно происходит примерно так:

1. Э-э, я просто прочитал эту вещь в противоречивом состоянии.
2. Э-э, я только что изменил эту вещь из 2-х потоков, а теперь это мусор.
3. Yay! Я узнал о замках
4. Ого, у меня много замков, и все, кажется, просто зависает иногда, когда у меня много блокировок во вложенном коде.
5. Hrm. Мне нужно прекратить делать эту блокировку «на лету», мне, кажется, не хватает места; поэтому я должен инкапсулировать их в структуру данных.
6. Эта структура данных была отличной, но теперь я, кажется, все время блокируюсь, и мой код так же медленен, как и один поток.
7. переменные состояния являются странными
8. Это быстро, потому что я сообразил, как я блокирую вещи. Хмм. Иногда данные разлагаются.
9. Whoa .... InterlockedWhatDidYouSay?
10. Эй, не смотри замок, я делаю эту вещь как спин-замок.
11. Переменные условий. Хм ... Понимаю.
12. Вы знаете, что, как насчет я просто начать думать о том, как работать с этим материалом в совершенно независимых способах, pipelineing своих операций, и имеющие несколько перекрестных зависимостей потоков, как это возможно ...

Очевидно, что это не все о переменных условий. Но есть много проблем, которые могут быть решены с помощью потоковой передачи и, возможно, почти столько же способов сделать это, и еще больше способов сделать это неправильно.

Answer 5

что это?

Вкратце, программа, которая может выполняться в параллельном контексте без ошибок, связанных с параллелизмом.

Если ThreadA и ThreadB считывают и/или записывают данные без ошибок и используют надлежащую синхронизацию, то программа может быть потокобезопасной. Это выбор дизайна - создание объекта threadafe может осуществляться несколькими способами, а более сложные типы могут быть потокобезопасными с использованием комбинаций этих методов.

и как и где я могу научиться программировать безопасный код?

boost/libs/thread /, скорее всего, будет хорошим представлением. Тема довольно сложная.

Стандартная библиотека C++ 11 обеспечивает реализацию для блокировок, атомации и потоков - любые хорошо написанные программы, которые используют их, были бы хорошо прочитаны. Стандартная библиотека была смоделирована после внедрения boost.

также, предположим, что у меня есть 2 потока, которые записывают в структуру и другую, которая читает с нее. Это опасно? есть ли что-нибудь, что я должен искать?

Да, это может быть опасно и/или привести к неправильным результатам. Представьте себе, что поток может истекать из своего времени в любой момент, а затем другой поток может затем прочитать или изменить эту структуру - если вы его не защитили, это может быть в середине обновления. Общим решением является блокировка, которая может использоваться для предотвращения доступа другого потока к общим ресурсам во время чтения/записи.

Answer 6

Чтобы ответить на вторую часть вопроса: Представьте себе две темы, как доступ к std::vector<int> data:

//first thread 
if (data.size() > 0) 
{ 
    std::cout << data[0]; //fails if data.size() == 0 
} 

//second thread 
if (rand() % 5 == 0) 
{ 
    data.clear(); 
} 
else 
{ 
    data.push_back(1); 
} 

Выполнить эти нити параллельно и программа зависнет, поскольку std::cout << data[0]; может выполняться непосредственно после data.clear();.

Вам необходимо знать, что в любой точке вашего кода потока поток может быть прерван, например. после проверки этого (data.size() > 0), и другой поток может стать активным. Хотя первый поток выглядит корректно в однопоточном приложении, он не работает в многопоточной программе.

Answer 7

Безопасность потока - это простая концепция: безопасно ли выполнять операцию A на одном потоке, в то время как другой поток выполняет операцию B, которая может быть или не быть такой же, как операция A. Это может быть расширено для покрытия многих потоки. В этом контексте, «безопасный» означает:

• Нет неопределенное поведение
• Все инварианты структур данных гарантируется не наблюдается нитями

Фактические операции А и В имеют важное значение. Если два потока и читают a plain int переменная, то это нормально. Однако, если какой-либо поток может записать эту переменную, и нет синхронизации, чтобы убедиться, что чтение и запись не могут выполняться вместе, тогда у вас есть гонка данных, которая является неопределенным поведением, и это не потокобезопасный.

Это относится в равной степени к сценарию, о котором вы просили: если вы не приняли специальные меры предосторожности, то небезопасно, чтобы один поток считывался из структуры одновременно с записью другого потока. Если вы можете гарантировать, что потоки не могут одновременно получить доступ к структуре данных, используя некоторую форму синхронизации, такую ​​как мьютекс, критический раздел, семафор или событие, тогда нет проблем.

Вы можете использовать такие вещи, как мьютексы и критические разделы, чтобы предотвратить одновременный доступ к некоторым данным, так что поток записи является единственным потоком, который обращается к данным при его записи, а поток чтения - это единственный поток, который обращается к данным, когда он читает, тем самым предоставляя гарантию, о которой я только что упомянул. Поэтому это позволяет избежать неопределенного поведения, упомянутого выше.

Однако вам все же необходимо убедиться в том, что ваш код безопасен в более широком контексте: если вам нужно изменить несколько переменных, вам необходимо удерживать блокировку мьютекса на всей операции, а не на каждом отдельном доступе , в противном случае вы можете обнаружить, что инварианты вашей структуры данных могут не наблюдаться другими потоками.

Возможно также, что структура данных может быть потокобезопасной для некоторых операций, но не для других. Например, однопользовательская очередь с одним потребителем будет ОК, если один поток нажимает элементы в очереди, а другой выталкивает элементы из очереди, но прерывается, если два потока нажимают элементы, или два потока выталкивают элементы.

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

Моя книга, C++ Concurrency in Action охватывает то, что означает, что вещи должны быть потокобезопасными, как создавать потокобезопасные структуры данных и примитивы синхронизации C++, используемые для этой цели, такие как std::mutex.