Transition from boost::thread to std::thread.

PointCloudLibrary · taketwo · May 7, 2019 · May 2, 2019 · May 6, 2019 · 3d23d5b897e4bab881e4cc63be231b1e07cff7cf
commit 3d23d5b897e4bab881e4cc63be231b1e07cff7cf
diff --git a/common/include/pcl/common/boost.h b/common/include/pcl/common/boost.h
@@ -50,7 +50,6 @@
 #include <boost/mpl/size.hpp>
 #include <boost/date_time/posix_time/posix_time.hpp>
 #include <boost/function.hpp>
-#include <boost/thread.hpp>
 #include <boost/signals2.hpp>
 #include <boost/signals2/slot.hpp>
 #include <boost/algorithm/string.hpp>

diff --git a/common/include/pcl/common/time_trigger.h b/common/include/pcl/common/time_trigger.h
@@ -43,10 +43,11 @@
 #include <boost/function.hpp>
 #include <boost/thread.hpp>
 #include <boost/signals2.hpp>
+#endif
 
 #include <condition_variable>
 #include <mutex>
-#endif
+#include <thread>
 
 namespace pcl
 {
@@ -101,7 +102,7 @@ namespace pcl
       bool quit_;
       bool running_;
 
-      boost::thread timer_thread_;
+      std::thread timer_thread_;
       std::condition_variable condition_;
       std::mutex condition_mutex_;
   };

diff --git a/common/src/time_trigger.cpp b/common/src/time_trigger.cpp
@@ -49,7 +49,7 @@ pcl::TimeTrigger::TimeTrigger (double interval, const callback_type& callback)
 , condition_ ()
 , condition_mutex_ ()
 {
-  timer_thread_ = boost::thread (boost::bind (&TimeTrigger::thread_function, this));
+  timer_thread_ = std::thread (&TimeTrigger::thread_function, this);
   registerCallback (callback);
 }
 
@@ -63,7 +63,7 @@ pcl::TimeTrigger::TimeTrigger (double interval)
 , condition_ ()
 , condition_mutex_ ()
 {
-  timer_thread_ = boost::thread (boost::bind (&TimeTrigger::thread_function, this));
+  timer_thread_ = std::thread (&TimeTrigger::thread_function, this);
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////

diff --git a/gpu/kinfu_large_scale/tools/record_maps_rgb.cpp b/gpu/kinfu_large_scale/tools/record_maps_rgb.cpp
@@ -323,11 +323,11 @@ main (int argc, char** argv)
   buff.setCapacity (buff_size);
   std::cout << "Starting the producer and consumer threads..." << std::endl;
   std::cout << "Press Ctrl-C to end" << std::endl;
-  boost::thread producer (grabAndSend);
+  std::thread producer (grabAndSend);
   std::this_thread::sleep_for(2s);
-  boost::thread consumer (receiveAndProcess);
-  boost::thread consumer2 (receiveAndProcess);
-  boost::thread consumer3 (receiveAndProcess);
+  std::thread consumer (receiveAndProcess);
+  std::thread consumer2 (receiveAndProcess);
+  std::thread consumer3 (receiveAndProcess);
   signal (SIGINT, ctrlC);
   producer.join ();
   {

diff --git a/io/include/pcl/io/boost.h b/io/include/pcl/io/boost.h
@@ -47,7 +47,6 @@
 #include <boost/numeric/conversion/cast.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/condition.hpp>
-#include <boost/thread.hpp>
 #include <boost/filesystem.hpp>
 #include <boost/bind.hpp>
 #include <boost/cstdint.hpp>

diff --git a/io/include/pcl/io/davidsdk_grabber.h b/io/include/pcl/io/davidsdk_grabber.h
@@ -47,6 +47,8 @@
 
 #include <david.h>
 
+#include <thread>
+
 namespace pcl
 {
   struct PointXYZ;
@@ -217,7 +219,7 @@ namespace pcl
 
     protected:
       /** @brief Grabber thread */
-      boost::thread grabber_thread_;
+      std::thread grabber_thread_;
 
       /** @brief Boost point cloud signal */
       boost::signals2::signal<sig_cb_davidsdk_point_cloud>* point_cloud_signal_;

diff --git a/io/include/pcl/io/depth_sense/depth_sense_device_manager.h b/io/include/pcl/io/depth_sense/depth_sense_device_manager.h
@@ -45,6 +45,8 @@
 
 #include <DepthSense.hxx>
 
+#include <thread>
+
 namespace pcl
 {
 
@@ -136,7 +138,7 @@ namespace pcl
           static boost::mutex mutex_;
 
           /// Thread where the grabbing takes place.
-          boost::thread depth_sense_thread_;
+          std::thread depth_sense_thread_;
 
           struct CapturedDevice
           {

diff --git a/io/include/pcl/io/dinast_grabber.h b/io/include/pcl/io/dinast_grabber.h
@@ -47,6 +47,8 @@
 #include <libusb-1.0/libusb.h>
 #include <boost/circular_buffer.hpp>
 
+#include <thread>
+
 namespace pcl
 {
   /** \brief Grabber for DINAST devices (i.e., IPA-1002, IPA-1110, IPA-2001)
@@ -206,7 +208,7 @@ namespace pcl
 
       bool running_;
 
-      boost::thread capture_thread_;
+      std::thread capture_thread_;
 
       mutable boost::mutex capture_mutex_;
       boost::signals2::signal<sig_cb_dinast_point_cloud>* point_cloud_signal_;

diff --git a/io/include/pcl/io/ensenso_grabber.h b/io/include/pcl/io/ensenso_grabber.h
@@ -52,6 +52,8 @@
 
 #include <nxLib.h> // Ensenso SDK
 
+#include <thread>
+
 namespace pcl
 {
   struct PointXYZ;
@@ -434,7 +436,7 @@ namespace pcl
 
     protected:
       /** @brief Grabber thread */
-      boost::thread grabber_thread_;
+      std::thread grabber_thread_;
 
       /** @brief Boost point cloud signal */
       boost::signals2::signal<sig_cb_ensenso_point_cloud>* point_cloud_signal_;

diff --git a/io/include/pcl/io/hdl_grabber.h b/io/include/pcl/io/hdl_grabber.h
@@ -46,6 +46,7 @@
 #include <pcl/point_cloud.h>
 #include <boost/asio.hpp>
 #include <string>
+#include <thread>
 
 #define HDL_Grabber_toRadians(x) ((x) * M_PI / 180.0)
 
@@ -293,8 +294,8 @@ namespace pcl
       boost::asio::io_service hdl_read_socket_service_;
       boost::asio::ip::udp::socket *hdl_read_socket_;
       std::string pcap_file_name_;
-      boost::thread *queue_consumer_thread_;
-      boost::thread *hdl_read_packet_thread_;
+      std::thread *queue_consumer_thread_;
+      std::thread *hdl_read_packet_thread_;
       bool terminate_read_packet_thread_;
       pcl::RGB laser_rgb_mapping_[HDL_MAX_NUM_LASERS];
       float min_distance_threshold_;

diff --git a/io/include/pcl/io/openni_camera/openni_device.h b/io/include/pcl/io/openni_camera/openni_device.h
@@ -41,8 +41,9 @@
 #ifdef HAVE_OPENNI
 
 #include <map>
-#include <vector>
+#include <thread>
 #include <utility>
+#include <vector>
 #include "openni_exception.h"
 #include "openni.h"
 
@@ -549,9 +550,9 @@ namespace openni_wrapper
       boost::condition_variable image_condition_;
       boost::condition_variable depth_condition_;
       boost::condition_variable ir_condition_;
-      boost::thread image_thread_;
-      boost::thread depth_thread_;
-      boost::thread ir_thread_;
+      std::thread image_thread_;
+      std::thread depth_thread_;
+      std::thread ir_thread_;
   };
 
   ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

diff --git a/io/include/pcl/io/openni_camera/openni_device_oni.h b/io/include/pcl/io/openni_camera/openni_device_oni.h
@@ -97,7 +97,7 @@ namespace openni_wrapper
     static void __stdcall NewONIIRDataAvailable (xn::ProductionNode& node, void* cookie) throw ();
 
     xn::Player player_;
-    boost::thread player_thread_;
+    std::thread player_thread_;
     mutable boost::mutex player_mutex_;
     boost::condition_variable player_condition_;
     bool streaming_;

diff --git a/io/include/pcl/io/real_sense_grabber.h b/io/include/pcl/io/real_sense_grabber.h
@@ -44,6 +44,8 @@
 #include <pcl/point_types.h>
 #include <pcl/common/time.h>
 
+#include <thread>
+
 namespace pcl
 {
 
@@ -265,7 +267,7 @@ namespace pcl
       EventFrequency frequency_;
       mutable boost::mutex fps_mutex_;
 
-      boost::thread thread_;
+      std::thread thread_;
 
       /// Depth buffer to perform temporal filtering of the depth images
       boost::shared_ptr<pcl::io::Buffer<unsigned short> > depth_buffer_;

diff --git a/io/include/pcl/io/robot_eye_grabber.h b/io/include/pcl/io/robot_eye_grabber.h
@@ -45,6 +45,8 @@
 #include <pcl/point_cloud.h>
 #include <boost/asio.hpp>
 
+#include <thread>
+
 namespace pcl
 {
 
@@ -129,8 +131,8 @@ namespace pcl
       boost::asio::ip::udp::endpoint sender_endpoint_;
       boost::asio::io_service io_service_;
       boost::shared_ptr<boost::asio::ip::udp::socket> socket_;
-      boost::shared_ptr<boost::thread> socket_thread_;
-      boost::shared_ptr<boost::thread> consumer_thread_;
+      boost::shared_ptr<std::thread> socket_thread_;
+      boost::shared_ptr<std::thread> consumer_thread_;
 
       pcl::SynchronizedQueue<boost::shared_array<unsigned char> > packet_queue_;
       boost::shared_ptr<pcl::PointCloud<pcl::PointXYZI> > point_cloud_xyzi_;

diff --git a/io/src/davidsdk_grabber.cpp b/io/src/davidsdk_grabber.cpp
@@ -137,7 +137,7 @@ pcl::DavidSDKGrabber::start ()
 
   frequency_.reset ();
   running_ = true;
-  grabber_thread_ = boost::thread (&pcl::DavidSDKGrabber::processGrabbing, this);
+  grabber_thread_ = std::thread (&pcl::DavidSDKGrabber::processGrabbing, this);
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////

diff --git a/io/src/depth_sense/depth_sense_device_manager.cpp b/io/src/depth_sense/depth_sense_device_manager.cpp
@@ -47,7 +47,7 @@ pcl::io::depth_sense::DepthSenseDeviceManager::DepthSenseDeviceManager ()
   try
   {
     context_ = DepthSense::Context::create ("localhost");
-    depth_sense_thread_ = boost::thread (&DepthSense::Context::run, &context_);
+    depth_sense_thread_ = std::thread (&DepthSense::Context::run, &context_);
   }
   catch (...)
   {

diff --git a/io/src/dinast_grabber.cpp b/io/src/dinast_grabber.cpp
@@ -107,7 +107,7 @@ void
 pcl::DinastGrabber::onInit (const int device_position)
 {
   setupDevice (device_position);
-  capture_thread_ = boost::thread (&DinastGrabber::captureThreadFunction, this);
+  capture_thread_ = std::thread (&DinastGrabber::captureThreadFunction, this);
   image_ = new unsigned char [image_size_];
 }
 

diff --git a/io/src/ensenso_grabber.cpp b/io/src/ensenso_grabber.cpp
@@ -205,7 +205,7 @@ pcl::EnsensoGrabber::start ()
 
   frequency_.reset ();
   running_ = true;
-  grabber_thread_ = boost::thread (&pcl::EnsensoGrabber::processGrabbing, this);
+  grabber_thread_ = std::thread (&pcl::EnsensoGrabber::processGrabbing, this);
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////

diff --git a/io/src/hdl_grabber.cpp b/io/src/hdl_grabber.cpp
@@ -494,7 +494,7 @@ pcl::HDLGrabber::start ()
   if (isRunning ())
     return;
 
-  queue_consumer_thread_ = new boost::thread (boost::bind (&HDLGrabber::processVelodynePackets, this));
+  queue_consumer_thread_ = new std::thread (&HDLGrabber::processVelodynePackets, this);
 
   if (pcap_file_name_.empty ())
   {
@@ -524,12 +524,12 @@ pcl::HDLGrabber::start ()
       PCL_ERROR("[pcl::HDLGrabber::start] Unable to bind to socket! %s\n", e.what ());
       return;
     }
-    hdl_read_packet_thread_ = new boost::thread (boost::bind (&HDLGrabber::readPacketsFromSocket, this));
+    hdl_read_packet_thread_ = new std::thread (&HDLGrabber::readPacketsFromSocket, this);
   }
   else
   {
 #ifdef HAVE_PCAP
-    hdl_read_packet_thread_ = new boost::thread (boost::bind (&HDLGrabber::readPacketsFromPcap, this));
+    hdl_read_packet_thread_ = new std::thread (&HDLGrabber::readPacketsFromPcap, this);
 #endif // #ifdef HAVE_PCAP
   }
 }
@@ -538,12 +538,12 @@ pcl::HDLGrabber::start ()
 void
 pcl::HDLGrabber::stop ()
 {
+  // triggers the exit condition
   terminate_read_packet_thread_ = true;
   hdl_data_.stopQueue ();
 
   if (hdl_read_packet_thread_ != nullptr)
   {
-    hdl_read_packet_thread_->interrupt ();
     hdl_read_packet_thread_->join ();
     delete hdl_read_packet_thread_;
     hdl_read_packet_thread_ = nullptr;
@@ -566,7 +566,7 @@ pcl::HDLGrabber::stop ()
 bool
 pcl::HDLGrabber::isRunning () const
 {
-  return (!hdl_data_.isEmpty () || (hdl_read_packet_thread_ != nullptr && !hdl_read_packet_thread_->timed_join (boost::posix_time::milliseconds (10))));
+  return (!hdl_data_.isEmpty () || hdl_read_packet_thread_);
 }
 
 /////////////////////////////////////////////////////////////////////////////

diff --git a/io/src/openni_camera/openni_device.cpp b/io/src/openni_camera/openni_device.cpp
@@ -393,19 +393,19 @@ openni_wrapper::OpenNIDevice::Init ()
     //focal length from mm -> pixels (valid for 1280x1024)
     depth_focal_length_SXGA_ = static_cast<float> (static_cast<XnDouble> (depth_focal_length_SXGA) / pixel_size);
 
-    depth_thread_ = boost::thread (&OpenNIDevice::DepthDataThreadFunction, this);
+    depth_thread_ = std::thread (&OpenNIDevice::DepthDataThreadFunction, this);
   }
 
   if (hasImageStream ())
   {
     boost::lock_guard<boost::mutex> image_lock (image_mutex_);
-    image_thread_ = boost::thread (&OpenNIDevice::ImageDataThreadFunction, this);
+    image_thread_ = std::thread (&OpenNIDevice::ImageDataThreadFunction, this);
   }
 
   if (hasIRStream ())
   {
     boost::lock_guard<boost::mutex> ir_lock (ir_mutex_);
-    ir_thread_ = boost::thread (&OpenNIDevice::IRDataThreadFunction, this);
+    ir_thread_ = std::thread (&OpenNIDevice::IRDataThreadFunction, this);
   }
 }
 

diff --git a/io/src/openni_camera/openni_device_oni.cpp b/io/src/openni_camera/openni_device_oni.cpp
@@ -97,7 +97,7 @@ openni_wrapper::DeviceONI::DeviceONI (
 
   player_.SetRepeat (repeat);
   if (streaming_)
-    player_thread_ = boost::thread (&DeviceONI::PlayerThreadFunction, this);
+    player_thread_ = std::thread (&DeviceONI::PlayerThreadFunction, this);
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

diff --git a/io/src/pcd_grabber.cpp b/io/src/pcd_grabber.cpp
@@ -395,7 +395,7 @@ pcl::PCDGrabberBase::start ()
   }
   else // manual trigger
   {
-    boost::thread non_blocking_call (boost::bind (&PCDGrabberBase::PCDGrabberImpl::trigger, impl_));
+    std::thread non_blocking_call (&PCDGrabberBase::PCDGrabberImpl::trigger, impl_);
   }
 }
 
@@ -416,7 +416,7 @@ pcl::PCDGrabberBase::trigger ()
 {
   if (impl_->frames_per_second_ > 0)
     return;
-  boost::thread non_blocking_call (boost::bind (&PCDGrabberBase::PCDGrabberImpl::trigger, impl_));
+  std::thread non_blocking_call (&PCDGrabberBase::PCDGrabberImpl::trigger, impl_);
 
 //  impl_->trigger ();
 }

diff --git a/io/src/real_sense_grabber.cpp b/io/src/real_sense_grabber.cpp
@@ -170,7 +170,7 @@ pcl::RealSenseGrabber::start ()
         THROW_IO_EXCEPTION ("Invalid stream profile for PXC device");
       frequency_.reset ();
       is_running_ = true;
-      thread_ = boost::thread (&RealSenseGrabber::run, this);
+      thread_ = std::thread (&RealSenseGrabber::run, this);
     }
   }
 }

diff --git a/io/src/robot_eye_grabber.cpp b/io/src/robot_eye_grabber.cpp
@@ -326,8 +326,8 @@ pcl::RobotEyeGrabber::start ()
 
   terminate_thread_ = false;
   resetPointCloud ();
-  consumer_thread_.reset(new boost::thread (boost::bind (&RobotEyeGrabber::consumerThreadLoop, this)));
-  socket_thread_.reset(new boost::thread (boost::bind (&RobotEyeGrabber::socketThreadLoop, this)));
+  consumer_thread_.reset(new std::thread (&RobotEyeGrabber::consumerThreadLoop, this));
+  socket_thread_.reset(new std::thread (&RobotEyeGrabber::socketThreadLoop, this));
 }
 
 /////////////////////////////////////////////////////////////////////////////