彻底搞懂Java多线程(一)

为什么需要多线程

在Java应用程序中，多线程可以帮助我们利用CPU资源，提高程序的执行效率，加速程序的运行速度。理论上，一个程序的执行速度可以比单线程的程序快1到100倍不等。

Java多线程的实现方式

Java多线程的实现方式主要有两种：继承Thread类和实现Runnable接口。

继承Thread类

使用继承Thread类的方式，需要重写Thread类的run()方法，并在该方法中实现多线程的操作。

public class MyThread extends Thread {
    // 重写run方法
    public void run() {
        // 多线程的操作
    }
}

实现Runnable接口

使用实现Runnable接口的方式，需要在类中实现Runnable接口的run()方法，并在该方法中实现多线程的操作。然后，创建Thread类的实例，将Runnable对象作为它的构造函数参数传递，最后调用start()方法启动线程。

public class MyRunnable implements Runnable {
    // 实现run方法
    public void run() {
        // 多线程的操作
    }
}

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

Java多线程的生命周期

Java多线程的生命周期包括5个状态：新建、就绪、运行、阻塞和死亡。

新建状态

当用new关键字创建一个Thread对象时，线程进入新建状态。

就绪状态

当线程调用start()方法时，线程进入就绪状态，等待JVM调度执行。

运行状态

当线程被JVM调度执行时，线程进入运行状态。

阻塞状态

当线程在等待一个监视器锁或某些操作执行的结果时，线程进入阻塞状态。

死亡状态

当线程执行完run()方法后或因异常而结束时，线程进入死亡状态。

Java多线程的同步机制

在Java多线程环境中，同步机制是用来解决多个线程访问共享资源的问题。

synchronized关键字

synchronized关键字可以用来确保同一时间只有一个线程能够访问共享资源。

public class Test {
    // 定义共享变量count
    private static int count = 0;
    // 在方法中使用synchronized关键字同步访问count变量
    public synchronized static void add() {
        count++;
    }
    public static void main(String[] args) throws InterruptedException {
        // 创建20个线程
        for (int i = 0; i < 20; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    // 每个线程循环调用1000次add方法
                    for (int i = 0; i < 1000; i++) {
                        add();
                    }
                }
            });
            thread.start();
        }
        // 等待所有线程执行完毕
        Thread.sleep(1000);
        System.out.println(count);
    }
}

wait()和notify()方法

wait()和notify()方法是Java中用于线程同步的另外两个重要的方法。

• wait()方法会让当前的线程进入等待状态，直到其它线程调用notify()方法将其唤醒。
• notify()方法会唤醒处于等待状态的线程，但不会释放锁，因此必须等到执行notify()方法的线程释放锁之后其他线程才能继续执行。

public class Test {
    public static void main(String[] args) throws InterruptedException {
        final Object lock = new Object();
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    try {
                        System.out.println("Thread1等待...");
                        lock.wait();
                        System.out.println("Thread1被唤醒！");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    try {
                        System.out.println("Thread2睡眠1秒钟...");
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    lock.notify();
                }
            }
        });
        thread1.start();
        thread2.start();
    }
}

示例说明

示例1

这是一个简单的多线程示例，创建了20个线程，每个线程循环调用1000次add方法，将一个静态变量count的值加1。

public class Test {
    // 定义共享变量count
    private static int count = 0;
    // 在方法中使用synchronized关键字同步访问count变量
    public synchronized static void add() {
        count++;
    }
    public static void main(String[] args) throws InterruptedException {
        // 创建20个线程
        for (int i = 0; i < 20; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    // 每个线程循环调用1000次add方法
                    for (int i = 0; i < 1000; i++) {
                        add();
                    }
                }
            });
            thread.start();
        }
        // 等待所有线程执行完毕
        Thread.sleep(1000);
        System.out.println(count);
    }
}

示例2

这个示例展示了wait()和notify()方法的使用。在线程1调用lock.wait()方法进入等待状态后，线程2睡眠1秒钟，然后调用lock.notify()方法唤醒在线程1中等待的线程。

public class Test {
    public static void main(String[] args) throws InterruptedException {
        final Object lock = new Object();
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    try {
                        System.out.println("Thread1等待...");
                        lock.wait();
                        System.out.println("Thread1被唤醒！");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    try {
                        System.out.println("Thread2睡眠1秒钟...");
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    lock.notify();
                }
            }
        });
        thread1.start();
        thread2.start();
    }
}