diff --git a/lib/cpp/test/concurrency/MutexTest.cpp b/lib/cpp/test/concurrency/MutexTest.cpp
deleted file mode 100644
index 781ec1a..0000000
--- a/lib/cpp/test/concurrency/MutexTest.cpp
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-// This is linked into the UnitTests test executable
-
-#include <boost/test/unit_test.hpp>
-
-#include "thrift/concurrency/Exception.h"
-#include "thrift/concurrency/Mutex.h"
-
-using boost::unit_test::test_suite;
-using boost::unit_test::framework::master_test_suite;
-
-using namespace apache::thrift::concurrency;
-
-struct LFAT
-{
-  LFAT()
-    : uut(Mutex::ERRORCHECK_INITIALIZER)
-  {
-    BOOST_CHECK_EQUAL(0, pthread_mutex_init(&mx, 0));
-    BOOST_CHECK_EQUAL(0, pthread_cond_init(&cv, 0));
-  }
-
-  Mutex uut;
-  pthread_mutex_t mx;
-  pthread_cond_t cv;
-};
-
-// Helper for testing mutex behavior when locked by another thread
-void * lockFromAnotherThread(void *ptr)
-{
-  struct LFAT *lfat = (LFAT *)ptr;
-  BOOST_CHECK_EQUAL   (0, pthread_mutex_lock(&lfat->mx));           // synchronize with testing thread
-  BOOST_CHECK_NO_THROW( lfat->uut.lock());
-  BOOST_CHECK_EQUAL   (0, pthread_cond_signal(&lfat->cv));          // tell testing thread we have locked the mutex
-  BOOST_CHECK_EQUAL   (0, pthread_cond_wait(&lfat->cv, &lfat->mx)); // wait for testing thread to signal condition variable telling us to unlock
-  BOOST_CHECK_NO_THROW( lfat->uut.unlock());
-  return ptr;                                                       // testing thread should join to ensure completeness
-}
-
-BOOST_AUTO_TEST_SUITE(MutexTest)
-
-BOOST_AUTO_TEST_CASE(happy_path)
-{
-  Mutex uut(Mutex::ERRORCHECK_INITIALIZER);                         // needed to test unlocking twice without undefined behavior
-
-  BOOST_CHECK_NO_THROW( uut.lock());
-  BOOST_CHECK_THROW   ( uut.lock(), SystemResourceException);       // EDEADLK (this thread owns it)
-  BOOST_CHECK_NO_THROW( uut.unlock());
-}
-
-BOOST_AUTO_TEST_CASE(recursive_happy_path)
-{
-  Mutex uut(Mutex::RECURSIVE_INITIALIZER);
-
-  BOOST_CHECK_NO_THROW( uut.lock());
-  BOOST_CHECK_NO_THROW( uut.lock());
-  BOOST_CHECK_NO_THROW( uut.unlock());
-  BOOST_CHECK_NO_THROW( uut.lock());
-  BOOST_CHECK_NO_THROW( uut.lock());
-  BOOST_CHECK_NO_THROW( uut.unlock());
-  BOOST_CHECK_NO_THROW( uut.lock());
-  BOOST_CHECK_NO_THROW( uut.unlock());
-  BOOST_CHECK_NO_THROW( uut.unlock());
-  BOOST_CHECK_NO_THROW( uut.unlock());
-}
-
-BOOST_AUTO_TEST_CASE(trylock)
-{
-  Mutex uut(Mutex::ADAPTIVE_INITIALIZER);   // just using another initializer for coverage
-
-  BOOST_CHECK         ( uut.trylock());
-  BOOST_CHECK         (!uut.trylock());
-  BOOST_CHECK_NO_THROW( uut.unlock());
-}
-
-BOOST_AUTO_TEST_CASE(timedlock)
-{
-  pthread_t th;
-  struct LFAT lfat;
-
-  BOOST_CHECK         ( lfat.uut.timedlock(100));
-  BOOST_CHECK_THROW   ( lfat.uut.timedlock(100),
-                        SystemResourceException);                   // EDEADLK (current thread owns mutex - logic error)
-  BOOST_CHECK_NO_THROW( lfat.uut.unlock());
-
-  BOOST_CHECK_EQUAL   (0, pthread_mutex_lock(&lfat.mx));            // synchronize with helper thread
-  BOOST_CHECK_EQUAL   (0, pthread_create(&th, NULL,
-                            lockFromAnotherThread, &lfat));         // create helper thread
-  BOOST_CHECK_EQUAL   (0, pthread_cond_wait(&lfat.cv, &lfat.mx));   // wait for helper thread to lock mutex
-
-  BOOST_CHECK         (!lfat.uut.timedlock(100));                   // false: another thread owns the lock
-
-  BOOST_CHECK_EQUAL   (0, pthread_cond_signal(&lfat.cv));           // tell helper thread we are done
-  BOOST_CHECK_EQUAL   (0, pthread_mutex_unlock(&lfat.mx));          // let helper thread clean up
-  BOOST_CHECK_EQUAL   (0, pthread_join(th, 0));                     // wait for testing thread to unlock and be done
-}
-
-BOOST_AUTO_TEST_CASE(underlying)
-{
-  Mutex uut;
-
-  BOOST_CHECK         ( uut.getUnderlyingImpl());
-}
-
-BOOST_AUTO_TEST_SUITE_END()
diff --git a/lib/cpp/test/concurrency/RWMutexStarveTest.cpp b/lib/cpp/test/concurrency/RWMutexStarveTest.cpp
deleted file mode 100644
index 985a230..0000000
--- a/lib/cpp/test/concurrency/RWMutexStarveTest.cpp
+++ /dev/null
@@ -1,157 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-// This is linked into the UnitTests test executable
-
-#include <boost/test/unit_test.hpp>
-
-#include "thrift/concurrency/Mutex.h"
-#include "thrift/concurrency/PosixThreadFactory.h"
-#include <memory>
-
-using std::shared_ptr;
-using boost::unit_test::test_suite;
-using boost::unit_test::framework::master_test_suite;
-
-using namespace apache::thrift::concurrency;
-
-class Locker : public Runnable {
-protected:
-  Locker(shared_ptr<ReadWriteMutex> rwlock, bool writer)
-    : rwlock_(rwlock), writer_(writer), started_(false), gotLock_(false), signaled_(false) {}
-
-public:
-  virtual void run() {
-    started_ = true;
-    if (writer_) {
-      rwlock_->acquireWrite();
-    } else {
-      rwlock_->acquireRead();
-    }
-    gotLock_ = true;
-    while (!signaled_) {
-      usleep(5000);
-    }
-    rwlock_->release();
-  }
-
-  bool started() const { return started_; }
-  bool gotLock() const { return gotLock_; }
-  void signal() { signaled_ = true; }
-
-protected:
-  shared_ptr<ReadWriteMutex> rwlock_;
-  bool writer_;
-  volatile bool started_;
-  volatile bool gotLock_;
-  volatile bool signaled_;
-};
-
-class Reader : public Locker {
-public:
-  Reader(shared_ptr<ReadWriteMutex> rwlock) : Locker(rwlock, false) {}
-};
-
-class Writer : public Locker {
-public:
-  Writer(shared_ptr<ReadWriteMutex> rwlock) : Locker(rwlock, true) {}
-};
-
-void test_starve(PosixThreadFactory::POLICY policy) {
-  // the man pages for pthread_wrlock_rdlock suggest that any OS guarantee about
-  // writer starvation may be influenced by the scheduling policy, so let's try
-  // all 3 policies to see if any of them work.
-  PosixThreadFactory factory(policy);
-  factory.setDetached(false);
-
-  shared_ptr<ReadWriteMutex> rwlock(new NoStarveReadWriteMutex());
-
-  shared_ptr<Reader> reader1(new Reader(rwlock));
-  shared_ptr<Reader> reader2(new Reader(rwlock));
-  shared_ptr<Writer> writer(new Writer(rwlock));
-
-  shared_ptr<Thread> treader1 = factory.newThread(reader1);
-  shared_ptr<Thread> treader2 = factory.newThread(reader2);
-  shared_ptr<Thread> twriter = factory.newThread(writer);
-
-  // launch a reader and make sure he has the lock
-  treader1->start();
-  while (!reader1->gotLock()) {
-    usleep(2000);
-  }
-
-  // launch a writer and make sure he's blocked on the lock
-  twriter->start();
-  while (!writer->started()) {
-    usleep(2000);
-  }
-  // tricky part... we can never be 100% sure that the writer is actually
-  // blocked on the lock, but we can pretty reasonably sure because we know
-  // he just executed the line immediately before getting the lock, and
-  // we'll wait a full second for him to get on it.
-  sleep(1);
-
-  // launch a second reader... if the RWMutex guarantees that writers won't
-  // starve, this reader should not be able to acquire the lock until the writer
-  // has acquired and released it.
-  treader2->start();
-  while (!reader2->started()) {
-    usleep(2000);
-  }
-  // again... can't be 100% sure the reader is waiting on (or has) the lock
-  // but we can be close.
-  sleep(1);
-
-  // tell reader 1 to let go of the lock
-  reader1->signal();
-
-  // wait for someone to get the lock
-  while (!reader2->gotLock() && !writer->gotLock()) {
-    usleep(2000);
-  }
-
-  // the test succeeded if the WRITER got the lock.
-  bool success = writer->gotLock();
-
-  // tell everyone we're done and wait for them to finish
-  reader2->signal();
-  writer->signal();
-  treader1->join();
-  treader2->join();
-  twriter->join();
-
-  // make sure it worked.
-  BOOST_CHECK_MESSAGE(success, "writer is starving");
-}
-
-BOOST_AUTO_TEST_SUITE(RWMutexStarveTest)
-
-BOOST_AUTO_TEST_CASE(test_starve_other) {
-  test_starve(PosixThreadFactory::OTHER);
-}
-
-BOOST_AUTO_TEST_CASE(test_starve_rr) {
-  test_starve(PosixThreadFactory::ROUND_ROBIN);
-}
-
-BOOST_AUTO_TEST_CASE(test_starve_fifo) {
-  test_starve(PosixThreadFactory::FIFO);
-}
-
-BOOST_AUTO_TEST_SUITE_END()
diff --git a/lib/cpp/test/concurrency/ThreadFactoryTests.h b/lib/cpp/test/concurrency/ThreadFactoryTests.h
index ba98502..8ab754c 100644
--- a/lib/cpp/test/concurrency/ThreadFactoryTests.h
+++ b/lib/cpp/test/concurrency/ThreadFactoryTests.h
@@ -19,7 +19,7 @@
 
 #include <thrift/thrift-config.h>
 #include <thrift/concurrency/Thread.h>
-#include <thrift/concurrency/PlatformThreadFactory.h>
+#include <thrift/concurrency/ThreadFactory.h>
 #include <thrift/concurrency/Monitor.h>
 #include <thrift/concurrency/Mutex.h>
 #include <thrift/concurrency/Util.h>
@@ -66,7 +66,7 @@
 
   bool reapNThreads(int loop = 1, int count = 10) {
 
-    PlatformThreadFactory threadFactory = PlatformThreadFactory();
+    ThreadFactory threadFactory = ThreadFactory();
     shared_ptr<Monitor> monitor(new Monitor);
 
     for (int lix = 0; lix < loop; lix++) {
@@ -159,7 +159,7 @@
     shared_ptr<SynchStartTask> task
         = shared_ptr<SynchStartTask>(new SynchStartTask(monitor, state));
 
-    PlatformThreadFactory threadFactory = PlatformThreadFactory();
+    ThreadFactory threadFactory = ThreadFactory();
 
     shared_ptr<Thread> thread = threadFactory.newThread(task);
 
@@ -265,7 +265,7 @@
     Monitor& _mon;
   };
 
-  void foo(PlatformThreadFactory* tf) { (void)tf; }
+  void foo(ThreadFactory* tf) { (void)tf; }
 
   bool floodNTest(size_t loop = 1, size_t count = 100000) {
 
@@ -274,7 +274,7 @@
 	
     for (size_t lix = 0; lix < loop; lix++) {
 
-      PlatformThreadFactory threadFactory = PlatformThreadFactory();
+      ThreadFactory threadFactory = ThreadFactory();
       threadFactory.setDetached(true);
 
       for (size_t tix = 0; tix < count; tix++) {
diff --git a/lib/cpp/test/concurrency/ThreadManagerTests.h b/lib/cpp/test/concurrency/ThreadManagerTests.h
index d6c092d..b3a319a 100644
--- a/lib/cpp/test/concurrency/ThreadManagerTests.h
+++ b/lib/cpp/test/concurrency/ThreadManagerTests.h
@@ -19,7 +19,7 @@
 
 #include <thrift/thrift-config.h>
 #include <thrift/concurrency/ThreadManager.h>
-#include <thrift/concurrency/PlatformThreadFactory.h>
+#include <thrift/concurrency/ThreadFactory.h>
 #include <thrift/concurrency/Monitor.h>
 #include <thrift/concurrency/Util.h>
 
@@ -108,12 +108,9 @@
 
     shared_ptr<ThreadManager> threadManager = ThreadManager::newSimpleThreadManager(workerCount);
 
-    shared_ptr<PlatformThreadFactory> threadFactory
-        = shared_ptr<PlatformThreadFactory>(new PlatformThreadFactory(false));
+    shared_ptr<ThreadFactory> threadFactory
+        = shared_ptr<ThreadFactory>(new ThreadFactory(false));
 
-#if !USE_STD_THREAD
-    threadFactory->setPriority(PosixThreadFactory::HIGHEST);
-#endif
     threadManager->threadFactory(threadFactory);
 
     threadManager->start();
@@ -257,12 +254,9 @@
       shared_ptr<ThreadManager> threadManager
           = ThreadManager::newSimpleThreadManager(workerCount, pendingTaskMaxCount);
 
-      shared_ptr<PlatformThreadFactory> threadFactory
-          = shared_ptr<PlatformThreadFactory>(new PlatformThreadFactory());
+      shared_ptr<ThreadFactory> threadFactory
+          = shared_ptr<ThreadFactory>(new ThreadFactory());
 
-#if !USE_STD_THREAD
-      threadFactory->setPriority(PosixThreadFactory::HIGHEST);
-#endif
       threadManager->threadFactory(threadFactory);
 
       threadManager->start();
@@ -401,54 +395,15 @@
       return false;
     }
 
-#if !USE_STD_THREAD
-    // test once with a detached thread factory and once with a joinable thread factory
-
-    shared_ptr<PosixThreadFactory> threadFactory
-        = shared_ptr<PosixThreadFactory>(new PosixThreadFactory(false));
-
-    std::cout << "\t\t\tapiTest with joinable thread factory" << std::endl;
-    if (!apiTestWithThreadFactory(threadFactory)) {
-      return false;
-    }
-
-    threadFactory.reset(new PosixThreadFactory(true));
-    std::cout << "\t\t\tapiTest with detached thread factory" << std::endl;
-    return apiTestWithThreadFactory(threadFactory);
-#else
-    return apiTestWithThreadFactory(shared_ptr<PlatformThreadFactory>(new PlatformThreadFactory()));
-#endif
+    return apiTestWithThreadFactory(shared_ptr<ThreadFactory>(new ThreadFactory()));
 
   }
 
-  bool apiTestWithThreadFactory(shared_ptr<PlatformThreadFactory> threadFactory)
+  bool apiTestWithThreadFactory(shared_ptr<ThreadFactory> threadFactory)
   {
     shared_ptr<ThreadManager> threadManager = ThreadManager::newSimpleThreadManager(1);
     threadManager->threadFactory(threadFactory);
 
-#if !USE_STD_THREAD
-    threadFactory->setPriority(PosixThreadFactory::HIGHEST);
-
-    // verify we cannot change the thread factory to one with the opposite detached setting
-    shared_ptr<PlatformThreadFactory> threadFactory2
-        = shared_ptr<PosixThreadFactory>(new PlatformThreadFactory(
-          PosixThreadFactory::ROUND_ROBIN,
-          PosixThreadFactory::NORMAL,
-          1,
-          !threadFactory->isDetached()));
-    try {
-      threadManager->threadFactory(threadFactory2);
-      // if the call succeeded we changed the thread factory to one that had the opposite setting for "isDetached()".
-      // this is bad, because the thread manager checks with the thread factory to see if it should join threads
-      // as they are leaving - so the detached status of new threads cannot change while there are existing threads.
-      std::cerr << "\t\t\tShould not be able to change thread factory detached disposition" << std::endl;
-      return false;
-    }
-    catch (InvalidArgumentException& ex) {
-      /* expected */
-    }
-#endif
-
     std::cout << "\t\t\t\tstarting.. " << std::endl;
 
     threadManager->start();
diff --git a/lib/cpp/test/concurrency/TimerManagerTests.h b/lib/cpp/test/concurrency/TimerManagerTests.h
index 1c52c47..c15b14b 100644
--- a/lib/cpp/test/concurrency/TimerManagerTests.h
+++ b/lib/cpp/test/concurrency/TimerManagerTests.h
@@ -18,7 +18,7 @@
  */
 
 #include <thrift/concurrency/TimerManager.h>
-#include <thrift/concurrency/PlatformThreadFactory.h>
+#include <thrift/concurrency/ThreadFactory.h>
 #include <thrift/concurrency/Monitor.h>
 #include <thrift/concurrency/Util.h>
 
@@ -80,7 +80,7 @@
 
     {
       TimerManager timerManager;
-      timerManager.threadFactory(shared_ptr<PlatformThreadFactory>(new PlatformThreadFactory()));
+      timerManager.threadFactory(shared_ptr<ThreadFactory>(new ThreadFactory()));
       timerManager.start();
       if (timerManager.state() != TimerManager::STARTED) {
         std::cerr << "timerManager is not in the STARTED state, but should be" << std::endl;
@@ -125,7 +125,7 @@
    */
   bool test01(int64_t timeout = 1000LL) {
     TimerManager timerManager;
-    timerManager.threadFactory(shared_ptr<PlatformThreadFactory>(new PlatformThreadFactory()));
+    timerManager.threadFactory(shared_ptr<ThreadFactory>(new ThreadFactory()));
     timerManager.start();
     assert(timerManager.state() == TimerManager::STARTED);
 
@@ -158,7 +158,7 @@
    */
   bool test02(int64_t timeout = 1000LL) {
     TimerManager timerManager;
-    timerManager.threadFactory(shared_ptr<PlatformThreadFactory>(new PlatformThreadFactory()));
+    timerManager.threadFactory(shared_ptr<ThreadFactory>(new ThreadFactory()));
     timerManager.start();
     assert(timerManager.state() == TimerManager::STARTED);
 
@@ -191,7 +191,7 @@
    */
   bool test03(int64_t timeout = 1000LL) {
     TimerManager timerManager;
-    timerManager.threadFactory(shared_ptr<PlatformThreadFactory>(new PlatformThreadFactory()));
+    timerManager.threadFactory(shared_ptr<ThreadFactory>(new ThreadFactory()));
     timerManager.start();
     assert(timerManager.state() == TimerManager::STARTED);
 
@@ -228,7 +228,7 @@
    */
   bool test04(int64_t timeout = 1000LL) {
     TimerManager timerManager;
-    timerManager.threadFactory(shared_ptr<PlatformThreadFactory>(new PlatformThreadFactory()));
+    timerManager.threadFactory(shared_ptr<ThreadFactory>(new ThreadFactory()));
     timerManager.start();
     assert(timerManager.state() == TimerManager::STARTED);