title: Python: Thread-safe way to call Networkx and functions on random graphs
body: <p>I have created this program, mostly to understand how Networkx and parallelization work:</p>
  
  <pre><code>import random
  import numpy as np
  import networxk as nx
  import multiprocessing
  from functools import wraps
  
  def unpack(func):
      @wraps(func)
      def wrapper(arg_tuple):
          return func(*arg_tuple)
      return wrapper
  
   @unpack
   def parallel_job(seed,shift):
       N = 1000
       k = 10
       random.seed(seed)
       np.random.seed(seed) 
       #Use Networkx to generate a random graph.           
       G = nx.erdos_renyi_graph(int(N),k/float(N), seed = seed) 
       #select 10 random nodes and print them
       for j in range(10):
           I = [10]
           S = [N - I[0]]
           X = np.array([0]*S[0] +[1]*I[0]).reshape((N,1))
           np.random.shuffle(X) 
           print X                 
  
  
  
  if __name__ == "__main__":
          threadnum = 10           
          simnum = 10
          seed = [j*2759 + 37*j**2 + 4757 for j in range(threadnum)]
          shift = [j*simnum for j in range(simnum)
  
          pool = multiprocessing.Pool(threadnum)
          arguments = zip(shift,seed)
          #spawn threadnum threads and give them parallel jobs
          pool.map(parallel_job, iterable=arguments) 
  </code></pre>
  
  <p>So this program defines a vector of seeds, spawns a certain number of threads, for each thread it assigns a seed. Then generates a random graph with that seed and then selects and prints 10 times a random selection of nodes. </p>
  
  <p>My questions are:</p>
  
  <p>1) if instead of generating exactly one graph per thread I would like to generate m different graphs, how should I modify it? after I generate each graph shall I change the seed with some method or there is a betetr way? Is it even necessary to call networkx with the optional argument seed = seed? I am reading on the documentation of NetworkX that it may use the global random generator to do the random graph and I am a bit worried</p>
  
  <p>2) If I put the part of the program that selects a random number of nodes in a separate function and I call it from the parallelized part of the code, will it use the "correct" seed to randomize the vector?</p>
  
  <p>3) Is there a better way to create random graphs in parallel and then picking random nodes on those graphs starting from a seed (that might be user given) ?</p>
  
  <p>I am using NetworkX version 2.2, numpy 1.15.4, python 2.7</p>