Potrzebuje pomocy :/ jestescie moja jedyna nadzieja

Witam z językiem Java nie mam za wiele wspólnego, a potrzebuje wielowątkowej wersji następującego programu:

package nqsek;
import java.io.*;

public class Main {

private static String s;

private static int N;
private static boolean przek_p[] = new boolean[256]; // tablica z zajetą prawą przekątną szachownicy
private static boolean przek_l[] = new boolean[256]; // tablica z zajetą lewą przekątną szachownicy
private static boolean kol[] = null; // tablica z zajętymi kolumnami
private static boolean poz[][] = null; // tablica z ustawieniami królowych
private static long licznik = 0; // licznik znalezionych pozycji

private static void sedzia(int wiersz) { // wiersz - wiersz w którym sedzia sprawdza czy można ustawić królową

  for (int i=0; i<N; i++) {
  	if (!((kol[i]) || (przek_p[i-wiersz+128]) || (przek_l[wiersz+i+128]))) {
  		przek_p[i-wiersz+128] = true;     	// dodaje przekątne
          przek_l[wiersz+i+128] = true;
          kol[i] = true;               		// dodaje kolumnę
          poz[i][wiersz] = true;        		// stawia królową w tablicy
          if (wiersz<(N-1)) {
          	sedzia(wiersz+1);       		// analizuje następny wiersz (tylko jeśli nie jesteśmy już w ostatnim)
          }
          else {                       	// to jest ostatnia królowa - program zapisuje wynik
          	licznik++;
          }
          // po wyjsciu z rekurencji (sedzia(wiersz+1)) program usuwa królową i szukaj dla niej następnego pola
          przek_p[i-wiersz+128] = false;
          przek_l[wiersz+i+128] = false;
          kol[i] = false;
          poz[i][wiersz] = false;
  	}
  }

}

public static void main(String[] args) throws IOException {

    	    System.out.println("Podaj rozmiar szachownicy NxN = ");
  BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in), 1);
  s = stdin.readLine();
  N = Integer.parseInt(s);
  kol = new boolean[N];
  poz = new boolean[N][N];

	long start = System.currentTimeMillis();
  sedzia(0);             // stawia pierwszą królową
  long end = System.currentTimeMillis();
  System.out.println("Liczba mozliwych ustawien krolowych: " + licznik);
  System.out.println("Czas wykonania: " + ((end-start)/1000) + " sekund");
}

}

Jest to program realizujący problem n-królowych od jakiegoś czasu staram sie zrobić jego wersje wielowątkową ale niestety mi sie nie udaje a zaliczenie tuz tuz :/

Z góry dzięki za pomoc lub jakieś wskazówki.

Z checia komus zaplace za pomoc w rozwiazaniu tego problemu, pozostalo mi niewiele czasu i kazda godzina sie dla mnie liczy. Jako ze nie pisalem nigdy w Javie (oprocz tego wlasnie zadania) popelniam wiele bledow skladniowych. Napisalem cos co powinno dzialac ale niestety nie bardzo dziala :/

package nqmulti;
import java.io.*;

public class Main {
    private static String s;
	private static int N;
	private static boolean przek_p[][] = null;	// tablica z zajetą prawą przekątną szachownicy
	private static boolean przek_l[][] = null;	// tablica z zajetą lewą przekątną szachownicy
	private static boolean kol[][] = null; 					// tablica z zajętymi kolumnami
	private static boolean poz[][][] = null; 					// tablica z ustawieniami królowych
	private static long licznik = 0;                    	// licznik znalezionych pozycji
 //   private static long wynik = 0;

    private static class wstaw extends Thread {		// wiersz - wiersz w którym sedzia sprawdza czy mozna ustawic królową
        private static int j=-1;

		public void run (){
                j++;
                sedzia(1,j);
		}
	}

    private static void sedzia(int wiersz, int galaz){

        for(int i=0;i<N;i++){
            if(wiersz==0){
                przek_p[i-wiersz+128][galaz] = true;             // dodaje przekątne
                przek_l[wiersz+i+128][galaz] = true;
                kol[i][galaz]=true;
                poz[i][0][galaz] = true;
                wstaw watek= new wstaw();
                watek.start();
                galaz++;
            }
            else{
                    if (!((kol[i][galaz]) || (przek_p[i-wiersz+128][galaz]) || (przek_l[wiersz+i+128][galaz]))) {
                        przek_p[i-wiersz+128][galaz] = true;             // dodaje przekątne
                        przek_l[wiersz+i+128][galaz] = true;
                        kol[i][galaz] = true;                               // dodaje kolumnę
                        poz[i][wiersz][galaz] = true;                        // stawia królową w tablicy
                        if (wiersz<(N-1)) {
                            sedzia(wiersz+1,galaz);                       // analizuje następny wiersz (tylko jeśli nie jesteśmy już w ostatnim)
                        }
                        else {                               // to jest ostatnia królowa - program zapisuje wynik
                            licznik++;
                        }
                        // po wyjsciu z rekurencji (sedzia(wiersz+1)) program usuwa królową i szukaj dla niej następnego pola
                            przek_p[i-wiersz+128][galaz] = false;
                            przek_l[wiersz+i+128][galaz] = false;
                            kol[i][galaz] = false;
                            poz[i][wiersz][galaz] = false;
                    }
            }
        }
    }

    
    public static void main(String[] args) throws IOException {

        System.out.println("Podaj rozmiar szachownicy NxN = ");
		BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in), 1);
		s = stdin.readLine();
		N = Integer.parseInt(s);
		kol = new boolean[N][N];
		poz = new boolean[N][N][N];
        przek_p = new boolean[256][N];
        przek_l = new boolean[256][N];
      //  licznik = new long[N];
      /*  for(int i=0;i<N;i++){
            licznik[i]=0;
        }*/

    	long pocz = System.currentTimeMillis();

        sedzia(0,0);


		long end = System.currentTimeMillis();
		System.out.println("Liczba możliwych ustawień królowych: " + licznik);
		System.out.println("Czas wykonania: " + ((end-pocz)/1000) + " sekund");
   
    //    System.out.println("Liczba możliwych ustawień królowych: " + wynik);
    }

}

Caly czas probuje cos tu zmieniac takze nie wnikajcie w komentarze.

przeciez masz juz tutaj wątki. wrzuc każdą klase do osobnego pliku podpisz tak jak się nazywają wątki, może brakowac pakietów ale od tego jest java api < lektura >

przeciez masz juz tutaj wątki. wrzuc każdą klase do osobnego pliku podpisz tak jak się nazywają wątki, może brakowac pakietów ale od tego jest java api < lektura >

Jak bym wiedzial jak to zrobic nie prosilbym o pomoc :/ , z tego co zauwazylem wszystkie watki sa uruchamiane ale nie wyswietla mi sie poprawny wynik. Jak ustawie wyswietlanie licznika na koncu funkcji sedzia to po za konczeniu programu wyniki otrzymuje poprawny. Nie wiem o co chodzi.

Podkresle jeszcze raz sa to moje dwa jedyne programy napisane w javie.

W metodzie main powinienem uzyc "czegos" co poczeka skonczenie pracy przez wszystkie watki. Wydaje mi sie ze powinien to byc obiekt klasy CountDownLatch z biblioteki java.util.concurrent , ale nie mam pojecia jak to wykorzystac.

Jezeli ktos wie jak to zrobic bym byl wdzieczny za poprawienie kodu.

Dobrze Ci się wydaje.
Stwórz obiekt CountDownLatch tak, żeby wszystkie wątki łącznie z Main go widziały. W Main, po wystartowaniu wszystkich wątków wywołaj metodę CountDownLatch await().
Na konieć metody run() (czy kiedy już będziesz miał potrzebne wyniki) wywołaj metodę countDown() z CountDownLatch. Dodam, że CountDownLatch musi być zainicializowany liczbą wątków, które będziesz miał w programie.

Dzieki rnd za podpowiedz. Napisalem juz ten program tylko nie dokladnie liczy jak na koncu metody sedzia (poza petla for) dodam wyswietlanie licznika to wtedy liczy dobrze. Nie wiem w czym jest blad i jesli ktos wie prosze o odpowiedz.
A oto kod:

import java.io.*;
import java.util.concurrent.*;

public class Main {
    private static String s;
    private static int N;
    private static boolean przek_p[][] = null;	
    private static boolean przek_l[][] = null;	
    private static boolean kol[][] = null; 		
    private static boolean poz[][][] = null; 	
    private static long licznik = 0;            
    private static CountDownLatch bariera = null;
    private static long pocz;
    private static long kon;

    private static class watki extends Thread {

        private static int j=-1;

	public void run (){
            try{
                j++;
                sedzia(1,j);
            }
            finally{
                 bariera.countDown();
            }
            
	}
   }

    private static class wynik extends Thread {
        public void run () {
            try {
                bariera.await();
                kon = System.currentTimeMillis();
                System.out.println("Liczba możliwych " +
                        "ustawień królowych: " + licznik);
                System.out.println("Czas wykonania: " +
                        ((kon-pocz)/1000) + " sekund");
            } 
            catch (InterruptedException ex) {
            }

        }
    }

    private static void sedzia(int wiersz, int galaz){

            if(wiersz==0){
                for(int i=0;i<N;i++){
                    przek_p[i-wiersz+128][i] = true;             
                    przek_l[wiersz+i+128][i] = true;
                    kol[i][i]=true;
                    poz[i][wiersz][i] = true;
                    watki watek= new watki();
                    watek.start();
                }
            }
            else{
                for(int i=0;i<N;i++){

                    if (!((kol[i][galaz]) || (przek_p[i-wiersz+128][galaz])
                            || (przek_l[wiersz+i+128][galaz]))) {
                        przek_p[i-wiersz+128][galaz] = true;     
                        przek_l[wiersz+i+128][galaz] = true;
                        kol[i][galaz] = true;        
                        poz[i][wiersz][galaz] = true; 
                        if (wiersz<(N-1)) {
                            sedzia(wiersz+1,galaz);
                        }
                        else {
                            licznik++;
                        }
                        przek_p[i-wiersz+128][galaz] = false;
                        przek_l[wiersz+i+128][galaz] = false;
                        kol[i][galaz] = false;
                        poz[i][wiersz][galaz] = false;
                    }
                }
            }
    }

    
    public static void main(String[] args) throws IOException {

        System.out.println("Podaj rozmiar szachownicy NxN = ");
	BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in), 1);
	s = stdin.readLine();
	N = Integer.parseInt(s);
	kol = new boolean[N][N];
	poz = new boolean[N][N][N];
        przek_p = new boolean[256][N];
        przek_l = new boolean[256][N];

        bariera = new CountDownLatch(N);

    	pocz = System.currentTimeMillis();
        sedzia(0,0);
        wynik w = new wynik();
        w.start();

    }

}