Bagaimana untuk menyelesaikan masalah pengaturcaraan serentak di Java

Cara menyelesaikan masalah pengaturcaraan serentak dalam Java

Dalam pengaturcaraan berbilang benang, Java menyediakan perpustakaan pengaturcaraan serentak yang kaya, tetapi masalah pengaturcaraan serentak masih membingungkan pembangun. Artikel ini akan memperkenalkan beberapa masalah pengaturcaraan serentak Java biasa dan menyediakan penyelesaian dan contoh kod yang sepadan.

1. Isu keselamatan benang

Keselamatan benang merujuk kepada ciri bahawa sumber yang dikongsi boleh diakses dengan betul dan stabil serta dikendalikan secara serentak oleh berbilang benang dalam persekitaran berbilang benang. Di Java, isu keselamatan benang sering berlaku dalam operasi baca dan tulis sumber yang dikongsi.

Terdapat banyak cara untuk menyelesaikan isu keselamatan rangkaian Cara yang paling biasa ialah menggunakan kata kunci yang disegerakkan untuk mengunci sumber yang dikongsi.

Kod sampel:

public class Counter {
  private int count;

  public synchronized void increment() {
    count++;
  }

  public int getCount() {
    return count;
  }
}

public class Main {
  public static void main(String[] args) {
    Counter counter = new Counter();

    // 创建多个线程对count进行累加
    Thread thread1 = new Thread(() -> {
       for (int i = 0; i < 1000; i++) {
         counter.increment();
       }
    });

    Thread thread2 = new Thread(() -> {
       for (int i = 0; i < 1000; i++) {
         counter.increment();
       }
    });

    // 启动线程
    thread1.start();
    thread2.start();

    // 等待线程执行完成
    try {
       thread1.join();
       thread2.join();
    } catch (InterruptedException e) {
       e.printStackTrace();
    }

    System.out.println(counter.getCount()); // 2000
  }
}

2. Masalah jalan buntu

Kebuntuan merujuk kepada situasi di mana dua atau lebih utas menunggu tanpa had untuk sumber dikeluarkan, menyebabkan program tidak dapat meneruskan pelaksanaan.

Cara biasa untuk mengelakkan masalah kebuntuan adalah dengan menggunakan susunan blok yang disegerakkan untuk memperoleh kunci. Memastikan semua rangkaian memperoleh sumber yang dikongsi dalam susunan yang sama boleh mengelakkan kebuntuan.

Kod sampel:

public class DeadLockDemo {
  private static Object lock1 = new Object();
  private static Object lock2 = new Object();

  public static void main(String[] args) {
    Thread thread1 = new Thread(() -> {
       synchronized (lock1) {
         System.out.println("Thread1 acquired lock1");
         try {
           Thread.sleep(1000);
         } catch (InterruptedException e) {
           e.printStackTrace();
         }
         synchronized (lock2) {
           System.out.println("Thread1 acquired lock2");
         }
       }
    });

    Thread thread2 = new Thread(() -> {
       synchronized (lock2) {
       System.out.println("Thread2 acquired lock2");
       try {
         Thread.sleep(1000);
       } catch (InterruptedException e) {
         e.printStackTrace();
       }
       synchronized (lock1) {
         System.out.println("Thread2 acquired lock1");
       }
     }
    });

    thread1.start();
    thread2.start();
  }
}

3. Masalah keterlihatan memori

Keterlihatan memori merujuk kepada ciri yang pembolehubah yang dikongsi antara berbilang rangkaian boleh dibaca oleh urutan lain dengan cara yang tepat pada masanya dan betul. Di Java, pembolehubah yang dikongsi antara utas selalunya disimpan dalam memori utama, dan setiap utas mempunyai memori kerjanya sendiri.

Satu cara untuk menyelesaikan masalah keterlihatan memori ialah menggunakan kata kunci yang tidak menentu untuk mengubah suai pembolehubah yang dikongsi. Kata kunci yang tidak menentu memastikan keterlihatan pembolehubah yang dikongsi, iaitu, selepas mengubah suai nilai pembolehubah yang dikongsi, urutan lain boleh melihat nilai terkini dengan serta-merta.

Contoh kod:

public class VolatileDemo {
  private static volatile boolean flag = false;

  public static void main(String[] args) {
    Thread thread1 = new Thread(() -> {
       while (!flag) {
         // do something
       }
       System.out.println("Thread1: flag is true");
    });

    Thread thread2 = new Thread(() -> {
       flag = true;
    });

    thread1.start();
    thread2.start();
  }
}

Di atas ialah beberapa kaedah dan contoh kod biasa tentang menyelesaikan masalah pengaturcaraan serentak di Java. Adalah penting untuk ambil perhatian bahawa masalah pengaturcaraan serentak adalah kawasan yang kompleks dan penyelesaian mungkin berbeza-beza bergantung pada situasi tertentu. Dalam pembangunan sebenar, adalah perlu untuk memilih penyelesaian yang paling sesuai berdasarkan senario dan keperluan perniagaan tertentu.

Atas ialah kandungan terperinci Bagaimana untuk menyelesaikan masalah pengaturcaraan serentak di Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!