java - 异步情况下的循环，怎么解决这个问题

Answer 1

Utiliser des synchronizedmots-clés

Answer 2

Ajouter le mot-clé volatile à la liste

Answer 3

Je viens de regarder aujourd'hui la programmation simultanée pratique sur la libération et l'accès sécurisés aux objets mutables :
Libération sécurisée :

1. Initialiser une référence d'objet dans une fonction d'initialisation statique

2. Enregistrer la référence de l'objet sur volatile ou AtomicReference

3. Enregistrer la référence de l'objet à un type final qui construit correctement l'objet

4. Enregistrez l'objet dans le cadre d'un verrou.

Accès sécurisé :

1. Discussion fermée

2. Partage en lecture seule

3. Partage thread-safe, la méthode d'accès interne de l'objet publié est thread-safe, et aucune synchronisation externe n'est requise

4. Protégez les objets, publiez des objets mutables en limitant l'accès externe et spécifiez l'interface d'accès aux objets mutables.

static List<String> arrayList = new ArrayList<>();Cela est conforme à la première règle de publication sécurisée
Ensuite, nous devons garantir un accès sécurisé Puisque la liste ne doit pas être accessible en toute sécurité dans les trois premières situations, nous ne pouvons compter que sur la restriction du monde extérieur lorsque. publier des objets, c'est-à-dire verrouiller.

Answer 4

Cela peut être réalisé selon la demande du sujet, mais la réalisation de cette demande est très étrange.

    private static void test1(final int i) {
    new Thread(new Runnable() {
        @Override
        public void run() {
            synchronized (arrayList) {
                while (arrayList.size() != i) {
                    try {
                        arrayList.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                arrayList.add(i, i + "position");
                arrayList.notifyAll();
            }
        }
    }).start();
}

En plus de cette méthode, cela peut également être réalisé par join et en passant countdownlatch Si vous voulez vraiment être comme le sujet, il vaut mieux ne pas utiliser le multi-threading

.

Answer 5

L'utilisation de la méthode InvokeAll du pool de threads peut garantir que l'ordre des résultats est cohérent avec l'ordre des paramètres transmis

Answer 6

public static void main(String[] args) {
        ExecutorService exec = Executors.newFixedThreadPool(10);
        
        List<Callable<Integer>> list = new ArrayList<>();
        
        for (int i = 0; i < 10; i++) {
            list.add(newTask(i));
        }
        
        try {
            for (Future<Integer> future : exec.invokeAll(list)) {
                try {
                    System.out.println(future.get());
                } catch (ExecutionException e) {
                    e.printStackTrace();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        exec.shutdown();
    }
    
    static Callable<Integer> newTask(final int t) {
        return new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println("newTask: " + t);
                try {
                    Thread.sleep((10 - t) * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return t;
            }
        }
    }