use empty method

if queue1.empty():
   pass
else:
   # get items from the queue

Note: doc says "not reliable" (no kidding).

I suppose that's because it can return True (queue is empty) while a message is posted, so the operation is not as atomic as catching the exception. Well, followed by a get_nowait() call I suppose it doesn't matter unless some other thread can consume the queue as well, in which case a racing condition could occur and the queue could be empty when you try to read from it!

In the main program, this sequence

p.join()
obj = queue.get()

means that nothing will be pulled off of queue until p exits.

Meanwhile, the subprocess is trying to clean itself up after the function has finished. The line

q.put('X' * 1000000)

puts a string containing a million letters into the queue. The subprocess can't exit until that string has been sent.

So there's the fundamental deadlock: the main process won't read from the queue until the subprocess has exited, and the subprocess won't exit until it's written all of its items to the queue.

The other question you ask is, why does q.put('X' * 100) work?

Inside the underlying machinery of this there is some buffering. You can queue.put() and it will go into an internal buffer, but the main program will continue. The queue machinery can write some data into a pipe without it being immediately read. On the reader side, the queue machinery can read some data without it being consumed.

In all of these cases, though, it's "some" data: more than zero, but not infinite. There's some overhead that's non-zero but we can ignore for now. A 100-character string will require 100+ bytes, but probably less than 256. A million-character string will require about a megabyte.

The documentation mentions a pipe. If this goes through a Unix pipe, and the pipe buffer is, say, 32 kB, then up to 32,768 bytes can be written into the pipe without being immediately read. The short string easily fits, the low-level write(2) call returns, and the message has been "sent". If it's 1,024 kB of data, though, it doesn't all fit into the buffer, and the subprocess needs to wait for all of it to be sent. That "wait" is what leads to the deadlock.

The important TL;DR here should be that you shouldn't wait for things to be sent from the subprocess after you wait for it to complete. Do things like queue reads before you subprocess.join().

The difference is that one blocks and the other does not. From the docs:

Queue.get(block=True, timeout=None)

Remove and return an item from the queue. If optional args block is true and timeout is None (the default), block if necessary until an item is available. If timeout is a positive number, it blocks at most timeout seconds and raises the Empty exception if no item was available within that time. Otherwise (block is false), return an item if one is immediately available, else raise the Empty exception (timeout is ignored in that case).

Queue.get if the block parameter is True will block until either a element is pushed to the queue or the timeout if given is exceeded.

Queue.get_nowait()

Equivalent to get(False).

Queue.get_no_wait() will never block, but will return Queue.Empty if the queue is empty.

The same is true for the stack implementations.