java基础，进阶（四）

努力学习的H同学

于 2022-10-24 16:22:02 发布

阅读量2.7k

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/weixin_48033615/article/details/127386619

版权

38.多线程

1）什么是线程

线程(thread)是一个程序内部的一条执行路径。

我们之前启动程序执行后，main方法的执行其实就是一条单独的执行路径。

程序中如果只有一条执行路径，那么这个程序就是单线程的程序。

2）什么是多线程

多线程是指从软硬件上实现多条执行流程的技术

3）多线程的创建

1] 方式一：继承Thread类

Java是通过java.lang.Thread 类来代表线程的。

按照面向对象的思想，Thread类应该提供了实现多线程的方式。

①实现方式：

定义一个子类MyThread继承线程类java.lang.Thread，重写run()方法

创建MyThread类的对象new一个

调用线程对象的start()方法启动线程（启动后还是执行run方法的）

package com.itheima.d1_create;

//目标：多线程的创建方式一：继承Thread类实现。
public class ThreadDemo1 {
    public static void main(String[] args) {
        // 3、new一个新线程对象
        Thread t = new MyThread();//多态的写法
        // 4、调用start方法启动线程（执行的还是run方法）
        t.start();

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

//在以后的开发中要分开定义，这里为了方便写在了一起
//1、定义一个线程类继承Thread类
class MyThread extends Thread{
    //2、重写run方法，里面是定义线程以后要干啥
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行输出：" + i);
        }
    }
}

②优缺点

优点：编码简单

缺点：线程类已经继承Thread，无法继承其他类，不利于扩展。

③为什么不直接调用了run方法，而是调用start启动线程

直接调用run方法会当成普通方法执行，此时相当于还是单线程执行。

只有调用start方法才是启动一个新的线程执行。

④不要把主线程任务放在子线程之前

这样主线程一直是先跑完的，相当于是一个单线程的效果了。

2] 方式二：实现Runnable接口

①实现方式：

定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法

创建MyRunnable任务对象

把MyRunnable任务对象交给Thread处理。

调用线程对象的start()方法启动线程

package com.itheima.d1_create;

//目标：学会线程的创建方式二，理解它的优缺点。
public class ThreadDemo2 {
    public static void main(String[] args) {
        // 3、创建一个任务对象
        Runnable target = new MyRunnable();
        // 4、把任务对象交给Thread处理
        Thread t = new Thread(target);
        // Thread t = new Thread(target, "1号");
        // 5、启动线程
        t.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("主线程执行输出：" + i);
        }
    }
}

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

②优缺点

优点：线程任务类只是实现Runnable接口，可以继续继承类和实现接口，扩展性强。

缺点：编程多一层对象包装，如果线程有执行结果是不可以直接返回的。

③多线程的实现方案二：实现Runnable接口(匿名内部类形式)

可以创建Runnable的匿名内部类对象。

交给Thread处理。

调用线程对象的start()启动线程。

package com.itheima.d1_create;

//目标：学会线程的创建方式二(匿名内部类方式实现，语法形式)
public class ThreadDemo2Other {
    public static void main(String[] args) {
        Runnable target = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("子线程1执行输出：" + i);
                }
            }
        };
        Thread t = new Thread(target);
        t.start();

        //简化写法
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("子线程2执行输出：" + i);
                }
            }
        }).start();

        //再简化
        new Thread(() -> {
                for (int i = 0; i < 10; i++) {
                    System.out.println("子线程3执行输出：" + i);
            }
        }).start();

        for (int i = 0; i < 10; i++) {
            System.out.println("主线程执行输出：" + i);
        }
    }
}

3] 方式三：JDK 5.0新增：实现Callable接口

①前2种线程创建方式都存在一个问题：

他们重写的run方法均不能直接返回结果。

不适合需要返回线程执行结果的业务场景。

②怎么解决这个问题呢？

JDK 5.0提供了Callable和FutureTask来实现。

这种方式的优点是：可以得到线程执行的结果。

③多线程的实现方案三：利用Callable、FutureTask接口实现

得到任务对象

定义类实现Callable接口，重写call方法，封装要做的事情。

用FutureTask把Callable对象封装成线程任务对象。

把线程任务对象交给Thread处理。

调用Thread的start方法启动线程，执行任务

线程执行完毕后、通过FutureTask的get方法去获取任务执行的结果。

④优缺点

优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。

可以在线程执行完毕后去获取线程执行的结果。

缺点：编码复杂一点。

package com.itheima.d1_create;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

//目标：学会线程的创建方式三：实现Callable接口，结合FutureTask完成。
public class ThreadDemo3 {
    public static void main(String[] args) {
        // 3、创建Callable任务对象
        Callable<String> call = new MyCallable(100);
        // 4、把Callable任务对象 交给 FutureTask 对象
        //  FutureTask对象的作用1： 是Runnable的对象（实现了Runnable接口），可以交给Thread了
        //  FutureTask对象的作用2： 可以在线程执行完毕之后通过调用其get方法得到线程执行完成的结果
        FutureTask<String> f1 = new FutureTask<>(call);
        //call不是线程对象 直接写Thread t = new Thread(call);会报错
        // 5、交给线程处理
        Thread t1 = new Thread(f1);
        // 6、启动线程
        t1.start();

        //再启动一个任务 
        Callable<String> call2 = new MyCallable(200);
        FutureTask<String> f2 = new FutureTask<>(call2);
        Thread t2 = new Thread(f2);
        t2.start();

        try {
            // 如果f1任务没有执行完毕，这里的代码会等待，直到线程1跑完才提取结果。
            String rs1 = f1.get();
            System.out.println("第一个结果：" + rs1);
        } catch (Exception e) {
            e.printStackTrace();
        }

        try {
            // 如果f2任务没有执行完毕，这里的代码会等待，直到线程2跑完才提取结果。
            String rs2 = f2.get();
            System.out.println("第二个结果：" + rs2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

//1、定义一个任务类 实现Callable接口  应该申明线程任务执行完毕后的结果的数据类型
class MyCallable implements Callable<String>{
    private int n;
    public MyCallable(int n) { this.n = n; }

    //2、重写call方法（任务方法）
    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= n ; i++) {
            sum += i;
        }
        return "子线程执行的结果是：" + sum;
    }
}

4）Thread的常用方法

1] Thread常用方法

获取线程名称getName()、设置名称setName()、获取当前线程对象currentThread()。

至于Thread类提供的诸如：yield、join、interrupt、不推荐的方法 stop 、守护线程、线程优先级等线程的控制方法，在开发中很少使用，这些方法会在高级篇以及后续需要用到的时候再为大家讲解。

2] 当有很多线程在执行的时候，区分线程的方法需要使用Thread的常用方法：getName()、setName()、currentThread()等。

package com.itheima.d2_api;
// 目标：线程的API
public class ThreadDemo01 {
    // main方法是由主线程负责调度的
    public static void main(String[] args) {
        Thread t1 = new MyThread("1号");
        // Thread t1 = new MyThread();无参构造器需要写两行代码
        // t1.setName("1号");
        t1.start();
        System.out.println(t1.getName());

        Thread t2 = new MyThread("2号");
        // t2.setName("2号");
        t2.start();
        System.out.println(t2.getName());

        // 哪个线程执行它，它就得到哪个线程对象（当前线程对象）
        // 主线程的名称就叫main
        Thread m = Thread.currentThread();
        System.out.println(m.getName());
        m.setName("最牛的线程");

        for (int i = 0; i < 5; i++) {
            System.out.println( m.getName() + "输出：" + i);
        }
    }
}
/*——————————————————————————————————————————————————————————*/
package com.itheima.d2_api;

public class MyThread extends Thread{
    public MyThread() { }

    public MyThread(String name) {
        // 为当前线程对象设置名称，送给父类的有参数构造器初始化名称
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println( Thread.currentThread().getName() + "输出：" + i);
        }
    }
}

/*———————————————Thread类的线程休眠方法———————————————————————————————————————*/
package com.itheima.d2_api;
//目标：线程的API
public class ThreadDemo02 {
    // main方法是由主线程负责调度的
    public static void main(String[] args) throws Exception {
        for (int i = 1; i <= 5; i++) {
            System.out.println("输出：" + i);
            if(i == 3){
                // 让当前线程进入休眠状态
                // 段子：项目经理让我加上这行代码，如果用户愿意交钱，我就注释掉。
                Thread.sleep(3000);
            }
        }
    }
}

5）线程安全

多个线程同时操作同一个共享资源的时候可能会出现业务安全问题，称为线程安全问题。

线程安全问题出现的原因？存在多线程并发、同时访问共享资源、存在修改共享资源

package com.itheima.d3_thread_safe;

//需求：模拟取钱案例。
public class ThreadDemo {
    public static void main(String[] args) {
        // 1、定义线程类，创建一个共享的账户对象
        Account acc = new Account("ICBC-111", 100000);

        // 2、创建2个线程对象，代表小明和小红同时进来了。
        new DrawThread(acc, "小明").start();
        new DrawThread(acc, "小红").start();
    }
}

/*——————————————————账户类————————————————*/
package com.itheima.d3_thread_safe;

public class Account {
    private String cardId;
    private double money; // 账户的余额

    public Account(){ }

    public Account(String cardId, double money) {
        this.cardId = cardId;
        this.money = money;
    }

    //小明 小红
    public void drawMoney(double money) {
        // 0、先获取是谁来取钱，线程的名字就是人名
        String name = Thread.currentThread().getName();
        // 1、判断账户是否够钱
        if(this.money >= money){//this.money账户中的余额，money要取的钱
            // 2、取钱
            System.out.println(name + "来取钱成功，吐出：" + money);
            // 3、更新余额
            this.money -= money;
            System.out.println(name + "取钱后剩余：" + this.money);
        }else {
            // 4、余额不足
            System.out.println(name +"来取钱，余额不足！");
        }

    }

    public String getCardId() {
        return cardId;
    }

    public void setCardId(String cardId) {
        this.cardId = cardId;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

}
/*——————————取钱的线程类——————————————————————————*/
package com.itheima.d3_thread_safe;

//取钱的线程类
public class DrawThread extends Thread {
    // 接收处理的账户对象
    private Account acc;
    public DrawThread(Account acc,String name){
        super(name);
        this.acc = acc;
    }
    @Override
    public void run() {
        // 小明 小红：取钱
        acc.drawMoney(100000);
    }
}

6）线程同步

1] 思想概述

取钱案例出现问题的原因？多个线程同时执行，发现账户都是够钱的。

如何才能保证线程安全呢？让多个线程实现先后依次访问共享资源，这样就解决了安全问题

线程同步解决安全问题的思想：加锁

（把共享资源进行上锁，每次只能一个线程进入访问完毕以后解锁，然后其他线程才能进来。

让多个线程实现先后依次访问共享资源，这样就解决了安全问题。）

2] 方式一：同步代码块

①作用：把出现线程安全问题的核心代码给上锁。

②原理：每次只能一个线程进入，执行完毕后自动解锁，其他线程才可以进来执行

③锁对象要求：理论上，锁对象只要对于当前同时执行的线程来说是同一个对象即可。

④锁对象用任意唯一的对象好不好呢?不好，会影响其他无关线程的执行。

⑤锁对象的规范要求：

规范上：建议使用共享资源作为锁对象。（用账户）

对于实例方法建议使用this作为锁对象。

对于静态方法建议使用字节码（类名.class）对象作为锁对象。

⑥同步代码块是如何实现线程安全的？

对出现问题的核心代码使用synchronized进行加锁、每次只能一个线程占锁进入访问

3] 方式二：同步方法

①作用：把出现线程安全问题的核心方法给上锁。

②原理：每次只能一个线程进入，执行完毕以后自动解锁，其他线程才可以进来执行。

③同步方法底层原理

同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。

如果方法是实例方法：同步方法默认用this作为的锁对象。但是代码要高度面向对象！

如果方法是静态方法：同步方法默认用类名.class作为的锁对象。

④同步代码块锁的范围更小，同步方法锁的范围更大，范围越小，性能能更好一点，但是在实际应用中可能更多用到同步方法，因为同步方法写法更方便，而且性能差的不是很多

package com.itheima.d4_thread_synchronized_code;

//账户类：余额，卡号
public class Account {
    private String cardId;
    private double money; // 余额 关键信息

    public Account() { }

    public Account(String cardId, double money) {
        this.cardId = cardId;
        this.money = money;
    }

    public String getCardId() {
        return cardId;
    }

    public void setCardId(String cardId) {
        this.cardId = cardId;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    /*对于静态方法建议使用字节码（类名.class）对象作为锁对象
    // 100个线程人，但是每次只有一个人能锁这个类
    public static void run(){
        synchronized (Account.class){
        }
    }*/

    //同步代码块
    //小明 小红
    public void drawMoney(double money) {
        // 1、拿到是谁来取钱
        String name = Thread.currentThread().getName();
        // 同步代码块
        /* 要声明一个锁对象，对于这两个线程是唯一的就可以了,字符串自变量在常量池中给出来就只有一个synchronized ("heima")，所以小明和小红进来都拿到的是同一对象，满足锁的唯一性，可以作为锁，没有意义只是一个代表做个控制
           不能用任意唯一对象的原因：如果有另一家人(比如是小白和小黑)的出现，还是这种常量"heima"的话在小明取钱的时候，小红，小白小黑都要等着*/
        // 小明 小红
        // this == acc 共享账户
        synchronized (this) {//ctrl + alt + t 快捷键
            // 2、判断余额是否足够
            if(this.money >= money){
                // 钱够了
                System.out.println(name+"来取钱，吐出：" + money);
                // 更新余额
                this.money -= money;
                System.out.println(name+"取钱后，余额剩余：" + this.money);
            }else{
                // 3、余额不足
                System.out.println(name+"来取钱，余额不足！");
            }
        }
    }

    //同步方法
    public synchronized void drawMoney(double money) {
        // 1、拿到是谁来取钱
        String name = Thread.currentThread().getName();
        // 2、判断余额是否足够
        // 小明  小红
        if(this.money >= money){
            // 钱够了
            System.out.println(name+"来取钱，吐出：" + money);
            // 更新余额
            this.money -= money;
            System.out.println(name+"取钱后，余额剩余：" + this.money);
        }else{
            // 3、余额不足
            System.out.println(name+"来取钱，余额不足！");
        }
    }
}

package com.itheima.d4_thread_synchronized_code;

//线程类
public class DrawThread extends Thread{
    private Account acc;
    public DrawThread(Account acc, String name){
        super(name);
        this.acc = acc;
    }

    @Override
    public void run() {
        // 小明 小红  ： acc
        acc.drawMoney(100000);
    }
}

package com.itheima.d4_thread_synchronized_code;

public class TestSafeDemo {
    public static void main(String[] args) {
        // 测试线程安全问题
        // 1、创建一个共享的账户对象。
        Account acc = new Account("ICBC-111" , 100000);

        // 2、创建2个线程对象，操作同一个账户对象
        new DrawThread(acc, "小明").start();
        new DrawThread(acc,"小红").start();
    }
}

4] lock锁

package com.itheima.d6_thread_synchronized_lock;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
    账户类：余额 , 卡号。
 */
public class Account {
    private String cardId;
    private double money; // 余额 关键信息
    // final修饰后：锁对象是唯一和不可替换的，非常专业
    private final Lock lock = new ReentrantLock();//定义一个实例的

    public Account() {
    }

    public Account(String cardId, double money) {
        this.cardId = cardId;
        this.money = money;
    }

    public String getCardId() {
        return cardId;
    }

    public void setCardId(String cardId) {
        this.cardId = cardId;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    //小明 小红

    public void drawMoney(double money) {
        // 1、拿到是谁来取钱
        String name = Thread.currentThread().getName();
        // 2、判断余额是否足够
        // 小明  小红
        lock.lock(); // 上锁
        try {
            if(this.money >= money){
                // 钱够了
                System.out.println(name+"来取钱，吐出：" + money);
                // 更新余额
                this.money -= money;
                System.out.println(name+"取钱后，余额剩余：" + this.money);
            }else{
                // 3、余额不足
                System.out.println(name+"来取钱，余额不足！");
            }
        } finally {
            lock.unlock(); // 解锁
        }
    }
}

7）线程通信（了解）

1] 什么是线程通信、如何实现？

所谓线程通信就是线程间相互发送数据，线程间共享一个资源即可实现线程通信。

2] 线程通信常见形式

通过共享一个数据的方式实现。

根据共享数据的情况决定自己该怎么做，以及通知其他线程怎么做。

3] 线程通信实际应用场景

生产者与消费者模型：生产者线程负责生产数据，消费者线程负责消费生产者产生的数据。

要求：生产者线程生产完数据后唤醒消费者，然后等待自己，消费者消费完该数据后唤醒生产者，然后等待自己。

/*线程通信的知识点并没有讲*/
package com.itheima.d7_thread_comunication;

public class TestDemo {
    public static void main(String[] args) {
        // 1、生产者线程：负责不断接收打进来的电话
        CallThread call = new CallThread();
        call.start();

        // 2、消费者线程：客服，每个客服每次接听一个电话
        ReceiveThread r1 = new ReceiveThread();
        r1.start();
    }
}

/*————————————————————————————————————————————————*/
package com.itheima.d7_thread_comunication;
//接电话线程类
public class ReceiveThread extends Thread{
    @Override
    public void run() {
        // 1号  2号
        while (true){
            CallSystem.receive();
        }
    }
}
/*————————————————————————————————————————————————*/
package com.itheima.d7_thread_comunication;
public class CallThread extends Thread{
    @Override
    public void run() {
        // 不断的打入电话
        while (true){
            CallSystem.call();
        }
    }
}
/*————————————————————————————————————————————————*/
package com.itheima.d7_thread_comunication;

//呼叫系统。
public class CallSystem {
    // 定义一个变量记录当前呼入进来的电话。
    public static int number = 0; // 最多只接听一个。

    /* 接入电话
     */
    public synchronized static void call() {
        try {
            number++;
            System.out.println("成功接入一个用户，等待分发~~~~");

            // 唤醒别人 : 1个
            CallSystem.class.notify();
            // 让当前线程对象进入等待状态。
            CallSystem.class.wait();

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //分发电话
    public synchronized static void receive() {
        try {
            String name = Thread.currentThread().getName();
            if(number == 1){
                System.out.println(name + "此电话已经分发给客服并接听完毕了~~~~~");
                number--;
                // 唤醒别人 : 1个
                CallSystem.class.notify();
                CallSystem.class.wait(); // 让当前线程等待
            }else {
                // 唤醒别人 : 1个
                CallSystem.class.notify();
                CallSystem.class.wait(); // 让当前线程等待
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

8）线程池(重点)

1] 概述

线程池就是一个可以复用线程的技术。

不使用线程池的问题：如果用户每发起一个请求，后台就创建一个新线程来处理，下次新任务来了又要创建新线程，而创建新线程的开销是很大的，这样会严重影响系统的性能。

2] 实现的API、参数说明

①JDK 5.0起提供了代表线程池的接口：ExecutorService，代表线程池

②如何得到线程池对象

③面试题

临时线程什么时候创建啊？

新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程。

什么时候会开始拒绝任务？

核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始任务拒绝。

3] 处理Runnable任务

package com.itheima.d8_threadpool;

import java.util.concurrent.*;

//目标：自定义一个线程池对象，并测试其特性。
public class ThreadPoolDemo1 {
    public static void main(String[] args) {
        // 1、创建线程池对象
        /**
         public ThreadPoolExecutor(int corePoolSize,
                                 int maximumPoolSize,
                                 long keepAliveTime,
                                 TimeUnit unit,
                                 BlockingQueue