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

Answer 1

Gunakan synchronizedkata kunci

Answer 2

Tambahkan kata kunci yang tidak menentu pada senarai

Answer 3

Saya baru sahaja menonton pengaturcaraan serentak praktikal hari ini tentang pelepasan selamat dan akses objek boleh ubah:
Keluaran selamat:

1. Mulakan rujukan objek dalam fungsi permulaan statik;

Simpan rujukan objek pada volatile atau AtomicReference
Simpan rujukan objek kepada jenis akhir yang membina objek dengan betul
Simpan objek dalam skop kunci.
Akses selamat:

Benang ditutup
Perkongsian baca sahaja
Perkongsian selamat benang, kaedah akses dalaman objek yang diterbitkan adalah selamat benang dan tiada penyegerakan luaran diperlukan
Lindungi objek, terbitkan objek boleh ubah dengan mengehadkan akses luaran dan nyatakan antara muka untuk mengakses objek boleh ubah.

Ini telah mematuhi peraturan pertama penerbitan selamat

Kemudian kita mesti memastikan akses selamat Memandangkan senarai itu tidak boleh diakses dengan selamat dalam tiga situasi pertama, kita hanya boleh bergantung pada menyekat dunia luar apabila. menerbitkan objek, iaitu mengunci. static List<String> arrayList = new ArrayList<>();

Answer 4

Ia boleh direalisasikan mengikut permintaan subjek, tetapi realisasi permintaan ini sangat pelik.

    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();
}

Selain kaedah ini, ia juga boleh dicapai melalui join dan lulus countdownlatch Jika anda benar-benar ingin menjadi seperti subjek, lebih baik tidak menggunakan multi-threading

Answer 5

Menggunakan kaedah invokeAll bagi kumpulan benang boleh memastikan bahawa susunan keputusan adalah konsisten dengan susunan parameter yang diluluskan dalam

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;
            }
        }
    }