Java多线程学习笔记 - 1

爱被打了一巴掌 2022-11-07 14:49 315阅读 0赞

### 一、多任务 ###

**概述：** 多任务就是同时运行多个任务。  
**好处：** 充分利用了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()`方法执行完毕。

用一个状态转移图表示如下：  
![线程状态图][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0F5dWUxMjIw_size_16_color_FFFFFF_t_70]  
线程在给定时间点只能处于一种状态。当线程启动后，它可以在`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`。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0F5dWUxMjIw_size_16_color_FFFFFF_t_70]: /images/20221023/8314116021204f92861931a5f4b17694.png