『JAVA多线程·学习之路』-Java多线程

港控/mmm° 2023-09-28 23:25 25阅读 0赞

#### 多线程 ####

*   *   *   *  概念：
             *   *  并发和并行：
                 *  进程和线程：
             *  多线程的实现：
             *   *  方式一：继承Thread类
                 *  方式二：实现Runnable接口
                 *  方式三：Callable和Future
                 *  三种方式的对比：
             *  Thread方法：
             *   *  获取和设置线程的名称
                 *  获得当前线程的对象
                 *  线程休眠
                 *  线程调度
                 *  守护线程/后台线程

##### 概念： #####

多线程是指从软件或者硬件上实现多个线程并发执行的技术。

具有多线程能力的计算机因有硬件支持而能够在同一时间执行多个线程，提升性能。

###### 并发和并行： ######

*  并行：在同一时刻，有多个指令在多个CPU上**同时**执行。

相当于三个厨师同时炒菜：  
![请添加图片描述][820779ce406b4c449f3f2a00855c4c1e.png]

*  并发：在同一时刻，有多个指令在单个CPU上**交替**执行。  
    ![请添加图片描述][631178f79ec44a238d593cb234d0d51c.gif]

###### 进程和线程： ######

进程：是正在运行的软件

*  独立性：进程是一个能独立运行的基本单位，同时是系统分配资源和调度的独立单位。
 *  动态性：进程的实质是程序的一次执行过程，进程是动态产生，动态消亡的。
 *  并发性：任何进程都可以同其他进程一起并发执行。

线程：是进程中的单个顺序控制流，是一条执行路径。（比如：360中的杀毒，扫描木马，清理垃圾等功能）

*  单线程：一个进程如果只有一条执行路径，则称为单线程程序。
 *  多线程：一个进程如果有多条执行路径，则称为多线程程序。

##### 多线程的实现： #####

三种实现方式：

*  继承Thread类的方式进行实现。
 *  实现Runnable接口的方式实现。
 *  利用Callable和Future接口方式实现。

###### 方式一：继承Thread类 ######

*  定义一个类ThreadDemo继承Thread类
 *  在ThreadDemo类中重写run()方法

public class ThreadDemo extends Thread{
        //代码就是线程在开始之后执行的代码
        @Override
        public void run() {
            for(int i = 0; i <5; i++){
                System.out.println("线程开启++==" + i);
            }
        }
    }

*  创建ThreadDemo类的对象
 *  启动线程
 *

public class Demo {
        public static void main(String[] args) {
            ThreadDemo t1 = new ThreadDemo();
            ThreadDemo t2 = new ThreadDemo();
            t1.start();
            t2.start();
        }
    }

**输出：**

线程开启++==0
    线程开启++==0
    线程开启++==1
    线程开启++==1
    线程开启++==2
    线程开启++==2
    线程开启++==3
    线程开启++==3
    线程开启++==4
    线程开启++==4

**注：两个线程在执行时是随机切换的，所以多次执行结果可能会不一样。**

###### 方式二：实现Runnable接口 ######

*  定义一个类MyRunnable实现Runnable接口
 *  在MyRunnable类中重写run()方法

public class MyRunnable implements Runnable{
        @Override
        public void run() {
            //线程启动后执行的代码
            for(int i = 0; i < 20; i++){
                System.out.println("第二种方式实现多线程" + i);
            }
        }
    }

*  创建MyRunnable类的对象
 *  创建Thread类的对象，把MyRunnable对象作为构造方法的参数
 *  
 *  启动线程

public class Demo {
        public static void main(String[] args) {
            //创建了一个参数的对象
            MyRunnable mr = new MyRunnable();
            //创建了一个线程对象，并把参数传递给了这个对象
            //在线程启动之后，执行的就是参数里面的run方法
            Thread t1 = new Thread(mr);
            //开启线程
            t1.start();
    
            MyRunnable mr2 = new MyRunnable();
            Thread t2 = new Thread(mr2);
            t2.start();
        }
    }

**输出：**

第二种方式实现多线程0
    第二种方式实现多线程0
    第二种方式实现多线程1
    第二种方式实现多线程1
    ...
    第二种方式实现多线程17
    第二种方式实现多线程17
    第二种方式实现多线程18
    第二种方式实现多线程19
    第二种方式实现多线程18
    第二种方式实现多线程19

###### 方式三：Callable和Future ######

*  定义一个类MyCallable实现Callable接口
 *  在MyCallable类中重写call()方法

public class MyCallable implements Callable<String> {
        @Override
        public String call() throws Exception {
        for (int i = 1 ; i <= 20; i++){
            System.out.println("跟女孩表白第" + i + "次");
        }
            //返回值就表示线程运行完毕之后的结果。
            return "答应";
        }
    }

*  创建MyCallable类的对象
 *  创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数
 *  创建Thread类的对象，把FutureTask对象作为构造方法的参数
 *  启动线程
 *  再启用FutureTask的get方法获取结果

public class Demo {
        public static void main(String[] args) {
            //线程开启之后需要执行里面的call方法
            MyCallable mc = new MyCallable();
            //可以获取线程执行完毕的看结果，也可以作为参数传递给Thread对象
            FutureTask<String> ft = new FutureTask<>(mc);
            //创建线程对象
            Thread t1 = new Thread(ft);
            //开启线程
            t1.start();
            try {
                String s = ft.get();
                System.out.println(s);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    }

**输出：**

跟女孩表白第1次
    跟女孩表白第2次
    跟女孩表白第3次
    跟女孩表白第4次
    跟女孩表白第5次
    ...
    跟女孩表白第18次
    跟女孩表白第19次
    跟女孩表白第20次
    答应

###### 三种方式的对比： ######

![请添加图片描述][b4d38a4691664f3ea7b967cc7799bd63.png]

##### Thread方法： #####

###### 获取和设置线程的名称 ######

获取线程的名字：

*  String getName() 获取线程的名称

@Override
    public void run() {
        for(int i = 0; i < 20 ; i++){
            System.out.println(getName() + "======" + i);
        }
    }

Thread-0======0
    Thread-1======0
    Thread-0======1
    Thread-1======1
    ...

Thread类中设置线程的名字

*  void setName(String name): 将此线程的名称更改为等于参数name

t1.setName("线程一");
    t2.setName("线程二");

线程一======0
    线程二======0
    线程一======1
    线程二======1
    线程一======2
    线程二======2
    ...

*  通过构造方法也可以设置线程名称

先声明构造方法

public MyThread(String name) {
        super(name);
    }

然后在创建线程时带入参数

MyThread t1 = new MyThread("第一个线程");
    MyThread t2 = new MyThread("第二个线程");

第一个线程======0
    第二个线程======0
    第一个线程======1
    第二个线程======1
    第一个线程======2
    第二个线程======2
    ...

###### 获得当前线程的对象 ######

*  public static Thread currentThread() : 返回当前正在执行的线程对象的引用

String name = Thread.currentThread().getName();
    System.out.println(name);

main

###### 线程休眠 ######

*  public static void sleep(long time) : 让线程休眠指定的时间，单位毫秒。

System.out.println("睡觉");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("醒了");
    }

睡觉
    //两秒后
    醒了

###### 线程调度 ######

**多线程的并发运行：**

计算机中的CPU，在任意时刻只能执行一条机器指令。每个线程只有获得CPU的使用权才能执行代码。

各个线程轮流获得CPU的使用权，分别执行各自的任务。

**线程有两种调度模型**

*  分时调度模型：所有线程**轮流**使用CPU的使用权，平均分配每个线程占用CPU的时间片
 *  抢占式调度模型：优先让优先级高的线程使用CPU，如果线程的优先级一样，那么会随机选择一个，优先级高的线程获取的CPU时间片相对多一些。

Java使用的是抢占式调度模型

**线程的优先级**

*  public final void setPriority(int newPriority) 设置线程的优先级
 *  public final int getPriority() 获取线程的优先级

MyCallable mc = new MyCallable();
            FutureTask<String> ft = new FutureTask<>(mc);
            Thread t1 = new Thread(ft);
            t1.setName("飞机");
            System.out.println(t1.getPriority());
    //        t1.start();
            MyCallable mc2 = new MyCallable();
            FutureTask<String> ft2 = new FutureTask<>(mc2);
            Thread t2 = new Thread(ft2);
            t2.setName("坦克");
            System.out.println(t2.getPriority());

5
    5

设置一下线程优先级

t1.setPriority(7);
    t2.setPriority(10);

线程的优先级高不一定就先执行完，只能说明他抢到CPU执行权的概率更高

###### 守护线程/后台线程 ######

*  public final void setDaemon(boolean on) : 设置为守护线程

MyThread1和MyThread2重写run方法

@Override
    public void run() {
        for(int i = 0 ; i < 20 ; i++){
            System.out.println(getName() + "---" + i);
        }
    }

Demo测试（将MyThread1的循环次数调小（小于20次，越小越明显））

public class Demo {
        public static void main(String[] args) {
            MyThread1 t1 = new MyThread1();
            MyThread2 t2 = new MyThread2();
            t1.setName("女神");
            t2.setName("备胎");
            //把第二个线程设置为守护线程
            //当普通线程执行完毕之后，守护线程也就没有存在下去的必要了
            t2.setDaemon(true);
            t1.start();
            t2.start();
        }
    }

**结果**

女神---0
    女神---1
    备胎---0
    女神---2
    备胎---1
    备胎---2
    备胎---3
    备胎---4
    备胎---5
    备胎---6
    备胎---7
    备胎---8
    备胎---9
    备胎---10
    备胎---11
    备胎---12
    备胎---13

可以看出，在”女神“线程结束之后，守护线程”备胎“在挣扎了几下后也停止了（未达到20次）。

[820779ce406b4c449f3f2a00855c4c1e.png]: https://img-blog.csdnimg.cn/820779ce406b4c449f3f2a00855c4c1e.png
[631178f79ec44a238d593cb234d0d51c.gif]: https://img-blog.csdnimg.cn/631178f79ec44a238d593cb234d0d51c.gif
[b4d38a4691664f3ea7b967cc7799bd63.png]: https://img-blog.csdnimg.cn/b4d38a4691664f3ea7b967cc7799bd63.png