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);
        }
    }
}

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);
        }
    }
}

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、采用继承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。