diff --git a/include/spdlog/details/async_log_helper.h b/include/spdlog/details/async_log_helper.h
index 6145dfa6..ee6d4c61 100644
--- a/include/spdlog/details/async_log_helper.h
+++ b/include/spdlog/details/async_log_helper.h
@@ -384,7 +384,7 @@ inline void spdlog::details::async_log_helper::sleep_or_yield(const spdlog::log_
 inline void spdlog::details::async_log_helper::wait_empty_q()
 {
     auto last_op = details::os::now();
-    while (_q.approx_size() > 0)
+    while (!_q.is_empty())
     {
         sleep_or_yield(details::os::now(), last_op);
     }
diff --git a/include/spdlog/details/mpmc_bounded_q.h b/include/spdlog/details/mpmc_bounded_q.h
index d8a9188e..55e99cdd 100644
--- a/include/spdlog/details/mpmc_bounded_q.h
+++ b/include/spdlog/details/mpmc_bounded_q.h
@@ -50,123 +50,119 @@ Distributed under the MIT License (http://opensource.org/licenses/MIT)
 
 namespace spdlog
 {
-namespace details
-{
+	namespace details
+	{
 
-template<typename T>
-class mpmc_bounded_queue
-{
-public:
+		template<typename T>
+		class mpmc_bounded_queue
+		{
+		public:
 
-    using item_type = T;
-    mpmc_bounded_queue(size_t buffer_size)
-        :max_size_(buffer_size),
-         buffer_(new cell_t [buffer_size]),
-         buffer_mask_(buffer_size - 1)
-    {
-        //queue size must be power of two
-        if(!((buffer_size >= 2) && ((buffer_size & (buffer_size - 1)) == 0)))
-            throw spdlog_ex("async logger queue size must be power of two");
+			using item_type = T;
+			mpmc_bounded_queue(size_t buffer_size)
+				:max_size_(buffer_size),
+				buffer_(new cell_t[buffer_size]),
+				buffer_mask_(buffer_size - 1)
+			{
+				//queue size must be power of two
+				if (!((buffer_size >= 2) && ((buffer_size & (buffer_size - 1)) == 0)))
+					throw spdlog_ex("async logger queue size must be power of two");
 
-        for (size_t i = 0; i != buffer_size; i += 1)
-            buffer_[i].sequence_.store(i, std::memory_order_relaxed);
-        enqueue_pos_.store(0, std::memory_order_relaxed);
-        dequeue_pos_.store(0, std::memory_order_relaxed);
-    }
+				for (size_t i = 0; i != buffer_size; i += 1)
+					buffer_[i].sequence_.store(i, std::memory_order_relaxed);
+				enqueue_pos_.store(0, std::memory_order_relaxed);
+				dequeue_pos_.store(0, std::memory_order_relaxed);
+			}
 
-    ~mpmc_bounded_queue()
-    {
-        delete [] buffer_;
-    }
+			~mpmc_bounded_queue()
+			{
+				delete[] buffer_;
+			}
 
 
-    bool enqueue(T&& data)
-    {
-        cell_t* cell;
-        size_t pos = enqueue_pos_.load(std::memory_order_relaxed);
-        for (;;)
-        {
-            cell = &buffer_[pos & buffer_mask_];
-            size_t seq = cell->sequence_.load(std::memory_order_acquire);
-            intptr_t dif = static_cast<intptr_t>(seq) - static_cast<intptr_t>(pos);
-            if (dif == 0)
-            {
-                if (enqueue_pos_.compare_exchange_weak(pos, pos + 1, std::memory_order_relaxed))
-                    break;
-            }
-            else if (dif < 0)
-            {
-                return false;
-            }
-            else
-            {
-                pos = enqueue_pos_.load(std::memory_order_relaxed);
-            }
-        }
-        cell->data_ = std::move(data);
-        cell->sequence_.store(pos + 1, std::memory_order_release);
-        return true;
-    }
+			bool enqueue(T&& data)
+			{
+				cell_t* cell;
+				size_t pos = enqueue_pos_.load(std::memory_order_relaxed);
+				for (;;) {
+					cell = &buffer_[pos & buffer_mask_];
+					size_t seq = cell->sequence_.load(std::memory_order_acquire);
+					intptr_t dif = static_cast<intptr_t>(seq) - static_cast<intptr_t>(pos);
+					if (dif == 0) {
+						if (enqueue_pos_.compare_exchange_weak(pos, pos + 1, std::memory_order_relaxed))
+							break;
+					}
+					else if (dif < 0) {
+						return false;
+					}
+					else {
+						pos = enqueue_pos_.load(std::memory_order_relaxed);
+					}
+				}
+				cell->data_ = std::move(data);
+				cell->sequence_.store(pos + 1, std::memory_order_release);
+				return true;
+			}
 
-    bool dequeue(T& data)
-    {
-        cell_t* cell;
-        size_t pos = dequeue_pos_.load(std::memory_order_relaxed);
-        for (;;)
-        {
-            cell = &buffer_[pos & buffer_mask_];
-            size_t seq =
-                cell->sequence_.load(std::memory_order_acquire);
-            intptr_t dif = static_cast<intptr_t>(seq) - static_cast<intptr_t>(pos + 1);
-            if (dif == 0)
-            {
-                if (dequeue_pos_.compare_exchange_weak(pos, pos + 1, std::memory_order_relaxed))
-                    break;
-            }
-            else if (dif < 0)
-                return false;
-            else
-                pos = dequeue_pos_.load(std::memory_order_relaxed);
-        }
-        data = std::move(cell->data_);
-        cell->sequence_.store(pos + buffer_mask_ + 1, std::memory_order_release);
-        return true;
-    }
+			bool dequeue(T& data)
+			{
+				cell_t* cell;
+				size_t pos = dequeue_pos_.load(std::memory_order_relaxed);
+				for (;;) {
+					cell = &buffer_[pos & buffer_mask_];
+					size_t seq =
+						cell->sequence_.load(std::memory_order_acquire);
+					intptr_t dif = static_cast<intptr_t>(seq) - static_cast<intptr_t>(pos + 1);
+					if (dif == 0) {
+						if (dequeue_pos_.compare_exchange_weak(pos, pos + 1, std::memory_order_relaxed))
+							break;
+					}
+					else if (dif < 0)
+						return false;
+					else
+						pos = dequeue_pos_.load(std::memory_order_relaxed);
+				}
+				data = std::move(cell->data_);
+				cell->sequence_.store(pos + buffer_mask_ + 1, std::memory_order_release);
+				return true;
+			}
 
-    size_t approx_size()
-    {
-        size_t first_pos = dequeue_pos_.load(std::memory_order_relaxed);
-        size_t last_pos = enqueue_pos_.load(std::memory_order_relaxed);
-        if (last_pos <= first_pos)
-            return 0;
-        auto size = last_pos - first_pos;
-        return size < max_size_ ? size : max_size_;
-    }
+			bool is_empty()
+			{				
+				unsigned front, front1, back;
+				// try to take a consistent snapshot of front/tail.
+				do {					
+					front = enqueue_pos_.load(std::memory_order_acquire);
+					back = dequeue_pos_.load(std::memory_order_acquire);
+					front1 = enqueue_pos_.load(std::memory_order_relaxed);
+				} while (front != front1);
+				return back == front;
+			}
 
-private:
-    struct cell_t
-    {
-        std::atomic<size_t>   sequence_;
-        T                     data_;
-    };
+		private:
+			struct cell_t
+			{
+				std::atomic<size_t>   sequence_;
+				T                     data_;
+			};
 
-    size_t const max_size_;
+			size_t const max_size_;
 
-    static size_t const     cacheline_size = 64;
-    typedef char            cacheline_pad_t [cacheline_size];
+			static size_t const     cacheline_size = 64;
+			typedef char            cacheline_pad_t[cacheline_size];
 
-    cacheline_pad_t         pad0_;
-    cell_t* const           buffer_;
-    size_t const            buffer_mask_;
-    cacheline_pad_t         pad1_;
-    std::atomic<size_t>     enqueue_pos_;
-    cacheline_pad_t         pad2_;
-    std::atomic<size_t>     dequeue_pos_;
-    cacheline_pad_t         pad3_;
+			cacheline_pad_t         pad0_;
+			cell_t* const           buffer_;
+			size_t const            buffer_mask_;
+			cacheline_pad_t         pad1_;
+			std::atomic<size_t>     enqueue_pos_;
+			cacheline_pad_t         pad2_;
+			std::atomic<size_t>     dequeue_pos_;
+			cacheline_pad_t         pad3_;
 
-    mpmc_bounded_queue(mpmc_bounded_queue const&) = delete;
-    void operator= (mpmc_bounded_queue const&) = delete;
-};
+			mpmc_bounded_queue(mpmc_bounded_queue const&) = delete;
+			void operator= (mpmc_bounded_queue const&) = delete;
+		};
 
-} // ns details
+	} // ns details
 } // ns spdlog