How to use multi-threaded concurrent programming in Java 7

How to use multi-threaded concurrent programming in Java 7

In modern computer systems, multi-threaded programming has become a common way to take full advantage of multi-core processors and parallel computing. As a commonly used programming language, Java has strong multi-threading support, allowing developers to use multi-threading to implement concurrent programming. This article will introduce how to use multi-threading to implement concurrent programming in Java 7, with code examples.

1. Create a thread
   In Java, you can create a thread by inheriting the Thread class or implementing the Runnable interface. The following is a sample code for creating a thread by inheriting the Thread class:

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

   The sample code for creating a thread by implementing the Runnable interface is as follows:

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

2. Start a thread
   Create a thread Finally, you need to call the start() method to start the thread. The following is a sample code to start a thread:

   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. Thread synchronization
   In multi-thread programming, if multiple threads read and write shared data at the same time, data corruption may occur. Inconsistency or conflict. In order to avoid this problem, you can use synchronization mechanism to ensure thread safety. Java provides the synchronized keyword and Lock class to implement thread synchronization. The following is a sample code that uses the synchronized keyword to achieve thread synchronization:

   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. Inter-thread communication
   In multi-threaded programming, sometimes we need to communicate between threads, such as a thread Wait for another thread to complete a task before continuing. Java provides wait(), notify() and notifyAll() methods to implement communication between threads. The following is a sample code that implements inter-thread communication through the wait() and notify() methods:

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

   The above is the basic process and sample code for using multi-threading to implement concurrent programming in Java 7. By rationally using multi-threading, you can make full use of computer resources and improve program performance and response speed. However, in multi-threaded programming, you also need to pay attention to the correct use of thread safety and synchronization mechanisms to avoid problems such as data inconsistency and race conditions.

The above is the detailed content of How to use multi-threaded concurrent programming in Java 7. For more information, please follow other related articles on the PHP Chinese website!