Synchronisation d'une variable entre deux threads

Version imprimable

Bonjour,

Je suis en train d'apprendre la programmation Android et Java, et j'ai une question concernant la synchronisation d'une variable entre deux threads.

Voici le code, pour mieux expliquer :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
   class MyRunnable implements Runnable {
        Boolean continueBoucle;
        @Override
        public void run() {
            int c = 0;
            continueBoucle = true;
 
            while (continueBoucle)
            {
                c++;
                Log.d("TINTIN", "Thread " + Thread.currentThread().getName() + " c=" + c);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
 
(...)
 
        MyRunnable myRunnable = new MyRunnable();
 
        boutonStart = findViewById(R.id.buttonStart);
        boutonStart.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                t = new Thread(myRunnable);
                t.start();
            }
        });
 
(...)
 
        boutonStop = findViewById(R.id.buttonStop);
        boutonStop.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                myRunnable.continueBoucle = false;
            }
        });

Est-ce que la variable continueBoucle doit être synchronisée, vu qu'elle est partagée entre deux threads ? Si oui, comment s'y prendre proprement ?

En outre, doit-elle être volatile ?

Je suis désolé pour ces question de noobs, je débute dans ce langage. :P

Merci pour vos explications ! :P

30/08/2021, 15h08
grunk

Une variable partagée entre 2 threads doit effectivement en général être synchronisée. Soit via le mot clé synchronized soit via l'acquisition d'un lock.

La notion de volatile est différente. Elle est là pour régler des problématique de visibilité de mémoire. Ca peut être utilise qu'en u nthread écrit et l'autre lit , mais il y'a, je trouve , beaucoup d'effet de bord pour l'utiliser sans très bonne raison.

Merci.

Du coup, est-ce que ce genre de chose est acceptable ?

Dans le thread 1:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
(...)
            while (true)
            {
(...)
                Boolean continueBoucle_;
                synchronized (continueBoucle)
                {
                    continueBoucle_ = continueBoucle;
                }
                if (continueBoucle_ == false)
                    break;
            }
(...)

Dans le thread principal :

Code:

1
2
3
4
5
6
 
(...)
                synchronized (myRunnable.continueBoucle) {
                    myRunnable.continueBoucle = false;
                }
(...)