Motivación: la razón por la que lo estoy considerando es que mi genio gerente de proyecto piensa que el impulso es otra dependencia y que es horrible porque "usted depende de él" (intenté explicar la calidad del impulso, y luego me di por vencido después de un tiempo :( La razón más pequeña por la que me gustaría hacerlo es que me gustaría aprender las características de c ++ 11, porque la gente comenzará a escribir código en él.

1. ¿Existe un mapeo 1: 1 entre #include<thread> #include<mutex>y equivalentes de impulso?
2. ¿Consideraría una buena idea reemplazar las cosas de impulso con cosas de c ++ 11
   ? Mi uso es primitivo, pero ¿hay ejemplos cuando std no ofrece qué impulso? O (blasfemia) viceversa?

PD: uso GCC, así que los encabezados están ahí.

Existen varias diferencias entre Boost.Thread y la biblioteca de hilos estándar C ++ 11:

• Boost admite la cancelación de subprocesos, los subprocesos de C ++ 11 no
• C ++ 11 es compatible std::async, pero Boost no
• Boost tiene un boost::shared_mutexbloqueo de lector múltiple / escritor único. El análogo std::shared_timed_mutexestá disponible solo desde C ++ 14 ( N3891 ), mientras que std::shared_mutexestá disponible solo desde C ++ 17 ( N4508 ).
• Los tiempos de espera de C ++ 11 son diferentes a los tiempos de espera de Boost (aunque esto pronto debería cambiar ahora Boost.Chrono ha sido aceptado).
• Algunos de los nombres son diferentes (por ejemplo, boost::unique_futurevs std::future)
• La semántica de paso de argumentos std::threades diferente de boost::thread--- Usos de refuerzo boost::bind, que requiere argumentos copiables. std::threadpermite que los tipos de solo movimiento std::unique_ptrse pasen como argumentos. Debido al uso de boost::bind, la semántica de los marcadores de posición, como _1en las expresiones de enlace anidadas, también puede ser diferente.
• Si no llama explícitamente join()o detach()el boost::threaddestructor y el operador de asignación llamarán detach()al objeto de hilo que se destruye / asigna. Con un std::threadobjeto C ++ 11 , esto dará como resultado una llamada astd::terminate() y anulará la aplicación.

Para aclarar el punto sobre los parámetros de solo movimiento, lo siguiente es válido C ++ 11, y transfiere la propiedad de intlo temporal std::unique_ptral parámetro de f1cuándo se inicia el nuevo hilo. Sin embargo, si lo usa boost::thread, no funcionará, ya que se usa boost::bindinternamente y std::unique_ptrno se puede copiar. También hay un error en la biblioteca de subprocesos C ++ 11 proporcionada con GCC que impide que esto funcione, ya que también se usa std::binden la implementación allí.

void f1(std::unique_ptr<int>);
std::thread t1(f1,std::unique_ptr<int>(new int(42)));

Si está utilizando Boost, entonces probablemente pueda cambiar a subprocesos de C ++ 11 sin problemas si su compilador lo admite (por ejemplo, las versiones recientes de GCC en Linux tienen una implementación casi completa de la biblioteca de subprocesos de C ++ 11 disponible en -std=c++0x modo).

Si su compilador no admite subprocesos de C ++ 11, puede obtener una implementación de terceros como Just :: Thread , pero esto sigue siendo una dependencia.

std::threadestá modelado en gran parte después boost::thread, con algunas diferencias :

• la semántica no copiable de boost, de un controlador de mapas a uno de os, se conserva. Pero este hilo es móvil para permitir el retorno del hilo de las funciones de fábrica y su colocación en contenedores.
• Esta propuesta agrega cancelación a la boost::thread , lo cual es una complicación significativa. Este cambio tiene un gran impacto no solo en el subproceso sino también en el resto de la biblioteca de subprocesos de C ++. Se cree que este gran cambio es justificable debido al beneficio.
  • El destructor de subprocesos ahora debe llamar a cancelar antes de desconectar para evitar fugas accidentales de subprocesos secundarios cuando se cancelan los subprocesos principales.
  • Ahora se requiere un miembro de separación explícito para habilitar la separación sin cancelar.
• Los conceptos de identificador de hilo e identidad de hilo se han separado en dos clases (son la misma clase boost::thread). Esto es para facilitar la manipulación y el almacenamiento de la identidad del hilo.
• Se ha agregado la capacidad de crear una identificación de subproceso que se garantiza que se compara igual que ningún otro subproceso unible ( boost::threadno tiene esto). Esto es útil para el código que quiere saber si está siendo ejecutado por el mismo hilo que una llamada anterior (los mutex recursivos son un ejemplo concreto).
• Existe una "puerta trasera" para obtener el identificador de subproceso nativo para que los clientes puedan manipular subprocesos utilizando el sistema operativo subyacente si lo desean.

Esto es de 2007, por lo que algunos puntos ya no son válidos: boost::threadtiene una native_handlefunción ahora y, como señalan los comentaristas, std::threadya no tiene cancelación.

No pude encontrar diferencias significativas entre boost::mutexy std::mutex.

Hay una razón para no migrar std::thread.

Si está utilizando enlaces estáticos, std::threadqueda inutilizable debido a estos errores / características de gcc:

• http://gcc.gnu.org/bugzilla/show_bug.cgi?id=52590
• http://gcc.gnu.org/bugzilla/show_bug.cgi?id=57740

Es decir, si llama std::thread::detacho std::thread::joinprovocará una excepción o un bloqueo, mientras boost::threadfunciona bien en estos casos.

Caso empresarial

Si está escribiendo software para la empresa que necesita ejecutarse en una variedad moderada a grande de sistemas operativos y, en consecuencia, construir con una variedad de compiladores y versiones de compiladores (especialmente los relativamente antiguos) en esos sistemas operativos, mi sugerencia es mantenerse alejado de C ++ 11 en total por ahora. Eso significa que no puede usar std::thread, y recomendaría usar boost::thread.

Funda Básica / Tech Startup

Si está escribiendo para uno o dos sistemas operativos, sabe con certeza que solo necesitará compilar con un compilador moderno que sea compatible principalmente con C ++ 11 (por ejemplo, VS2015, GCC 5.3, Xcode 7), y aún no lo ha hecho. dependiendo de la biblioteca de impulso, entonces std::threadpodría ser una buena opción.

Mi experiencia

Personalmente, soy partidario de las bibliotecas reforzadas, muy utilizadas, altamente compatibles y altamente consistentes, como boost versus una alternativa muy moderna. Esto es especialmente cierto para temas de programación complicados como el enhebrado. Además, durante mucho tiempo he experimentado un gran éxito con boost::thread(y boost en general) en una amplia gama de entornos, compiladores, modelos de subprocesos, etc. Cuando es mi elección, elijo boost.

Con Visual Studio 2013, std::mutexparece que se comporta de manera diferente que el boost::mutex, lo que me causó algunos problemas (vea esta pregunta ).

Con respecto a std :: shared_mutex agregado en C ++ 17

Las otras respuestas aquí proporcionan una muy buena visión general de las diferencias en general. Sin embargo, hay varios problemas con std::shared_mutexese impulso resuelve.

1. Muticios actualizables. Estos están ausentes de std::thread. Permiten que un lector se actualice a escritor sin permitir que otros escritores entren antes que usted . Estos le permiten hacer cosas como preprocesar un gran cálculo (por ejemplo, reindexar una estructura de datos) cuando está en modo de lectura, luego actualizar para escribir para aplicar el reindex mientras mantiene presionado el bloqueo de escritura por un corto tiempo.

2. Justicia. Si tiene actividad de lectura constante con a std::shared_mutex, sus escritores estarán bloqueados indefinidamente. Esto se debe a que si aparece otro lector, siempre se les dará prioridad. Con boost:shared_mutex, todos los hilos eventualmente tendrán prioridad. ⁽¹⁾ Ni los lectores ni los escritores estarán hambrientos.

El problema de esto es que si tiene un sistema de alto rendimiento sin tiempo de inactividad y una contención muy alta, std::shared_mutexnunca funcionará para usted sin construir manualmente un sistema prioritario sobre él. boost::shared_mutexfuncionará de la caja, aunque es posible que deba modificarlo en ciertos casos. Yo diría que std::shared_mutexel comportamiento es un error latente que espera suceder en la mayoría de los códigos que lo usan.

⁽¹⁾ _{El algoritmo real que utiliza se basa en el programador de subprocesos del sistema operativo. En mi experiencia, cuando las lecturas están saturadas, hay pausas más largas (al obtener un bloqueo de escritura) en Windows que en OSX / Linux.}

Intenté usar shared_ptr desde std en lugar de boost y de hecho encontré un error en la implementación de gcc de esta clase. Mi aplicación se bloqueó debido a que el destructor se llamó dos veces (esta clase debería ser segura para subprocesos y no debería generar tales problemas). Después de mover para impulsar :: shared_ptr todos los problemas desaparecieron. Las implementaciones actuales de C ++ 11 aún no están maduras.

Boost también tiene más características. Por ejemplo, el encabezado en la versión estándar no proporciona el serializador a una secuencia (es decir, cout << duración). Boost tiene muchas bibliotecas que usan sus propios equivalentes, etc., pero no cooperan con las versiones estándar.

En resumen: si ya tiene una aplicación escrita con boost, es más seguro mantener su código tal como está en lugar de esforzarse para pasar al estándar C ++ 11.