Dijkstra short path Parallel

package DijkstraParallel;

import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.logging.Level;
import java.util.logging.Logger;

class Worker implements Runnable {
    int threadId;

    public Worker(int threadId) {
        this.threadId = threadId;
    }

    @Override
    public void run() {
        do {
            int vertex = (int) DijkstraParallel.getWork();
            if (vertex == -1) {
                break;
            } else {
                for (int i = 0; i < DijkstraParallel.n; i++) {
                    // if equal to infinity, it means no connection between these vertices
                    if (DijkstraParallel.weight[vertex][i] < DijkstraParallel.infinity) {
                        int newdist = DijkstraParallel.mindist[vertex] + DijkstraParallel.weight[vertex][i];

                        if (newdist < DijkstraParallel.mindist[i]) {
                            // atomic operation on change on global variable
                            try {
                                DijkstraParallel.L.lock();
                                DijkstraParallel.mindist[i] = newdist;
                            } finally {
                                DijkstraParallel.L.unlock();
                            }

                            // checking if the vertex is already in a pool better to use set
                            if (!DijkstraParallel.workpool.contains(i)) {
                                DijkstraParallel.putWork(i);
                            }
                        }
                    }
                }
            }
        } while (true);
    }
}

public class DijkstraParallel {
    public static final int n = 5;
    public static final int infinity = 32000;
    public static int workCount = 0;
    public static BlockingDeque workpool = new LinkedBlockingDeque();

    public static int getWork(){

        try {
            DijkstraParallel.L.lock();
            workCount = workCount - 1;
        } finally {
            DijkstraParallel.L.unlock();
        }

        if(workCount == -n){
            // terminate all workers sending them -1
            for(int i=0;i<n;i++){
                try {
                    workpool.put(-1);
                } catch (InterruptedException ex) {
                    Logger.getLogger(DijkstraParallel.class.getName()).log(Level.SEVERE, null, ex);
                }
            }

            return -1;

        }else{
            try {
                return (int) workpool.take();
            } catch (InterruptedException ex) {
                Logger.getLogger(DijkstraParallel.class.getName()).log(Level.SEVERE, null, ex);
            }
        }

        return -1;
    }

    public static void putWork(Integer vertexNo){

        try {
            workpool.put(vertexNo);
        } catch (InterruptedException ex) {
            Logger.getLogger(DijkstraParallel.class.getName()).log(Level.SEVERE, null, ex);
        }

        try {

            DijkstraParallel.L.lock();
            workCount = workCount + 1;
        } finally {
            DijkstraParallel.L.unlock();
        }
    }

    public static int weight[][] = {
        {infinity, 4, 8, infinity, infinity},
        {infinity, infinity, 3, 1, infinity},
        {infinity, infinity, infinity, infinity, 5},
        {infinity, infinity, 2, infinity, 10},
        {infinity, infinity, infinity, infinity, infinity}
    };

    public static int mindist[] = new int[n];
//    public static Lock L[] = new ReentrantLock[n];
    public static Lock L = new ReentrantLock();

    public static List<Thread> threads = new LinkedList<>();

    public static void main(String[] args) {
        initThreads();

        for(int i=0;i<n;i++){
            System.out.println("vertex: " + DijkstraParallel.mindist[i]);
        }
    }

    public static void initThreads(){
        // initializing the mindist with all infinity and first one 0;

        for(int i=0;i<mindist.length;i++){
            mindist[i] = infinity;
        }

        mindist[0] = 0;

        // creating total threads
        for(int i=0;i<n;i++){
            Worker runnable = new Worker(i);
            Thread t = new Thread(runnable);
            threads.add(t);
        }

        // put first source in the work pool to initialize the work pool
        try {
            workpool.put(0);
        } catch (InterruptedException ex) {
            Logger.getLogger(DijkstraParallel.class.getName()).log(Level.SEVERE, null, ex);
        }

        // start all threads at once
        for(int i=0;i<n;i++){
            Thread t = threads.get(i);
            t.start();
        }

        // join all threads here before program exits
        for(int i=0;i<n;i++){
            Thread t = threads.get(i);
            try {
                t.join();
            } catch (InterruptedException ex) {
                System.out.println("exception");
            }
        }
    }
}