Cara menggunakan pengaturcaraan serentak berbilang benang dalam Java 7

Cara menggunakan pengaturcaraan serentak berbilang benang dalam Java 7

Dalam sistem komputer moden, pengaturcaraan berbilang benang telah menjadi cara biasa untuk memanfaatkan sepenuhnya pemproses berbilang teras dan pengkomputeran selari. Sebagai bahasa pengaturcaraan yang biasa digunakan, Java mempunyai sokongan multi-threading yang kuat, membolehkan pembangun menggunakan multi-threading untuk melaksanakan pengaturcaraan serentak. Artikel ini akan memperkenalkan cara menggunakan multi-threading untuk melaksanakan pengaturcaraan serentak dalam Java 7, dengan contoh kod.

1. Mencipta Benang
   Di Java, anda boleh mencipta benang dengan mewarisi kelas Benang atau melaksanakan antara muka Runnable. Berikut ialah contoh kod untuk mencipta thread dengan mewarisi kelas Thread:

   public class MyThread extends Thread {
    public void run() {
        // 线程的执行逻辑
    }
   }

   Contoh kod untuk mencipta thread dengan melaksanakan antara muka Runnable adalah seperti berikut:

   public class MyRunnable implements Runnable {
    public void run() {
        // 线程的执行逻辑
    }
   }

2. Memulakan thread
   Selepas membuat thread, anda perlu memanggil kaedah mula () untuk memulakan benang. Berikut ialah contoh kod untuk memulakan utas:

   public static void main(String[] args) {
    MyThread thread = new MyThread();
    thread.start();
   }

   public static void main(String[] args) {
    Thread thread = new Thread(new MyRunnable());
    thread.start();
   }

3. Penyegerakan benang
   Dalam pengaturcaraan berbilang benang, jika berbilang rangkaian membaca dan menulis data yang dikongsi pada masa yang sama, ketidakkonsistenan data atau konflik mungkin berlaku. Untuk mengelakkan masalah ini, anda boleh menggunakan mekanisme penyegerakan untuk memastikan keselamatan benang. Java menyediakan kata kunci yang disegerakkan dan kelas Kunci untuk melaksanakan penyegerakan benang. Berikut ialah contoh kod yang menggunakan kata kunci disegerakkan untuk mencapai penyegerakan utas:

   public class Counter {
    private int count = 0;
   
    public synchronized void increment() {
        count++;
    }
   }

   public static void main(String[] args) {
    Counter counter = new Counter();
   
    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());
   }

4. Komunikasi antara utas
   Dalam pengaturcaraan berbilang benang, kadangkala kita perlu berkomunikasi antara utas, seperti satu utas menunggu urutan lain selesai tugas tertentu. Java menyediakan kaedah wait(), notify() dan notifyAll() untuk melaksanakan komunikasi antara benang. Berikut ialah contoh kod yang melaksanakan komunikasi antara benang melalui kaedah wait() dan notify():

   public class Message {
    private String message;
    private boolean empty = true;
   
    public synchronized String read() {
        while (empty) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        empty = true;
        notifyAll();
        return message;
    }
   
    public synchronized void write(String message) {
        while (!empty) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        empty = false;
        this.message = message;
        notifyAll();
    }
   }

   public static void main(String[] args) {
    Message message = new Message();
   
    Thread thread1 = new Thread(() -> {
        String[] messages = { "Message 1", "Message 2", "Message 3" };
        for (String msg : messages) {
            message.write(msg);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });
   
    Thread thread2 = new Thread(() -> {
        for (int i = 0; i < 3; i++) {
            String msg = message.read();
            System.out.println(msg);
        }
    });
   
    thread1.start();
    thread2.start();
   
    try {
        thread1.join();
        thread2.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
   }

   Di atas ialah proses asas dan kod sampel untuk menggunakan multi-threading untuk melaksanakan pengaturcaraan serentak dalam Java 7. Dengan menggunakan multi-threading secara rasional, anda boleh menggunakan sepenuhnya sumber komputer dan meningkatkan prestasi program dan kelajuan tindak balas. Walau bagaimanapun, dalam pengaturcaraan berbilang benang, anda juga perlu memberi perhatian kepada penggunaan yang betul bagi mekanisme keselamatan dan penyegerakan benang untuk mengelakkan masalah seperti ketidakkonsistenan data dan keadaan perlumbaan.

Atas ialah kandungan terperinci Cara menggunakan pengaturcaraan serentak berbilang benang dalam Java 7. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!