并行冒泡排序被阻塞的问题可能是由于不正确的线程同步导致的。下面是一种解决方法，使用Java的并发工具类来实现线程同步，并避免阻塞。

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class ParallelBubbleSort {
    private int[] array;
    private int numThreads;
    private CyclicBarrier barrier;

    public ParallelBubbleSort(int[] array, int numThreads) {
        this.array = array;
        this.numThreads = numThreads;
        this.barrier = new CyclicBarrier(numThreads);
    }

    public void sort() {
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - 1 - i; j++) {
                int threadIndex = j % numThreads;
                Thread thread = new Thread(new BubbleSortRunnable(j, threadIndex));
                thread.start();
            }
            // 等待所有线程完成一轮冒泡排序
            try {
                barrier.await();
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }

    private class BubbleSortRunnable implements Runnable {
        private int index;
        private int threadIndex;

        public BubbleSortRunnable(int index, int threadIndex) {
            this.index = index;
            this.threadIndex = threadIndex;
        }

        @Override
        public void run() {
            if (array[index] > array[index + 1]) {
                int temp = array[index];
                array[index] = array[index + 1];
                array[index + 1] = temp;
            }
            // 等待其他线程完成排序
            try {
                barrier.await();
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        int[] array = {5, 2, 9, 1, 3};
        int numThreads = 3;
        ParallelBubbleSort sorter = new ParallelBubbleSort(array, numThreads);
        sorter.sort();
        for (int num : array) {
            System.out.print(num + " ");
        }
    }
}

在上述代码中，使用CyclicBarrier类来实现线程同步。每个线程在进行冒泡排序之后，调用barrier.await()方法等待其他线程完成排序。当所有线程都完成排序后，继续下一轮的排序。这样可以确保每个线程都能够按照正确的顺序执行，避免冒泡排序被阻塞。