Java线程与进程详解：创建、区别与并发性能-优快云博客

本文链接：https://blog.youkuaiyun.com/2301_76508804/article/details/132384527

线程:(Thread)

特点:

是计算机中两个重要的概念之一，用于描述并发执行的程序。

与进程是被包含于的关系

线程是进程中的独立执行单元。一个进程可以包含多个线程，这些线程共享相同的内存空间和其他资源。每个线程都有自己的程序计数器、栈和局部变量等，但它们共享进程的全局变量和堆内存空间。多线程可以让程序并发执行，提高程序的性能和响应能力。

创建线程的方式:

方式一

继承Thread类：

在面向对象编程中，可以创建一个自定义的类，继承自Thread类。
在自定义的类中，重写Thread类中的run方法，定义线程的执行逻辑。
创建该自定义类的实例，并使用实例调用start方法来启动线程的执行。

1.Java为开发者提供了一个类叫做Thread，此类的对象用来表示线程。创建线程并执行线程的步骤如下:

1.定义一个子类继承Thread类，并重写run方法
2.创建Thread的子类对象
3.调用start方法启动线程（启动线程后，会自动执行run方法中的代码）

代码如下

public class MyThread extends Thread{
// 2、必须重写Thread类的run方法
@Override
public void run() {
// 描述线程的执行任务。
for (int i = 1; i <= 5; i++) {
System.out.println("子线程MyThread输出：" + i);
}
}
}

再定义一个测试类，在测试类中创建MyThread线程对象，并启动线程

public class ThreadTest1 {
// main方法是由一条默认的主线程负责执行。
public static void main(String[] args) {
// 3、创建MyThread线程类的对象代表一个线程
Thread t = new MyThread();
// 4、启动线程（自动执行run方法的）
t.start();

for (int i = 1; i <= 5; i++) {
System.out.println("主线程main输出：" + i);
}
}
}

打印结果如下图所示，我们会发现MyThread和main线程在相互抢夺CPU的执行权

最后我们还需要注意一点：不能直接去调用run方法，如果直接调用run方法就不认为是一条线程启动了，而是把Thread当做一个普通对象，此时run方法中的执行的代码会成为主线程的一部分。此时执行结果是这样的。

实现Runnable接口：

可以创建一个实现了Runnable接口的类，该接口只定义了一个run方法。
在实现类中，实现run方法，定义线程的执行逻辑。
创建该实现类的实例，并将实例作为参数传递给Thread类的构造函数。
调用Thread实例的start方法来启动线程的执行。

2.Java为开发者提供了一个Runnable接口，该接口中只有一个run方法，意思就是通过Runnable接口的实现类对象专门来表示线程要执行的任务。具体步骤如下

1.先写一个Runnable接口的实现类，重写run方法(这里面就是线程要执行的代码)
2.再创建一个Runnable实现类的对象
3.创建一个Thread对象，把Runnable实现类的对象传递给Thread
4.调用Thread对象的start()方法启动线程（启动后会自动执行Runnable里面的run方法）

代码如下：先准备一个Runnable接口的实现类

/**
* 1、定义一个任务类，实现Runnable接口
*/
public class MyRunnable implements Runnable{
// 2、重写runnable的run方法
@Override
public void run() {
// 线程要执行的任务。
for (int i = 1; i <= 5; i++) {
System.out.println("子线程输出 ===》" + i);
}
}
}

再写一个测试类，在测试类中创建线程对象，并执行线程

public class ThreadTest2 {
public static void main(String[] args) {
// 3、创建任务对象。
Runnable target = new MyRunnable();
// 4、把任务对象交给一个线程对象处理。
// public Thread(Runnable target)
new Thread(target).start();

for (int i = 1; i <= 5; i++) {
System.out.println("主线程main输出 ===》" + i);
}
}
}

运行上面代码，结果如下图所示

主线程main输出 ===》1
主线程main输出 ===》2
主线程main输出 ===》3
子线程输出 ===》1
子线程输出 ===》2
子线程输出 ===》3
子线程输出 ===》4
子线程输出 ===》5
主线程main输出 ===》4
主线程main输出 ===》5

线程创建方式2—匿名内部类

代码如下

public class ThreadTest2_2 {
public static void main(String[] args) {
// 1、直接创建Runnable接口的匿名内部类形式（任务对象）
Runnable target = new Runnable() {
@Override
public void run() {
for (int i = 1; i <= 5; i++) {
System.out.println("子线程1输出：" + i);
}
}
};
new Thread(target).start();

// 简化形式1：
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 1; i <= 5; i++) {
System.out.println("子线程2输出：" + i);
}
}
}).start();

// 简化形式2：
new Thread(() -> {
for (int i = 1; i <= 5; i++) {
System.out.println("子线程3输出：" + i);
}
}).start();

for (int i = 1; i <= 5; i++) {
System.out.println("主线程main输出：" + i);
}
}
}

线程的创建方式3

1.先定义一个Callable接口的实现类，重写call方法
2.创建Callable实现类的对象
3.创建FutureTask类的对象，将Callable对象传递给FutureTask
4.创建Thread对象，将Future对象传递给Thread
5.调用Thread的start()方法启动线程(启动后会自动执行call方法)
等call()方法执行完之后，会自动将返回值结果封装到FutrueTask对象中
6.调用FutrueTask对的get()方法获取返回结果

代码如下：先准备一个Callable接口的实现类

单线程和多线程的区别

单线程和多线程是指程序中线程的数量的不同，它们之间有以下区别：

执行方式：
- 单线程程序只有一个执行线程，按照顺序依次执行任务。每个任务必须等待前一个任务完成后才能执行。
- 多线程程序可以同时执行多个任务，每个任务在独立的线程中执行。多个线程可以并发执行，提高程序的性能和响应能力。
并发性：
- 单线程程序是串行执行的，每个任务按照顺序依次执行。只有一个任务在执行时，其他任务必须等待。
- 多线程程序可以并发执行多个任务，不同的线程可以同时执行不同的任务。多线程可以提高程序的并发性和吞吐量。
资源占用：
- 单线程程序只需要占用一个线程的资源，包括内存、CPU时间等。资源占用较少。
- 多线程程序需要占用多个线程的资源，包括内存、CPU时间等。资源占用较多。
编程复杂性：
- 单线程程序相对简单，因为只有一个执行线程，不需要考虑线程同步和并发控制等问题。
- 多线程程序相对复杂，因为涉及到多个线程的并发执行，需要考虑线程同步、资源共享和并发控制等问题。
错误处理：
- 单线程程序中的错误可能会导致整个程序崩溃，因为只有一个执行线程。
- 多线程程序中的错误可能只会影响到某个线程，其他线程仍然可以继续执行。

/**
* 1、让这个类实现Callable接口
*/
public class MyCallable implements Callable<String> {
private int n;
public MyCallable(int n) {
this.n = n;
}

// 2、重写call方法
@Override
public String call() throws Exception {
// 描述线程的任务，返回线程执行返回后的结果。
// 需求：求1-n的和返回。
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += i;
}
return "线程求出了1-" + n + "的和是：" + sum;
}
}

再定义一个测试类，在测试类中创建线程并启动线程，还要获取返回结果

public class ThreadTest3 {
public static void main(String[] args) throws Exception {
// 3、创建一个Callable的对象
Callable<String> call = new MyCallable(100);
// 4、把Callable的对象封装成一个FutureTask对象（任务对象）
// 未来任务对象的作用？
// 1、是一个任务对象，实现了Runnable对象.
// 2、可以在线程执行完毕之后，用未来任务对象调用get方法获取线程执行完毕后的结果。
FutureTask<String> f1 = new FutureTask<>(call);
// 5、把任务对象交给一个Thread对象
new Thread(f1).start();

Callable<String> call2 = new MyCallable(200);
FutureTask<String> f2 = new FutureTask<>(call2);
new Thread(f2).start();

// 6、获取线程执行完毕后返回的结果。
// 注意：如果执行到这儿，假如上面的线程还没有执行完毕
// 这里的代码会暂停，等待上面线程执行完毕后才会获取结果。
String rs = f1.get();
System.out.println(rs);

String rs2 = f2.get();
System.out.println(rs2);
}
}