(How) does table inheritance interfere with locking in postgres?
Apparently, you want to see constraint exclusion at doing its work.  As in similar setups the parent table has no constraint (and, just to mention it, usually no rows), it will be always visited by queries on the parent table.  Using your example schema, see the output:

test=# EXPLAIN SELECT count(1) FROM p;
                            QUERY PLAN                             
───────────────────────────────────────────────────────────────────
 Aggregate  (cost=576.00..576.01 rows=1 width=0)
   -&gt;  Append  (cost=0.00..501.00 rows=30001 width=0)
         -&gt;  Seq Scan on p  (cost=0.00..0.00 rows=1 width=0)
         -&gt;  Seq Scan on a  (cost=0.00..164.00 rows=10000 width=0)
         -&gt;  Seq Scan on b  (cost=0.00..164.00 rows=10000 width=0)
         -&gt;  Seq Scan on c  (cost=0.00..173.00 rows=10000 width=0)

test=# EXPLAIN SELECT count(1) FROM p WHERE type_id = 1;
                            QUERY PLAN                             
───────────────────────────────────────────────────────────────────
 Aggregate  (cost=412.00..412.01 rows=1 width=0)
   -&gt;  Append  (cost=0.00..387.00 rows=10002 width=0)
         -&gt;  Seq Scan on p  (cost=0.00..0.00 rows=1 width=0)
               Filter: (type_id = 1)
         -&gt;  Seq Scan on a  (cost=0.00..189.00 rows=10000 width=0)
               Filter: (type_id = 1)
         -&gt;  Seq Scan on c  (cost=0.00..198.00 rows=1 width=0)
               Filter: (type_id = 1)


In the second case, table b is not visited, because the planner knows for sure that there cannot be any rows matching the condition.  At the same time, p is present in both cases.  The same applies to c, too: it has no easy way (the check) to exclude the table from the plan.  In this case, it has to visit all tables that have the possibility to contain the actual rows.

Let's add some check there, too:

ALTER TABLE c ADD CHECK (type_id = 3);

test=# EXPLAIN SELECT count(1) FROM p WHERE type_id = 1;
                            QUERY PLAN                             
───────────────────────────────────────────────────────────────────
 Aggregate  (cost=214.00..214.01 rows=1 width=0)
   -&gt;  Append  (cost=0.00..189.00 rows=10001 width=0)
         -&gt;  Seq Scan on p  (cost=0.00..0.00 rows=1 width=0)
               Filter: (type_id = 1)
         -&gt;  Seq Scan on a  (cost=0.00..189.00 rows=10000 width=0)
               Filter: (type_id = 1)


Much better now.

Now let's have a look on the locks that are taken.

BEGIN; -- to be able to see the locks

SELECT count(1) FROM p WHERE type_id = 1;

SELECT relname, locktype, mode
  FROM pg_locks
  JOIN pg_class c ON relation = c.oid 
  JOIN pg_namespace n ON c.relnamespace = n.oid
 WHERE nspname = 'dba' 
   AND relkind = 'r';

 relname │ locktype │      mode       
─────────┼──────────┼─────────────────
 c       │ relation │ AccessShareLock
 b       │ relation │ AccessShareLock
 a       │ relation │ AccessShareLock
 p       │ relation │ AccessShareLock


This is not so nice...  Apparently (and somewhat surprisingly), going to the parent table locks all children, too.

But:

ROLLBACK;
BEGIN; -- to be able to see the locks

SELECT count(1) FROM a WHERE type_id = 1; -- touching only "a"

-- the locks taken:
 a       │ relation │ AccessShareLock


This means that if you can constraint your query to touch only a subset of the tables, it will save you the locks on the other children.  Playing around a bit it shows that this applies to other statements (for example, an UPDATE), too, just the lock modes are different.