目录
编写第一个多线程程序
1. 方式一 : 继承Thread类, 重写run方法
2. 方式二: 实现Runnable接口, 重写run方法
3. 方式三: 使用Lambda表达式
[匿名内部类]
[Lambda表达式]
在上个文章中, 我们了解了进程和线程的相关概念. 那么, 在Java中, 我们如何进行多线程编程呢?
线程本身是操作系统的一个概念, 操作系统提供一个线程的API, 供程序员调用. 不同的操作系统线程的API是不同的 (Windows的线程API和Linux的线程API差异很大). 但是JVM将不同的系统线程的API都封装好了, 所以我门在不同系统上进行Java的多线程编程时, 不需要关注系统原生的API, 只需要掌握Java这一套API就可以了.
在Java中, Thread类就负责完成多线程的相关开发.
编写第一个多线程程序
我们有多种方式来进行多线程编程.
1. 方式一 : 继承Thread类, 重写run方法
(1) 步骤一: 创建一个线程类
[注]: 这里不需要对Thread进行导包操作, 因为Thread是java.lang包中的类, 默认已经导入.
上述代码, 就创建了一个线程类(MyThread类) 继承自Thread类. 类里重写了run()方法. (run()方法是Runnable接口中定义的一个方法, 用来指定线程要执行的任务, Thread类实现了run方法, 我们定义的MyThread类继承自Thread, 自然需要重写run方法, 来制定我们当前这个线程需要完成什么任务)
(2) 步骤二: 启动线程
观察运行结果, 我们可以看到, 现在控制台上正在循环打印"hello thread", 代表我们创建的MyThread线程启动了. 这里涉及到一个方法start(), 这个方法的作用就是启动线程.
[注]: 通过上述代码, 我们看到, main方法中并没有调用run()方法, 但是程序确实执行力main方法里面的内容. 像这种, 我们手动定义但没有手动调用, 被系统自动调用执行的方法, 叫做"回调函数"(Callback Function)
接下来我们整体看这个代码:
class MyThread extends Thread {
@Override
public void run() {
// 这里写的代码, 就是即将创建出的线程, 要执行的逻辑.
while (true) {
System.out.println("hello thread");
// 该线程需要完成的任务: 循环打印"hello thread".
}
}
}
public class Demo1 {
public static void main(String[] args) {
MyThread t = new MyThread();
t.start(); // 这一步就创建了一个线程
}
}上述代码实际上就是一个进程. 因为调用了main方法, 所以该进程中还有一个执行main方法的线程, 就叫做"主线程". 我们之前说过, 一个进程至少包含一个线程, 这个线程就是主线程.
主线程和t线程会并发/并行地在CPU上调度执行. 宏观表现就是交替打印主线程和t线程中的任务.
class MyThread extends Thread { //创建一个线程类
@Override
public void run() {
// 这里写的代码, 就是即将创建出的线程, 要执行的逻辑.
while (true) {
System.out.println("hello thread");
// 该线程需要完成的任务: 循环打印"hello thread".
}
}
}
public class Demo1 {
public static void main(String[] args) {
MyThread t = new MyThread(); //实例化一个新线程
t.start(); //启动这个线程
while (true) {
System.out.println("hello main");
// 主线程要完成的任务: 循环打印"hello main".
}
}
} 
从运行结果来看, 主线程和t线程的任务交替打印. 那么多个线程之间, 谁先去CPU上调度执行, 谁后去CPU上调度执行, 这个顺序是不确定的, 取决于操作系统的内核. 并且, 我们把这种执行方式叫做"抢占式执行".
* 使用匿名内部类来实现方式一
上述红框框住的代码, 就使用了匿名内部类. 这部分代码完成了3件事: (1) 定义了一个匿名内部类, 这个类一定是Thread的子类. (2) 在这个类内部重写了run方法. (3) 创建了一个类的实例, 并且赋给了引用t.
2. 方式二: 实现Runnable接口, 重写run方法
方式一中, 我们的MyThread类是继承自Thread类的, 而Thread类又实现了Runnable接口. 那么我们能不能直接实现Runnable接口呢? 那当然是可以的.
(1) 步骤一: 创建一个MyRunnable类, 实现Runnable接口
(2) 步骤二: 实例化一个MyRunnable类的对象, 并用这个对象实例化一个新线程.
整体代码如下:
class MyRunnable implements Runnable {
@Override
public void run() {
while (true) {
System.out.println("hello thread");
// 该线程需要完成的任务: 循环打印"hello thread".
}
}
}
public class Demo2 {
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable(); //实例化一个MyRunnable类的对象
Thread t = new Thread(myRunnable); // 用myRunnable实例化一个新线程
t.start();
while (true) {
System.out.println("hello main");
// 主线程需要完成的任务: 循环打印"hello main".
}
}
}* 使用匿名内部类来实现方式二:
public class Demo4 {
public static void main(String[] args) {
// Runnable runnable = new Runnable(){
// @Override
// public void run() {
// while (true) {
// System.out.println("hello thread");
// }
// }
// };
// Thread t = new Thread(runnable);
// // 上述代码还是比较繁琐, 我们可以再嵌套一层匿名内部类
Thread t = new Thread(new Runnable(){
@Override
public void run() {
while (true) {
System.out.println("hello thread");
}
}
});// 嵌套两层匿名内部类 实例化出一个线程对象
t.start(); //启动线程
}
}3. 方式三: 使用Lambda表达式
public class Demo5 {
public static void main(String[] args) {
Thread t = new Thread(() -> {
while (true) {
System.out.println("hello thread");
}
}); // Lambda表达式: ()代表函数的形参列表为空; {}前面是空的,代表函数没有返回值, {}里面是方法体.
}
}( )内为空代表函数的形参列表为空; { }前面是空的,代表函数没有返回值, { }里面是方法体.
[匿名内部类]
匿名内部类（Anonymous Inner Class）是一种没有名字的内部类，通常用于创建那些只需要使用一次的类实例。匿名内部类可以继承一个类或者实现一个接口，并且可以在创建时立即进行实例化和使用。
[注]: 匿名内部类一般是"一次性使用"的类, 用完一次之后就不再使用了.
匿名内部类可以访问外部类的成员变量和方法，包括私有成员。
匿名内部类只能用于创建一个类的实例，不能用于创建多个实例。
[Lambda表达式]
Lambda表达式其实就是一个"函数式接口"产生的"匿名内部类", 实质上还是一种匿名内部类. Lambda 表达式通常用于实现函数式接口（Functional Interface），这是一个只有一个抽象方法的接口。例如，Runnable 接口只有一个 run 方法，因此可以用 Lambda 表达式来实现。
本篇文章主要讨论了如何写好你的第一个多线程程序, 快去试试吧~~
