def__init__(self,kind,value,maxvalue,*,ctx):

ifctxisNone:

ctx=context._default_context.get_context()

self.is_fork_ctx=ctx.get_start_method()=='fork'

unlink_now=sys.platform=='win32'orself.is_fork_ctx

self._is_fork_ctx=ctx.get_start_method()=='fork'

unlink_now=sys.platform=='win32'orself._is_fork_ctx

foriinrange(100):

try:

sl=self._semlock=_multiprocessing.SemLock(

ifsys.platform=='win32':

h=context.get_spawning_popen().duplicate_for_child(sl.handle)

else:

ifself.is_fork_ctx:

ifself._is_fork_ctx:

raiseRuntimeError('A SemLock created in a fork context is being '

self._semlock=_multiprocessing.SemLock._rebuild(*state)

util.debug('recreated blocker with handle %r'%state[0])

self._make_methods()

self._is_fork_ctx=False

def_make_name():

p.start()

p.join()

def_put_one_in_queue(cls,queue):

queue.put(1)

def_put_two_and_nest_once(cls,queue):

queue.put(2)

process=multiprocessing.Process(target=cls._put_one_in_queue,args=(queue,))

process.start()

process.join()

deftest_nested_startmethod(self):

queue=multiprocessing.Queue()

process=multiprocessing.Process(target=self._put_two_and_nest_once,args=(queue,))

process.start()

process.join()

results= []

whilenotqueue.empty():

results.append(queue.get())

self.assertEqual(results, [2,1])

Fix:meth:`multiprocessing.synchronize.SemLock.__setstate__` to properly initialize:attr:`multiprocessing.synchronize.SemLock._is_fork_ctx`. This fixes a regression when passing a SemLock accross nested processes.

Rename:attr:`multiprocessing.synchronize.SemLock.is_fork_ctx` to:attr:`multiprocessing.synchronize.SemLock._is_fork_ctx` to avoid exposing it as public API.