Zmiana programu jednowątkowego w program współbieżny.

Witam ponownie,

Mój poprzedni temat został przeniesiony do kosza z powodu szczątkowego opisu problemu. Postaram się jeszcze raz dokładniej opisać o co chodzi.

Poniżej znajduje się mój program, działa on z wykorzystaniem jednego, głównego wątku (thread). Natomiast Java wspiera współbieżność (Java Concurrency), obsługę wielu wątków. Moje pytanie polega właśnie na tym czy poniższy program można przerobić w taki sposób, aby obsługiwał on kilka wątków, a nie tylko jeden. Czyli zmienić go tak, aby część zadań/algorytmu przekazać innym wątkom. Czy można to zrobić i w jaki sposób? Z góry dziękuję za pomoc.

W załączniku przesyłam cały projekt.

package projekt_zal_pacman;
 
import java.awt.EventQueue;
import javax.swing.JFrame;
 
public class Pacman extends JFrame {
 
    public Pacman() {
 
        initUI();
    }
 
    private void initUI() {
 
        add(new Board());
        setTitle("Pacman");
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        setSize(380, 420);
        setLocationRelativeTo(null);
        setVisible(true);        
    }
 
    public static void main(String[] args) {
 
        EventQueue.invokeLater(new Runnable() {
 
            @Override
            public void run() {
                Pacman ex = new Pacman();
                ex.setVisible(true);
            }
        });
    }
}  

 package projekt_zal_pacman;
 
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Event;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
 
import javax.swing.ImageIcon;
import javax.swing.JPanel;
import javax.swing.Timer;
 
public class Board extends JPanel implements ActionListener {
 
    private Dimension d;
    private final Font smallfont = new Font("Arial", Font.BOLD, 14);
 
    private Image ii;
    private final Color dotcolor = new Color(0, 0, 255);
    private Color mazecolor;
 
    private boolean ingame = false;
    private boolean dying = false;
 
    private final int blocksize = 24;
    private final int nrofblocks = 15;
    private final int scrsize = nrofblocks * blocksize;
    private final int pacanimdelay = 2;
    private final int pacmananimcount = 4;
    private final int maxghosts = 12;
    private final int pacmanspeed = 6;
 
    private int pacanimcount = pacanimdelay;
    private int pacanimdir = 1;
    private int pacmananimpos = 0;
    private int nrofghosts = 6;
    private int pacsleft, score;
    private int[] dx, dy;
    private int[] ghostx, ghosty, ghostdx, ghostdy, ghostspeed;
 
    private Image ghost;
    private Image pacman1, pacman2up, pacman2left, pacman2right, pacman2down;
    private Image pacman3up, pacman3down, pacman3left, pacman3right;
    private Image pacman4up, pacman4down, pacman4left, pacman4right;
 
    private int pacmanx, pacmany, pacmandx, pacmandy;
    private int reqdx, reqdy, viewdx, viewdy;
 
    private final short leveldata[] = {
        19, 26, 26, 26, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 22,
        21, 0, 0, 0, 17, 16, 16, 16, 16, 16, 16, 16, 16, 16, 20,
        21, 0, 0, 0, 17, 16, 16, 16, 16, 16, 16, 16, 16, 16, 20,
        21, 0, 0, 0, 17, 16, 16, 24, 16, 16, 16, 16, 16, 16, 20,
        17, 18, 18, 18, 16, 16, 20, 0, 17, 16, 16, 16, 16, 16, 20,
        17, 16, 16, 16, 16, 16, 20, 0, 17, 16, 16, 16, 16, 24, 20,
        25, 16, 16, 16, 24, 24, 28, 0, 25, 24, 24, 16, 20, 0, 21,
        1, 17, 16, 20, 0, 0, 0, 0, 0, 0, 0, 17, 20, 0, 21,
        1, 17, 16, 16, 18, 18, 22, 0, 19, 18, 18, 16, 20, 0, 21,
        1, 17, 16, 16, 16, 16, 20, 0, 17, 16, 16, 16, 20, 0, 21,
        1, 17, 16, 16, 16, 16, 20, 0, 17, 16, 16, 16, 20, 0, 21,
        1, 17, 16, 16, 16, 16, 16, 18, 16, 16, 16, 16, 20, 0, 21,
        1, 17, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 20, 0, 21,
        1, 25, 24, 24, 24, 24, 24, 24, 24, 24, 16, 16, 16, 18, 20,
        9, 8, 8, 8, 8, 8, 8, 8, 8, 8, 25, 24, 24, 24, 28
    };
 
    private final int validspeeds[] = {1, 2, 3, 4, 6, 8};
    private final int maxspeed = 6;
 
    private int currentspeed = 3;
    private short[] screendata;
    private Timer timer;
 
    public Board() {
 
        loadImages();
        initVariables();
 
        addKeyListener(new TAdapter());
 
        setFocusable(true);
 
        setBackground(Color.black);
        setDoubleBuffered(true);
    }
 
    private void initVariables() {
 
        screendata = new short[nrofblocks * nrofblocks];
        mazecolor = new Color(138, 43, 226);
        d = new Dimension(400, 400);
        ghostx = new int[maxghosts];
        ghostdx = new int[maxghosts];
        ghosty = new int[maxghosts];
        ghostdy = new int[maxghosts];
        ghostspeed = new int[maxghosts];
        dx = new int[4];
        dy = new int[4];
 
        timer = new Timer(40, this);
        timer.start();
    }
 
    @Override
    public void addNotify() {
        super.addNotify();
 
        initGame();
    }
 
    private void doAnim() {
 
        pacanimcount--;
 
        if (pacanimcount <= 0) {
            pacanimcount = pacanimdelay;
            pacmananimpos = pacmananimpos + pacanimdir;
 
            if (pacmananimpos == (pacmananimcount - 1) || pacmananimpos == 0) {
                pacanimdir = -pacanimdir;
            }
        }
    }
 
    private void playGame(Graphics2D g2d) {
 
        if (dying) {
 
            death();
 
        } else {
 
            movePacman();
            drawPacman(g2d);
            moveGhosts(g2d);
            checkMaze();
        }
    }
 
    private void showIntroScreen(Graphics2D g2d) {
 
        g2d.setColor(new Color(0, 0, 255));
        g2d.fillRect(50, scrsize / 2 - 30, scrsize - 100, 50);
        g2d.setColor(Color.white);
        g2d.drawRect(50, scrsize / 2 - 30, scrsize - 100, 50);
 
        String s = "Aby rozpocząć naciśnij S";
        Font small = new Font("Arial", Font.BOLD, 16);
        FontMetrics metr = this.getFontMetrics(small);
 
        g2d.setColor(Color.white);
        g2d.setFont(small);
        g2d.drawString(s, (scrsize - metr.stringWidth(s)) / 2, scrsize / 2);
    }
 
    private void drawScore(Graphics2D g) {
 
        int i;
        String s;
 
        g.setFont(smallfont);
        g.setColor(new Color(0, 0, 0));
        s = "Wynik: " + score;
        g.drawString(s, scrsize / 2 + 96, scrsize + 16);
 
        for (i = 0; i < pacsleft; i++) {
            g.drawImage(pacman3right, i * 28 + 8, scrsize + 1, this);
        }
    }
 
    private void checkMaze() {
 
        short i = 0;
        boolean finished = true;
 
        while (i < nrofblocks * nrofblocks && finished) {
 
            if ((screendata[i] & 48) != 0) {
                finished = false;
            }
 
            i++;
        }
 
        if (finished) {
 
            score += 50;
 
            if (nrofghosts < maxghosts) {
                nrofghosts++;
            }
 
            if (currentspeed < maxspeed) {
                currentspeed++;
            }
 
            initLevel();
        }
    }
 
    private void death() {
 
        pacsleft--;
 
        if (pacsleft == 0) {
            ingame = false;
        }
 
        continueLevel();
    }
 
    private void moveGhosts(Graphics2D g2d) {
 
        short i;
        int pos;
        int count;
 
        for (i = 0; i < nrofghosts; i++) {
            if (ghostx[i] % blocksize == 0 && ghosty[i] % blocksize == 0) {
                pos = ghostx[i] / blocksize + nrofblocks * (int) (ghosty[i] / blocksize);
 
                count = 0;
 
                if ((screendata[pos] & 1) == 0 && ghostdx[i] != 1) {
                    dx[count] = -1;
                    dy[count] = 0;
                    count++;
                }
 
                if ((screendata[pos] & 2) == 0 && ghostdy[i] != 1) {
                    dx[count] = 0;
                    dy[count] = -1;
                    count++;
                }
 
                if ((screendata[pos] & 4) == 0 && ghostdx[i] != -1) {
                    dx[count] = 1;
                    dy[count] = 0;
                    count++;
                }
 
                if ((screendata[pos] & 8) == 0 && ghostdy[i] != -1) {
                    dx[count] = 0;
                    dy[count] = 1;
                    count++;
                }
 
                if (count == 0) {
 
                    if ((screendata[pos] & 15) == 15) {
                        ghostdx[i] = 0;
                        ghostdy[i] = 0;
                    } else {
                        ghostdx[i] = -ghostdx[i];
                        ghostdy[i] = -ghostdy[i];
                    }
 
                } else {
 
                    count = (int) (Math.random() * count);
 
                    if (count > 3) {
                        count = 3;
                    }
 
                    ghostdx[i] = dx[count];
                    ghostdy[i] = dy[count];
                }
 
            }
 
            ghostx[i] = ghostx[i] + (ghostdx[i] * ghostspeed[i]);
            ghosty[i] = ghosty[i] + (ghostdy[i] * ghostspeed[i]);
            drawGhost(g2d, ghostx[i] + 1, ghosty[i] + 1);
 
            if (pacmanx > (ghostx[i] - 12) && pacmanx < (ghostx[i] + 12)
                    && pacmany > (ghosty[i] - 12) && pacmany < (ghosty[i] + 12)
                    && ingame) {
 
                dying = true;
            }
        }
    }
 
    private void drawGhost(Graphics2D g2d, int x, int y) {
 
        g2d.drawImage(ghost, x, y, this);
    }
 
    private void movePacman() {
 
        int pos;
        short ch;
 
        if (reqdx == -pacmandx && reqdy == -pacmandy) {
            pacmandx = reqdx;
            pacmandy = reqdy;
            viewdx = pacmandx;
            viewdy = pacmandy;
        }
 
        if (pacmanx % blocksize == 0 && pacmany % blocksize == 0) {
            pos = pacmanx / blocksize + nrofblocks * (int) (pacmany / blocksize);
            ch = screendata[pos];
 
            if ((ch & 16) != 0) {
                screendata[pos] = (short) (ch & 15);
                score++;
            }
 
            if (reqdx != 0 || reqdy != 0) {
                if (!((reqdx == -1 && reqdy == 0 && (ch & 1) != 0)
                        || (reqdx == 1 && reqdy == 0 && (ch & 4) != 0)
                        || (reqdx == 0 && reqdy == -1 && (ch & 2) != 0)
                        || (reqdx == 0 && reqdy == 1 && (ch & 8) != 0))) {
                    pacmandx = reqdx;
                    pacmandy = reqdy;
                    viewdx = pacmandx;
                    viewdy = pacmandy;
                }
            }
 
            // Check for standstill
            if ((pacmandx == -1 && pacmandy == 0 && (ch & 1) != 0)
                    || (pacmandx == 1 && pacmandy == 0 && (ch & 4) != 0)
                    || (pacmandx == 0 && pacmandy == -1 && (ch & 2) != 0)
                    || (pacmandx == 0 && pacmandy == 1 && (ch & 8) != 0)) {
                pacmandx = 0;
                pacmandy = 0;
            }
        }
        pacmanx = pacmanx + pacmanspeed * pacmandx;
        pacmany = pacmany + pacmanspeed * pacmandy;
    }
 
    private void drawPacman(Graphics2D g2d) {
 
        if (viewdx == -1) {
            drawPacnanLeft(g2d);
        } else if (viewdx == 1) {
            drawPacmanRight(g2d);
        } else if (viewdy == -1) {
            drawPacmanUp(g2d);
        } else {
            drawPacmanDown(g2d);
        }
    }
 
    private void drawPacmanUp(Graphics2D g2d) {
 
        switch (pacmananimpos) {
            case 1:
                g2d.drawImage(pacman2up, pacmanx + 1, pacmany + 1, this);
                break;
            case 2:
                g2d.drawImage(pacman3up, pacmanx + 1, pacmany + 1, this);
                break;
            case 3:
                g2d.drawImage(pacman4up, pacmanx + 1, pacmany + 1, this);
                break;
            default:
                g2d.drawImage(pacman4up, pacmanx + 1, pacmany + 1, this);
                break;
        }
    }
 
    private void drawPacmanDown(Graphics2D g2d) {
 
        switch (pacmananimpos) {
            case 1:
                g2d.drawImage(pacman2down, pacmanx + 1, pacmany + 1, this);
                break;
            case 2:
                g2d.drawImage(pacman3down, pacmanx + 1, pacmany + 1, this);
                break;
            case 3:
                g2d.drawImage(pacman4down, pacmanx + 1, pacmany + 1, this);
                break;
            default:
                g2d.drawImage(pacman4down, pacmanx + 1, pacmany + 1, this);
                break;
        }
    }
 
    private void drawPacnanLeft(Graphics2D g2d) {
 
        switch (pacmananimpos) {
            case 1:
                g2d.drawImage(pacman2left, pacmanx + 1, pacmany + 1, this);
                break;
            case 2:
                g2d.drawImage(pacman3left, pacmanx + 1, pacmany + 1, this);
                break;
            case 3:
                g2d.drawImage(pacman4left, pacmanx + 1, pacmany + 1, this);
                break;
            default:
                g2d.drawImage(pacman4left, pacmanx + 1, pacmany + 1, this);
                break;
        }
    }
 
    private void drawPacmanRight(Graphics2D g2d) {
 
        switch (pacmananimpos) {
            case 1:
                g2d.drawImage(pacman2right, pacmanx + 1, pacmany + 1, this);
                break;
            case 2:
                g2d.drawImage(pacman3right, pacmanx + 1, pacmany + 1, this);
                break;
            case 3:
                g2d.drawImage(pacman4right, pacmanx + 1, pacmany + 1, this);
                break;
            default:
                g2d.drawImage(pacman4right, pacmanx + 1, pacmany + 1, this);
                break;
        }
    }
 
    private void drawMaze(Graphics2D g2d) {
 
        short i = 0;
        int x, y;
 
        for (y = 0; y < scrsize; y += blocksize) {
            for (x = 0; x < scrsize; x += blocksize) {
 
                g2d.setColor(mazecolor);
                g2d.setStroke(new BasicStroke(2));
 
                if ((screendata[i] & 1) != 0) { //prawe, pionowe linie
                    g2d.drawLine(x, y, x, y + blocksize - 1);
                }
 
                if ((screendata[i] & 2) != 0) { //dolne, poziome linie
                    g2d.drawLine(x, y, x + blocksize - 1, y);
                }
 
                if ((screendata[i] & 4) != 0) { //lewe, pionowe linie
                    g2d.drawLine(x + blocksize - 1, y, x + blocksize - 1,
                            y + blocksize - 1);
                }
 
                if ((screendata[i] & 8) != 0) { //górne, poziome linie
                    g2d.drawLine(x, y + blocksize - 1, x + blocksize - 1,
                            y + blocksize - 1);
                }
 
                if ((screendata[i] & 16) != 0) {
                    g2d.setColor(dotcolor);
                    g2d.fillRect(x + 11, y + 11, 3, 3);
                }
 
                i++;
            }
        }
    }
 
    private void initGame() {
 
        pacsleft = 3;
        score = 0;
        initLevel();
        nrofghosts = 6;
        currentspeed = 3;
    }
 
    private void initLevel() {
 
        int i;
        for (i = 0; i < nrofblocks * nrofblocks; i++) {
            screendata[i] = leveldata[i];
        }
 
        continueLevel();
    }
 
    private void continueLevel() {
 
        short i;
        int dx = 1;
        int random;
 
        for (i = 0; i < nrofghosts; i++) {
 
            ghosty[i] = 4 * blocksize;
            ghostx[i] = 4 * blocksize;
            ghostdy[i] = 0;
            ghostdx[i] = dx;
            dx = -dx;
            random = (int) (Math.random() * (currentspeed + 1));
 
            if (random > currentspeed) {
                random = currentspeed;
            }
 
            ghostspeed[i] = validspeeds[random];
        }
 
        pacmanx = 7 * blocksize;
        pacmany = 11 * blocksize;
        pacmandx = 0;
        pacmandy = 0;
        reqdx = 0;
        reqdy = 0;
        viewdx = -1;
        viewdy = 0;
        dying = false;
    }
 
    private void loadImages() {
 
        ghost = new ImageIcon("images/ghost.png").getImage();
        pacman1 = new ImageIcon("images/pacman.png").getImage();
        pacman2up = new ImageIcon("images/up1.png").getImage();
        pacman3up = new ImageIcon("images/up2.png").getImage();
        pacman4up = new ImageIcon("images/up3.png").getImage();
        pacman2down = new ImageIcon("images/down1.png").getImage();
        pacman3down = new ImageIcon("images/down2.png").getImage();
        pacman4down = new ImageIcon("images/down3.png").getImage();
        pacman2left = new ImageIcon("images/left1.png").getImage();
        pacman3left = new ImageIcon("images/left2.png").getImage();
        pacman4left = new ImageIcon("images/left3.png").getImage();
        pacman2right = new ImageIcon("images/right1.png").getImage();
        pacman3right = new ImageIcon("images/right2.png").getImage();
        pacman4right = new ImageIcon("images/right3.png").getImage();
 
    }
 
    @Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);
 
        doDrawing(g);
    }
 
    private void doDrawing(Graphics g) {
 
        Graphics2D g2d = (Graphics2D) g;
 
        g2d.setColor(Color.WHITE);
        g2d.fillRect(0, 0, d.width, d.height);
 
        drawMaze(g2d);
        drawScore(g2d);
        doAnim();
 
        if (ingame) {
            playGame(g2d);
        } else {
            showIntroScreen(g2d);
        }
 
        g2d.drawImage(ii, 5, 5, this);
        Toolkit.getDefaultToolkit().sync();
        g2d.dispose();
    }
 
    class TAdapter extends KeyAdapter {
 
        @Override
        public void keyPressed(KeyEvent e) {
 
            int key = e.getKeyCode();
 
            if (ingame) {
                if (key == KeyEvent.VK_LEFT) {
                    reqdx = -1;
                    reqdy = 0;
                } else if (key == KeyEvent.VK_RIGHT) {
                    reqdx = 1;
                    reqdy = 0;
                } else if (key == KeyEvent.VK_UP) {
                    reqdx = 0;
                    reqdy = -1;
                } else if (key == KeyEvent.VK_DOWN) {
                    reqdx = 0;
                    reqdy = 1;
                } else if (key == KeyEvent.VK_ESCAPE && timer.isRunning()) {
                    ingame = false;
                } else if (key == KeyEvent.VK_PAUSE) {
                    if (timer.isRunning()) {
                        timer.stop();
                    } else {
                        timer.start();
                    }
                }
            } else {
                if (key == 's' || key == 'S') {
                    ingame = true;
                    initGame();
                }
            }
        }
 
        @Override
        public void keyReleased(KeyEvent e) {
 
            int key = e.getKeyCode();
 
            if (key == Event.LEFT || key == Event.RIGHT
                    || key == Event.UP || key == Event.DOWN) {
                reqdx = 0;
                reqdy = 0;
            }
        }
    }
 
    @Override
    public void actionPerformed(ActionEvent e) {
 
        repaint();
    }
}

Nie napisałeś najważniejszego: A co Ty o tym myślisz? Można czy nie można? W którym miejscu myślisz, że można by coś zrównoleglić?

Krótka odpowiedź: nie da się. Jedyne co,można, i należałoby!, zrobić z tym kodem to "kill it with fire".
Masz tu jedną klasę a powinieneś przynajmniej kilkanaście jeśli nie więcej. Kod to jedno wielkie spaghetti. Poza tym nadal nie opisałeś CO właściwie ma się tu wykonywać współbieżnie.

Myślę, że prawie każdy program można zrównoleglić, będzie to oczywiście bardziej lub mniej sensowne. Tym samym myślę, że ten też może obsługiwać więcej wątków, ale niestety nie wiem jak to zrobić.

W tym programie, szczerze mówiąc, chyba nie jest to konieczne, ale skoro trzeba to trzeba. Myślę, że można zrównoleglić np. w klasie Board, metodę moveGhosts oraz drawPacman (ruch Pacmana w każdym z kierunków), wtedy program oprócz głównego wątku obsługiwałby jeszcze dwa dodatkowe. Mogę oczywiście nie mieć racji, dla tego proszę Was o pomoc.

Czyli jednak się mylę. A jeżeli mogę wiedzieć to skąd wiadomo, że tego programu nie można wykonywać współbieżnie?

Myślę, że prawie każdy program można zrównoleglić, będzie to oczywiście bardziej lub mniej sensowne.

Ogólnie: nie zrobisz programu współbieżnego w przypadku, gdy każdy krok programu wymaga wyniku poprzedniego kroku.

Rozumiem, a mój program niestety tak działa. A czy ktoś z Was dysponuje takim programem współbieżnym, nieco bardziej zaawansowanym? W Internecie znalazłem tylko małe, przykładowe programiki typu - Witaj wątek nr 2, Witaj wątek nr 1 itd.

Spróbuj napisać własnego MapReduce w Javie.

Dobrze, dziękuję, tak zrobię i później umieszczę tutaj kod. Rozumiem, że MapReduce wykorzystuje współbieżność?

Nie wiedziałem, ale oczywiście sprawdziłem i już wiem. Pytam tylko dlatego, że w kodzie MapReduce nie ma ani klasy Thread, ani interfejsu Runnable, czyli tego czego będę musiał użyć, aby zrealizować program współbieżny. Oczywiście MapReduce sam w sobie służy do przetwarzania równoległego, ale w kodzie "tego nie widać". (Brak Thread i Runnable)

Twoja klasa Board to podręcznikowy przykład antywzorca "god object" ;). Gdybyś miał sporo zasobów do wczytania to mógłbyś to ładowanie zrównoleglić: 1 wątek by wczytywał zasoby (obrazki, dźwięk, mapy etc.), a np. główny wątek by wyświetlał animację ładowania.

Jejku, jej! Jakby ten był napisany z głową to każdy sprite w grze mógłby poruszać się w podobnym wątku, rysowanie też mogłoby być w osobnym wątku itd Ale to co napisałeś nadaje się tylko do skasowania.

Szalom, a jest możliwość przerobienia tego co wypociłem, żeby dołożyć wątki czy dosłownie tylko skasować to i koniec?

Przykro mi.