Java笔记之多线程（一）

柔光的暖阳◎ 2023-10-09 15:16 33阅读 0赞

#### 文章目录 ####

*  前言
 *  一、什么是进程与线程？
 *   *  1.进程
     *  2.线程
     *  3.其他相关概念
 *  二、如何创建线程
 *   *  1.继承Thread类，重新run方法
     *  2.实现Runnable接口
     *  3.通过Callable和Future创建线程
     *  4. 继承Thread vs实现Runnable的区别
 *  三、用户线程和守护线程
 *   *  守护线程的使用
     *  设置成守护线程
 *  四、线程常用方法
 *   *  常用方法第一组
     *  常用方法第二组
 *  五、使用线程的好处
 *  六、线程生命周期

--------------------

## 前言 ##

在学习多线程之前，先了解什么是进程，什么是线程。

--------------------

## 一、什么是进程与线程？ ##

### 1.进程 ###

1.  进程是指**运行中的程序**，比如我们使用QQ，就启动了一个进程，操作系统就会为该进程**分配内存空间**。当我们使用迅雷，又启动了一个进程,操作系统将为迅雷分配新的内存空间。
2.  进程是程序的一次执行过程，它有自己独立的生命周期，它会在启动程序时产生，运行程序时存在，关闭程序时消亡。

![在这里插入图片描述][f77d552ef7494688b371e7e2a5bb2774.png]

### 2.线程 ###

1.线程由**进程创建的**,是进程的一个实体，是具体干活的人。  
2.一个进程可以拥有多个线程。线程不独立分配内存，而是共享进程的内存资源，线程可以共享cpu的计算资源。  
现在，进程更强调【内存资源的分配】，而线程更强调【计算资源的分配】。因为有了线程的概念，一个进程的线程就不能修改另一个线程的数据，隔离性更好，安全性更好。  
我们在使用浏览器播放视频或者下载文件时，我们可以同时播放或者下载多个，那播放两个视频或者下载多个文件就是不同线程在做的工作，否则，你一定是需要等待一个结束了，另一个才能开始。  
![在这里插入图片描述][7dc73a0649cf4e028adbdebdd8805cb4.png]我们可以在计算机的任务管理器中查看当前计算机的进程和线程数。  
![在这里插入图片描述][04a1b4b784c74a5bb9703208bd08b595.png]

### 3.其他相关概念 ###

1.**单线程**:同个时刻，只允许执行一个线程  
2.**多线程**:同一个时刻，可以执行多个线程，比如:一个qq进程，可以同时打开多个聊天窗口,一个浏览器进程，可以同时下载多个文件  
3.**并发**:同一个时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简  
单的说，单核cpu实现的多任务就是并发。  
![在这里插入图片描述][d84d883ea44e4410885b353ac7e944e2.png]  
4.**并行**:同一个时刻,多个任务同时执行。多核cpu可以实现并行。  
![在这里插入图片描述][b88bac00cb8b497b9842c83c1b1ea45a.png]

## 二、如何创建线程 ##

创建线程主要有三种方式：

### 1.继承Thread类，重新run方法 ###

> 步骤：

• 定义类继承Thread;  
• 重写Thread类中的run方法；（目的：将自定义代码存储在run方法，让线程运行）  
• 调用线程的start方法：(该方法有两步：启动线程，调用run方法)

> 代码如下（示例）：

public class ThreadDemo {
        
        public static void main(String[] args) throws InterruptedException {
        
            new ThreadTest().start();
            while (true) {
        
                System.out.println(Thread.currentThread().getName()+"---1");
                Thread.sleep(1000);
            }
        }
    }
    class ThreadTest extends Thread{
        
        @Override
        public void run() {
        
            while (true) {
        
                System.out.println(Thread.currentThread().getName()+"---2");
                try {
        
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
            }
        }
    }

![在这里插入图片描述][d0aec785f1884a88bb4d1cdeef582ec9.png]

### 2.实现Runnable接口 ###

> 步骤：

• 创建任务： 创建类实现Runnable接口  
• 使用Thread 为这个任务分配线程  
• 调用线程的start方法

> 代码如下（示例）：

public class RunnableDemo {
        
        public static void main(String[] args) throws InterruptedException {
        
            for (int i = 0; i < 11; i++) {
        
                Thread.sleep(1000);
                System.out.println("hi"+i);
                if (i == 5) {
        
                    T3 t3 = new T3();
                    Thread thread = new Thread(t3);
                    thread.start();
                    System.out.println("子线程先开始");
                    thread.join();
                    thread.setDaemon(true);
                    System.out.println("子线程结束，主线程开始");
                }
            }
        }
    }
    class T3 implements Runnable {
        
        @Override
        public void run() {
        
            int sum = 0;
            while (true){
        
                try {
        
                    Thread.sleep(1000);
                    sum++;
                    System.out.println("hello"+sum +"次");
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                if (sum == 10){
        
                    break;
                }
            }
        }
    }

### 3.通过Callable和Future创建线程 ###

（1）创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。  
（2）创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。  
（3）使用FutureTask对象作为Thread对象的target创建并启动新线程。  
（4）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

> 代码如下（示例）：

public class UseCallable {
        
        public static void main(String[] args) throws ExecutionException, InterruptedException {
        
            System.out.println(1);
            //保存一个将来的返回值
            FutureTask<String> futureTask = new FutureTask<>(new Task());
            new Thread(futureTask).start();
            System.out.println(3);
            System.out.println(4);
            String result = futureTask.get();
            System.out.println(5);
            System.out.println(result);
            System.out.println(6);
        }
        static class Task implements Callable<String> {
        
    
            public String call() throws Exception {
        
                while (true) {
        
                    Thread.sleep(1000);
                    return Thread.currentThread().getName() + "---2";
                }
            }
        }
    }

注：futureTask.get();这是一个阻塞的方法，意思就是，这个方法会一直等，主线程会一直等待，这个线程执行完成之后并有了返回值，才会继续执行。

### 4. 继承Thread vs实现Runnable的区别 ###

1.  从java的设计来看,通过继承Thread或者实现Runnable接口来创建线程本  
    质上没有区别,从jdk帮助文档我们可以看到Thread类本身就实现了Runnable接口
2.  实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了 单继承的限制

## 三、用户线程和守护线程 ##

Java提供两种类型的线程：用户线程和守护程序线程

**1. 用户线程：** 也叫工作线程，当线程的任务执行完或通知方式结束。  
**2. 守护线程：** 一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束。  
**3.常见的守护线程:** 垃圾回收机制

### 守护线程的使用 ###

守护线程对于后台支持任务非常有用，例如垃圾收集，释放未使用对象的内存以及从缓存中删除不需要的条目。大多数JVM线程都是守护线程。在比如qq等等聊天软件,主程序是非守护线程,而所有的聊天窗口是守护线程,当在聊天的过程中,直接关闭聊天应用程序时,聊天窗口也会随之关。包括word中我们在书写文字的时候，还有线程帮我们进行拼写检查，这都是守护线程。

### 设置成守护线程 ###

要将线程设置为守护线程，我们需要做的就是调用Thread.setDaemon（）

> 代码示例：

thread.setDaemon(true);

任何线程都继承创建它的线程的守护进程状态。由于主线程是用户线程，因此在main方法内创建的任何线程默认为用户线程。

## 四、线程常用方法 ##

### 常用方法第一组 ###

1.  **setName** //设置线程名称，使之与参数name相同
2.  **getName** //返回该线程的名称
3.  **start** //使该线程开始执行;Java 虚拟机底层调用该线程的start0方法
4.  **run** //调用线程对象 run方法;
5.  **setPriority** //更改线程的优先级
6.  **getPriority** //获取线程的优先级
7.  **sleep** //在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)
8.  **interrupt** //中断线程

**注意事项和细节**

1.  start底层会创建新的线程，调用run,run 就是一个简单的方法调用，不会启动新线程
2.  线程优先级的范围

/**
         * 线程的最小优先级 .
         */
        public static final int MIN_PRIORITY = 1;
    
        /**
         * 线程的默认优先级 .
         */
        public static final int NORM_PRIORITY = 5;
    
        /**
         * 线程的最大优先级 .
         */
        public static final int MAX_PRIORITY = 10;

1.  interrupt,中断线程，但并没有真正的结束线程。所以一般用于中断正在休眠线程
2.  sleep:线程的静态方法,使当前线程休眠

### 常用方法第二组 ###

1.  **yield:线程的礼让**。让出cpu，让其他线程执行，但礼让的时间不确定,所以也不一定礼让成功
2.  **join:线程的插队**。插队的线程一旦插队成功，则肯定先执行完插入的线程所有的任务

> 示例代码：

public class Thread03 {
        
        public static void main(String[] args) throws InterruptedException {
        
            T1 t1 = new T1();
            t1.start();
            for (int i = 0; i < 11; i++) {
        
                System.out.println("主线程（小弟）吃" + i + "包子" );
                if (i == 5) {
        
                    System.out.println("主线程（小弟）让（老大）先吃");
                    t1.join();
                    //Thread.yield();
                    System.out.println("主线程（老大）吃完了，小弟吃");
                }
            }
        }
    }
    class T2 implements Runnable {
        
            @Override
            public void run() {
        
                int sum = 0;
                while (true) {
        
                    try {
        
                        Thread.sleep(1000);
                        sum++;
                        System.out.println("hello" + sum + "次");
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                    if (sum == 10) {
        
                        break;
                    }
                }
            }
        }

## 五、使用线程的好处 ##

1.加速，提高CPU的使用率  
2.能够异步无干扰进行其他业务操作

> 代码示例：

public class UseCallable1 {
        
        public static void main(String[] args) throws ExecutionException, InterruptedException {
        
            //单线程计算
            long start = System.currentTimeMillis();
            long res = 0L;
            for (int i = 0; i < 1000000000; i++) {
        
                res += i;
            }
            long end = System.currentTimeMillis();
            System.out.println("---单线程计算时间" + (end - start));
            System.out.println(res);
            //多线程计算
            start = System.currentTimeMillis();
            FutureTask[] futureTasks = new FutureTask[10];
            res = 0L;
            for (int i = 0; i < 10; i++) {
        
                FutureTask<Long> futureTask = new FutureTask<>(new Task(i*100000000,(i+1)*100000000));
                new Thread(futureTask).start();
                futureTasks[i] = futureTask;
            }
            for (int i = 0; i < futureTasks.length; i++) {
        
                long sum = (long) futureTasks[i].get();
                res += sum;
            }
            end = System.currentTimeMillis();
            System.out.println("---多线程计算时间" + (end - start));
            System.out.println(res);
        }
    
        static class Task implements Callable<Long> {
        
    
            private int from;
            private int to;
            public Task(int from, int to) {
        
                this.from = from;
                this.to = to;
            }
    
            @Override
            public Long call() throws Exception {
        
                long sum = 0L;
                for (int i = from; i < to; i++) {
        
                    sum += i;
                }
                return sum;
            }
        }
    }

## 六、线程生命周期 ##

生命周期可以通俗地理解为“从摇篮到坟墓”（Cradle-to-Grave）的整个过程。线程的生命周期包括从创建到终结的整个过程。  
JDK中用Thread.State枚举表示了线程的几种状态

public enum State {
        
            /**
             * 尚未启动的线程处于此状态.
             */
            NEW,
    
            /**
             * 在Java虚拟机中执行的线程处于此状态.
             */
            RUNNABLE,
    
            /**
             * 被阻塞等待监视器锁定的线程处于此线程.
             */
            BLOCKED,
    
            /**
             * 正在等待另一个线程执行特定动作的线程处于此状态.
             */
            WAITING,
    
            /**
             * 正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
             */
            TIMED_WAITING,
    
            /**
             * 己退出的线程处于此状态.
             */
            TERMINATED;
        }

其中：`RUNNABLE`中有`Ready`和`Running`两种状态  
![在这里插入图片描述][18edab81ed4148169d23201ab8fac923.png]

[f77d552ef7494688b371e7e2a5bb2774.png]: https://img-blog.csdnimg.cn/f77d552ef7494688b371e7e2a5bb2774.png
[7dc73a0649cf4e028adbdebdd8805cb4.png]: https://img-blog.csdnimg.cn/7dc73a0649cf4e028adbdebdd8805cb4.png
[04a1b4b784c74a5bb9703208bd08b595.png]: https://img-blog.csdnimg.cn/04a1b4b784c74a5bb9703208bd08b595.png
[d84d883ea44e4410885b353ac7e944e2.png]: https://img-blog.csdnimg.cn/d84d883ea44e4410885b353ac7e944e2.png
[b88bac00cb8b497b9842c83c1b1ea45a.png]: https://img-blog.csdnimg.cn/b88bac00cb8b497b9842c83c1b1ea45a.png
[d0aec785f1884a88bb4d1cdeef582ec9.png]: https://img-blog.csdnimg.cn/d0aec785f1884a88bb4d1cdeef582ec9.png
[18edab81ed4148169d23201ab8fac923.png]: https://img-blog.csdnimg.cn/18edab81ed4148169d23201ab8fac923.png