diff -r 6c8e2c6e3a99 Lib/multiprocessing/synchronize.py
--- a/Lib/multiprocessing/synchronize.py	Wed Sep 09 22:46:40 2015 -0400
+++ b/Lib/multiprocessing/synchronize.py	Thu Sep 10 23:27:38 2015 -0500
@@ -134,7 +134,10 @@
             value = self._semlock._get_value()
         except Exception:
             value = 'unknown'
-        return '<%s(value=%s)>' % (self.__class__.__name__, value)
+        return '<%s.%s at %#x %s>' % (
+            self.__class__.__module__, self.__class__.__name__,
+            id(self), value
+        )
 
 #
 # Bounded semaphore
@@ -150,8 +153,10 @@
             value = self._semlock._get_value()
         except Exception:
             value = 'unknown'
-        return '<%s(value=%s, maxvalue=%s)>' % \
-               (self.__class__.__name__, value, self._semlock.maxvalue)
+        return '<%s.%s at %#x %s/%s>' % (
+            self.__class__.__module__, self.__class__.__name__,
+            id(self), value, self._semlock.maxvalue
+        )
 
 #
 # Non-recursive lock
@@ -336,6 +341,12 @@
         self._cond = ctx.Condition(ctx.Lock())
         self._flag = ctx.Semaphore(0)
 
+    def __repr__(self):
+        return '<%s.%s at %#x %s>' % (
+            self.__class__.__module__, self.__class__.__name__,
+            id(self), 'set' if self.is_set() else 'unset'
+        )
+
     def is_set(self):
         with self._cond:
             if self._flag.acquire(False):
@@ -380,6 +391,12 @@
         self._state = 0
         self._count = 0
 
+    def __repr__(self):
+        return '<%s.%s at %#x %s/%s%s>' % (
+            self.__class__.__module__, self.__class__.__name__, id(self),
+            self.n_waiting, self._parties, ', broken' if self.broken else ''
+        )
+
     def __setstate__(self, state):
         (self._parties, self._action, self._timeout,
          self._cond, self._wrapper) = state
diff -r 6c8e2c6e3a99 Lib/test/_test_multiprocessing.py
--- a/Lib/test/_test_multiprocessing.py	Wed Sep 09 22:46:40 2015 -0400
+++ b/Lib/test/_test_multiprocessing.py	Thu Sep 10 23:27:38 2015 -0500
@@ -824,6 +824,28 @@
         self.assertEqual(acquire(timeout=TIMEOUT3), False)
         self.assertTimingAlmostEqual(acquire.elapsed, TIMEOUT3)
 
+    def test_reprs(self):
+        if self.TYPE in ('manager', 'threads'):
+            self.skipTest('test not appropriate for {}'.format(self.TYPE))
+
+        sem = self.Semaphore(5)
+        try:
+            value = sem.get_value()
+            self.assertRegex(repr(sem), r"<[.\w]+\.Semaphore at .* 5>")
+        except Exception:
+            # If self._semaphore._get_value() is still unimplemented
+            self.assertRegex(repr(sem), r"<[.\w]+\.Semaphore at .* unknown>")
+
+        sem = self.BoundedSemaphore(7)
+        try:
+            value = sem.get_value()
+            self.assertRegex(repr(sem),
+                             r"<[.\w]+\.BoundedSemaphore at .* 7/7>")
+        except Exception:
+            # If self._semaphore._get_value() is still unimplemented
+            self.assertRegex(repr(sem),
+                             r"<[.\w]+\.BoundedSemaphore at .* unknown/7>")
+
 
 class _TestCondition(BaseTestCase):
 
@@ -1103,6 +1125,14 @@
         p.start()
         self.assertEqual(wait(), True)
 
+    def test_repr(self):
+        if self.TYPE == 'manager':
+            self.skipTest('test not appropriate for {}'.format(self.TYPE))
+        event = self.Event()
+        self.assertRegex(repr(event), r"<[.\w]+\.Event at .* unset>")
+        event.set()
+        self.assertRegex(repr(event), r"<[.\w]+\.Event at .* set>")
+
 #
 # Tests for Barrier - adapted from tests in test/lock_tests.py
 #
@@ -1437,6 +1467,29 @@
             for j in range(self.N):
                 self.assertEqual(conn.recv(), i)
 
+    @classmethod
+    def _test_repr_barrier_wait(cls, barrier):
+        _id = barrier.wait(cls.defaultTimeout)
+
+    def test_repr(self):
+        if self.TYPE == 'manager':
+            self.skipTest('test not appropriate for {}'.format(self.TYPE))
+        self.assertRegex(repr(self.barrier),
+                         r"<[.\w]+\.Barrier at .* 0/%d>" % (self.N,))
+        bunch = Bunch(self, self._test_repr_barrier_wait,
+                      (self.barrier,), self.N-1)
+        bunch.wait_for_started()
+        time.sleep(0.2)
+        self.assertRegex(repr(self.barrier),
+                         r"<[.\w]+\.Barrier at .* %d/%d>" % (self.N-1, self.N))
+        self.barrier.wait()
+        bunch.wait_for_finished()
+        self.assertRegex(repr(self.barrier),
+                         r"<[.\w]+\.Barrier at .* 0/%d>" % (self.N,))
+        self.barrier.abort()
+        self.assertRegex(repr(self.barrier),
+                         r"<[.\w]+\.Barrier at .* 0/%d, broken>" % (self.N,))
+
 #
 #
 #