matplotlib with multiprocessing *sometimes* changes figure format

I am using matplotlib to make many figures and save them. I have 5 or so functions that perform either simple or no computations with the data, plot the data, and then format the figure to fit a specific form (title, axes, paper size).

These 5 or so plotting functions get called one at a time from another function in between computations. (Some computations, plotting_function_1, some more computations, plotting_function_2, ...).

I start each plotting function in a new process via plotProcess1 = multiprocessing.Process(target=plot_data1, args=(data, save_directory); myProcess.start() in order to continue with the computation while the plotting functions are running.

When I check the figures after the program has finished, many of the figures have very strange formatting errors with the titles and paper size. The weird part is that the data is always plotted exactly as it should be (The scatter data may look like some is missing, but that is just part of the dataset). Take a look at the Good figures vs bad figures to see what I am talking about (Top left is expected output, others are the issue).

This only started when I started using multiprocessing to make the plots in the background. The weirdest part is that it does not always do it, and it seems to do it at random. Any thoughts as to why it might be doing this and how to fix it? I would really like to keep the computations running while I make the plots due to timing. With some datasets, a few hundred plots will be made with each plotting function and the entire program might take 10s of hours to complete.

Edit: My datasets are very large spatial datasets, so each one of my plotting functions creates and saves multiple plots (around 20, but could be less or more depending on the size of the dataset). I have figured out when the issue occurs now, but still not why. The strange behavior happens when two plotting functions are running at the same time.

A typical timeline where the strange behaviour happens is: (plotting_function_1 has been started --> some small computations happen --> plotting_function_2 is started --> plotting_function_1 finishes --> Plotting_function_2 finishes)

This still doesn't make sense to me, because each plotting function runs in a separate process, does not change any data, and saves to a unique filename.

Edit 2: Here is a snippet of code that will create strangely formatted figures.

# Plot the raw data
    if plot_TF is True:
        photon_data_copy = photon_data.copy()
        plot_segments_copy = plot_segments.copy()

        if isParallel is True:
            rawPlotProcess = multiprocessing.Process(target=plot_raw_data, args=(photon_data_copy, plot_segments_copy, run_name, plotdir))
            rawPlotProcess.start()
        else:
            plot_raw_data(photon_data_copy, plot_segments_copy, run_name, plotdir)

    # Calculate signal slab and noise slab
    start = time.time()
    signal_mask, noise_mask = assign_slabs_by_histogram_max_bin(photon_data, pixel_dimensions, slab_thickness)
    logger.info('Time elapsed assigning slabs: {}'.format(time.time() - start))

    photon_signal = photon_data[signal_mask, :]
    photon_noise = photon_data[noise_mask, :]

    # Plot the Signal and Noise slabs
    if plot_TF is True:
        photon_signal_copy = photon_signal.copy()
        photon_noise_copy = photon_noise.copy()

        if isParallel is True:
            slabPlotProcess = multiprocessing.Process(target=plot_slabs, args=(photon_signal_copy, photon_noise_copy, plot_segments_copy, run_name, plotdir))
            slabPlotProcess.start()
        else:
            plot_slabs(photon_signal_copy, photon_noise_copy, plot_segments_copy, run_name, plotdir)