Java-多线程基础

什么是多线程

在程序中，一个线程就是一条执行路径。一个程序默认从主线程开始执行。如果程序中开辟了多个线程，则程序就会多个线程同时执行。

多线程可以大幅度提高程序的效率，因为多个线程可以同时执行，而不是一个一个依次执行。

多线程的实现

Java中实现多线程主要有两种方式，一种是继承Thread类，一种是实现Runnable接口。

继承Thread类

public class MyThread extends Thread {
    @Override
    public void run() {
        // 实现多线程的代码
    }
}

在实现类中重写run方法，并在该方法中实现多线程的具体代码，然后通过调用start方法来启动线程。

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

实现Runnable接口

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 实现多线程的代码
    }
}

在实现类中同样重写run方法，并在该方法中实现多线程的具体代码。这时需要在创建线程时将该实现类作为参数传入Thread类中。

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

多线程的基本方法

Java多线程中，常用的线程方法有:

方法	描述
start	启动线程，并执行run方法
join	线程等待，让其他线程等待该线程执行完毕
sleep	让线程休眠指定的时间
yield	让出CPU资源，使其他线程可以被调度

这里简单介绍一下常用的线程方法sleep。

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println(getName() + "线程正在运行...");
            try {
                Thread.sleep(1000); // 线程休眠1秒钟
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

在该例子中，使用了sleep方法让线程休眠1秒钟，然后再继续执行下一个循环。

多线程的状态

Java多线程中，线程会存在以下几种状态:

• 新建状态：当一个Thread类或其子类的对象被声明并创建时，该线程处于新建状态。
• 就绪状态：当调用start方法之后，该线程处于就绪状态，等待调度器调度执行。
• 运行状态：当调度器从多个就绪状态的线程中选择一个线程调用其run方法时，该线程处于运行状态。
• 阻塞状态：线程因为某种原因放弃CPU，暂时停止运行，并处于阻塞状态。直到线程进入就绪状态，才有机会转到运行状态。
• 死亡状态：线程完成工作或者因异常退出run方法时，该线程结束，并处于死亡状态。

示例说明

示例1

下面的代码用两个线程交替输出1至10的数字：

public class Main {
    private static Object lock = new Object(); // 初始化锁

    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    for (int i = 1; i <= 10; i += 2) {
                        System.out.println(Thread.currentThread().getName() + " " + i);
                        lock.notify(); // 唤醒另一个线程
                        try {
                            lock.wait(); // 让出CPU控制权，并释放锁
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    lock.notify(); // 唤醒另一个线程
                }
            }
        }, "线程1");

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    for (int i = 2; i <= 10; i += 2) {
                        System.out.println(Thread.currentThread().getName() + " " + i);
                        lock.notify(); // 唤醒另一个线程
                        try {
                            lock.wait(); // 让出CPU控制权，并释放锁
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    lock.notify(); // 唤醒另一个线程
                }
            }
        }, "线程2");

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

在该例子中，我们使用了一个Object类型的对象作为锁来保证线程的同步。每个线程执行输出完后，都调用notify方法唤醒另一个线程来执行输出任务，在执行输出任务之前，又调用了wait方法让出了CPU控制权，并释放锁。通过这种方式，两个线程实现了交替输出的效果。

示例2

下面的代码使用线程池的方式进行多线程的实现。

public class Main {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "正在执行。");
                }
            });
        }
        executorService.shutdown();
    }
}

在该例子中，我们使用了线程池的方式进行多线程的实现。通过创建一个线程池，然后提交任务给线程池来执行，最后用shutdown方法关闭线程池，实现了多线程的优雅退出。