Java多线程学习笔记 - 1
Java多线程学习笔记 - 1
一、多任务
概述： 多任务就是同时运行多个任务。
好处： 充分利用了CPU的资源，提高了代码的执行效率。
执行方式：
并发：在一段时间内交替去执行多项任务【任务数 > 核数】
并行：多个计算机内核一起执行任务，一个内核负责执行一个任务【任务数 <= 核数】
实现方式： 多线程或多进程。
二、进程与线程
2.1 概述
进程： 一个正在运行的程序或软件就是一个进程，它是操作系统进行资源分配的基本单位。
线程： 操作系统调度的最小任务单位。
2.2 进程与线程之间的关系
一个进程可以包含一个或多个线程，但至少会有一个线程。线程是依附进程而存在的，换言说：没有进程就没有线程。
2.3 进程 vs 线程
与多线程相比，多进程优点：
稳定性比线程高。在多进程情况下，一个进程的崩溃不会影响其他进行的执行，而在多线程的情况下，任何一个线程崩溃会直接导致整个进程崩溃。
与多线程相比，多进程缺点：
创建进程比创建线程开销大；
进程间通信比线程间通信要慢，因为线程间数据是共享的。
三、创建线程的方法
3.1 继承 Threda 类，重写 run 方法
// Demo
public class ThreadTest {
public static void main(String[] args) {
// 创建线程对象
MyThread myThread = new MyThread();
// 启动线程
myThread.start();
for (int i = 0; i < 10; i++) {
System.out.println("更上一层楼" + i);
}
}
}
class MyThread extends Thread{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("欲穷千里目" + i);
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
3.2 实现 Runnable 接口
// Demo
public class RunnableTest {
public static void main(String[] args) {
// 创建一个任务对象
MyRunnable myRunnable = new MyRunnable();
// 创建一个子线程对象
Thread thread = new Thread(myRunnable);
// 开启子线程任务
thread.start();
for (int i = 0; i < 10; i++) {
System.out.println("秋收万颗子" + i);
}
}
}
class MyRunnable implements Runnable{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("春种一粒粟" + i);
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
3.3 实现 Callable 接口
通过Callable<T>接口实现多线程，比较繁琐，优点是有返回值。
// Demo
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
import java.util.concurrent.ExecutionException;
public class CallableTest{
public static void main(String[] args) throws ExecutionException, InterruptedException {
// 创建任务对象
Callable<Integer> callable = new MyCallable();
FutureTask<Integer> task = new FutureTask<>(callable);
// 启动线程
new Thread(task).start();
// 获取子线程返回值。
// 如果使用该方法，主线程将会等待子线程返回结果后再执行。也可以设置指定等待时间，如果指定时间内子线程未运行完毕，主线程不再等待子线程运行结果，继续往下运行。
/*
Integer result = task.get();
System.out.println("子线程返回值为：" + result);
*/
int count =0;
for (int i = 0; i < 5; i++) {
count += i;
}
System.out.println("主线程的返回值为：" + count);
}
}
class MyCallable implements Callable<Integer>{
@Override
public Integer call() throws Exception {
int count = 0;
for (int i = 0; i < 10; i++) {
count += i;
}
System.out.println("子线程运行完毕，结果为：" + count);
return count;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
总结：
1、采用继承Thread类的方式创建多线程：
优势：编写简单，访问当前线程直接使用this即可。
劣势：因为线程类已经继承了Thread类，所以不能再继承其他父类。
2、采用实现Runnable或Callable接口的方式创建多线程：
优势：
线程类只是实现了Runnable或Callable接口，还可以继承其他类，避免了单继承所带来的局限性；
此种方式下，多线程可以共享同一个target对象，非常适合多个相同线程来处理同一份资源的情况
任务与线程本身是分离的，提供了程序的健壮性。
劣势：
编程比较复杂，访问当前线程必须使用Thread.currentThread()方法。
3、综上所述，一般推荐采用实现Runnable或Callable接口的方式创建多线程。
四、线程状态
在Java程序中，一个线程对象只能调用一次start() 方法启动新线程，并在新线程中执行run()方法。一旦run()方法执行完毕，线程结束。因此，Java线程的状态有以下几种：
NEW：新创建的线程，尚未执行；
RUNNABLE：运行中的线程，正在执行run()方法中的代码；
BLOCKED：运行中的线程，因为某些操作被阻塞而挂起；
WAITING：运行中的线程，因为某些操作在等待中；
TIMED_WAITING：运行中的线程，因为执行sleep()方法正在计时等待；
TERMINATED：线程已终止，因为run()方法执行完毕。
用一个状态转移图表示如下：
线程在给定时间点只能处于一种状态。当线程启动后，它可以在RUNNABLE、BLOCKED、WAITING和TIMED_WAITING这几个状态之间切换，直到最后变成TERMINATED状态，线程终止。
五、线程终止
1、线程自然终止：run()方法执行到return语句返回；
2、线程意外终止：run()方法因为未捕获的异常导致线程被终止；
3、外部干涉终止：程序员在线程类中定义线程使用标识，在线程体内使用该标识，并提供对外方法改变该标识。当程序运行满足某种条件时，调用方法改变标识，使程序终止执行。
4、对某个线程的Thread实例调用stop()方法强制终止（已弃用）
六、线程优先级
我们可以通过调用线程的setPriority()方法设置线程的优先级，优先级的范围是：1~10，以下是几个优先级的常量：
MAX_PRIORITY：线程可以拥有的最大优先级，值为10；
MIN_PRIORITY：线程可以拥有的最低优先级，值为1。
NORM_PRIORITY：分配给线程的默认优先级，值为5。
————————————————
版权声明：本文为CSDN博主「阿兵哥哥」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/Ayue1220/article/details/114709167