Multithreading methods and examples developed in Java

Java is a popular programming language and one of the most widely used multi-threaded programming languages. Multi-threading refers to allowing a program to perform multiple tasks at the same time, which can improve the execution efficiency of the program. This article will introduce multi-threading methods and examples in Java development.

1. The basic concept of Java multi-threading

Multi-threading in Java is to complete tasks in the code by creating multiple threads. In a single-threaded program, each statement is executed in sequence, while in a multi-threaded program, different threads can execute different statements at the same time, which improves the execution efficiency of the program.

In Java, threads are implemented through the Thread class. Each thread is an independent execution unit with its own execution stack and execution control flow. Threads in Java are divided into user threads and daemon threads. When all user threads have finished executing, the daemon thread will also end execution.

2. How to implement multi-threading in Java

Multi-threading in Java can be achieved by implementing the Runnable interface or inheriting the Thread class. Using the Runnable interface can achieve code reuse, and using the Thread class can achieve more control.

2.1 Implement the Runnable interface

To use the Runnable interface, you need to implement the run() method, and write the code to be executed by multiple threads in the run() method. To use the Runnable interface, you need to create a Thread object and start the thread through the Thread object.

The sample code is as follows:

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        //多线程执行的代码
        System.out.println("MyRunnable start");
    }

    public static void main(String[] args) {

        MyRunnable r = new MyRunnable();
        Thread t = new Thread(r);
        t.start();

    }
}

2.2 Inheriting the Thread class

Inheriting the Thread class requires overriding the run() method, and writing multi-threaded execution in the run() method code.

The sample code is as follows:

public class MyThread extends Thread{

    @Override
    public void run() {
        //多线程执行的代码
        System.out.println("MyThread start");
    }

    public static void main(String[] args) {

        MyThread t = new MyThread();
        t.start();

    }
}

3. Common methods of Java multi-threading

Multi-threading in Java can be operated using some common methods. The following are commonly used methods:

3.1 start()

The start() method is a method to start a thread.

The sample code is as follows:

Thread t = new Thread();
t.start();

3.2 join()

The join() method is a method that waits for the thread to complete execution.

The sample code is as follows:

Thread t = new Thread();
t.start();
t.join();

3.3 sleep()

The sleep() method is a method to let the thread sleep for a period of time.

The sample code is as follows:

Thread.sleep(1000);

4. Java multi-thread synchronization issue

Multiple threads in Java will involve synchronization issues. Multiple threads can do this at the same time. Accessing the same resource can cause conflicts. Java provides the synchronized keyword and Lock interface to solve this problem.

4.1 synchronized keyword

The synchronized keyword can be used to modify an object or method to ensure that only one thread can execute this object or method at the same time.

The sample code is as follows:

public class MyThread implements Runnable{

    private static int count = 0;

    @Override
    public synchronized void run() {
        for (int i = 0; i < 10000; i++) {
            count++;
        }
    }

    public static void main(String[] args) throws InterruptedException {

        MyThread r1 = new MyThread();
        MyThread r2 = new MyThread();

        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r2);

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println(count);

    }
}

4.2 Lock interface

The Lock interface provides a more flexible locking method and is more refined than the synchronized keyword.

The sample code is as follows:

public class MyThread implements Runnable{

    private static int count = 0;

    private Lock lock = new ReentrantLock();

    @Override
    public void run() {

        lock.lock();
        try {
            for (int i = 0; i < 10000; i++) {
                count++;
            }
        } finally {
            lock.unlock();
        }

    }

    public static void main(String[] args) throws InterruptedException {

        MyThread r1 = new MyThread();
        MyThread r2 = new MyThread();

        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r2);

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println(count);

    }
}

5. Conclusion

Multiple threads in Java can improve the execution efficiency of the program and are often used in development. This article introduces the basic concepts, implementation methods, common methods and solutions to synchronization problems in Java multithreading. I hope it will be helpful to students who develop Java.

The above is the detailed content of Multithreading methods and examples developed in Java. For more information, please follow other related articles on the PHP Chinese website!