【Java从入门到大牛】多线程

最新推荐文章于 2024-11-11 00:03:55 发布
最新推荐文章于 2024-11-11 00:03:55 发布
阅读量260 收藏
点赞数
分类专栏： Java从入门到大牛 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62511863/article/details/133632610
版权

🔥 本文由 程序喵正在路上 原创，CSDN首发！
💖 系列专栏：Java从入门到大牛
🌠 首发时间：2023年11月18日
🦋 欢迎关注🖱点赞👍收藏🌟留言🐾

目录

多线程的创建

方式一：继承Thread类

什么是线程？

线程（Thread）是一个程序内的一条执行流程，比如常见的 main 方法就是一个线程

public static void main(String[] args) {
	// 代码...
	for(int i = 0; i <10; i++) {
		System.out.println(i);
	}
	//...
}

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

什么是多线程？

多线程是指从软硬件上实现的多条执行流程的技术（多条线程由 CPU 负责调度执行）

多线程的用处

在生活中，有很多多线程应用的例子，比如，12306网站同时有多位用户在抢票，那么网站就需要提供多条线程来为多位用户服务；在使用百度网盘时，用户可能同时需要上传和下载资源，这也需要用到多线程技术；再比如消息通信、淘宝、京东系统都离不开多线程技术

如果在程序中创建出多条线程呢？

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

多线程的创建方式一：继承Thread类

  1. 定义一个子类 MyThread 继承线程类 java.lang.Thread，并重写 run() 方法
  2. 创建 MyThread 类的对象
  3. 调用线程对象的 start() 方法启动线程，这个方法会自动执行 run() 方法

代码实现

MyThread类

/**
 * 1. 让子类继承Thread线程类
 */
public class MyThread extends Thread {
    @Override   // 2. 必须重写Thread类的run方法
    public void run() {
        // 这里用来描述线程要执行的任务
        for (int i = 1; i <= 5; i++) {
            System.out.println("子线程MyThread输出：" + i);
        }
    }
}

测试类

/**
 * 目标：掌握线程的创建方式一:继承Thread类
 */
public class ThreadTest1 {
    // main方法是由一条默认的主线程负责执行的
    public static void main(String[] args) {
        // 3. 创建MyThread线程类的对象代表一个线程
        Thread t = new MyThread();  // 多态写法

        // 4. 启动线程，必须是调用start方法
        t.start();  // 启动后，现在就存在两个线程：main线程和t线程

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

因为有两个线程，线程执行的顺序也不确定，所有每次执行结果都可能不同

在这里插入图片描述

方法一优缺点：

  • 优点：编码简单
  • 缺点：线程类已经继承 Thread 类，所以无法再继承其他类，不利于功能的扩展

多线程的注意事项

1、启动线程必须是调用 start 方法，不能调用 run 方法

  • 直接调用 run 方法会当成普通方法执行，此时相当于还是单线程执行
  • 只有调用 start 方法才是启动一个新的线程执行

2、不要把主线程任务放在启动子线程之前

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

方式二：实现Runnable接口

多线程的创建方式二：实现Runnable接口

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

  2. 创建 MyRunnable 任务对象

  3. 把 MyRunnable 任务对象交给 Thread 处理
    在这里插入图片描述

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

代码实现

MyRunnable类

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

测试类

/**
 * 目标：掌握多线程的创建方式二：实现Runnable接口
 */
public class ThreadTest2 {
    public static void main(String[] args) {
        // 3.创建任务对象
        Runnable target = new MyRunnable();
        // 4.把任务对象交给一个线程对象处理
        new Thread(target).start();

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

方式二的优缺点

  • 优点：任务类只是实现接口，可以继承其他类、实现其他接口，扩展性强
  • 缺点：需要多一个 Runnable 对象

线程创建方式二的匿名内部类写法

  1. 可以创建 Runnable 的匿名内部类对象
  2. 再交给 Thread 线程对象
  3. 再调用线程对象的 start() 启动线程

匿名内部类写法实现

/**
 * 目标：掌握多线程创建方式二的匿名内部类写法
 */
public class ThreadTest2_2 {
    public static void main(String[] args) {
        // 1、直接创建Runnable接口的匿名内部类形式（任务对象）
        Runnable target = new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.println("子线程1输出：" + i);
                }
            }
        };
        new Thread(target).start();

        // 简化形式1：
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.println("子线程2输出：" + i);
                }
            }
        }).start();

        // 简化形式2：
        new Thread(() -> {
                for (int i = 1; i <= 5; i++) {
                    System.out.println("子线程3输出：" + i);
                }
        }).start();

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

方式三：实现Callable接口

前两种线程创建方式都存在一个问题：假如线程执行完毕后有一些数据需要返回，他们重写的 run 方法均不能返回结果

怎么解决这个问题？

  • JDK5.0 提供了 Callable 接口和 FutureTask 来实现
  • 这种方式最大的优点就是可以返回线程执行完毕后的结果

多线程的第三种创建方式：利用Callable接口和FutureTask类来实现

1、创建任务对象

  • 定义一个类实现 Callable 接口，并重写 call 方法，里面封装要做的事情和要返回的数据
  • 把 Callable 类型的对象封装成 FutureTask（线程任务对象）

2、把线程任务对象交给 Thread 对象

3、调用 Thread 对象的 start 方法启动线程

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

FutureTask的API

在这里插入图片描述
代码实现

MyCallable类

import java.util.concurrent.Callable;

/**
 * 1、让这个类实现Callable接口
 */
public class MyCallable implements Callable<String> {
    private int n;
    public MyCallable(int n) {
        this.n = n;
    }

    // 2、重写call方法
    @Override
    public String call() throws Exception {
        // 描述线程的任务，返回线程执行返回后的结果
        // 需求：求1-n的和并返回
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return "线程求出了1-" + n + "的和是：" + sum;
    }
}

测试类

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

/**
 * 目标：掌握线程的创建方式三：实现Callable接口
 */
public class ThreadTest3 {
    public static void main(String[] args) throws Exception {
        // 3、创建一个Callable的对象
        Callable<String> call = new MyCallable(100);
        // 4、把Callable的对象封装成一个FutureTask对象（任务对象）
        // 未来任务对象的作用？
        // 1、是一个任务对象，实现了Runnable对象
        // 2、可以在线程执行完毕之后，用未来任务对象调用get方法获取线程执行完毕后的结果
        FutureTask<String> f1  = new FutureTask<>(call);
        // 5、把任务对象交给一个Thread对象
        new Thread(f1).start();

        Callable<String> call2 = new MyCallable(200);
        FutureTask<String> f2  = new FutureTask<>(call2);
        new Thread(f2).start();

        // 6、获取线程执行完毕后返回的结果
        // 注意：如果执行到这儿，假如上面的线程还没有执行完毕
        // 这里的代码会暂停，等待上面线程执行完毕后才会获取结果
        String rs = f1.get();
        System.out.println(rs);

        String rs2 = f2.get();
        System.out.println(rs2);
    }
}

在这里插入图片描述

线程创建方式三的优缺点

  • 优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强；可以在县城执行完毕后去获取线程执行的结果
  • 缺点：编码复杂一点

Thread的常见方法

Thread 提供了很多与线程操作相关的方法
在这里插入图片描述

应用演示

MyThread类

public class MyThread extends Thread {
    public MyThread(String name) {
        super(name);    // 为当前线程设置名字
    }
    @Override
    public void run() {
        // 获取当前线程对象
        Thread t = Thread.currentThread();
        for (int i = 1; i <= 3; i++) {
            System.out.println(t.getName() + "输出：" + i);
        }
    }
}

测试类1

/**
 * 目标：掌握Thread的常用方法
 */
public class ThreadTest1 {
    public static void main(String[] args) {
        Thread t1 = new MyThread("1号线程");
        t1.start();
        System.out.println(t1.getName());   // Thread-0

        Thread t2 = new MyThread("2号线程");
        t2.start();
        System.out.println(t2.getName());   // Thread-1

        //获取主线程对象的名字
        Thread m = Thread.currentThread();
        m.setName("main主线程");
        System.out.println(m.getName());

        for (int i = 1; i <= 5; i++) {
            System.out.println(m.getName() + "输出：" + i);
        }
    }
}

在这里插入图片描述

测试类2

/**
 * 目标：掌握sleep方法,join方法的作用
 */
public class ThreadTest2 {
    public static void main(String[] args) throws Exception {
        for (int i = 1; i <= 5; i++) {
            System.out.println(i);
            // 休眠5s
            if(i == 3){
                // 让当前执行的线程暂停5秒，再继续执行
                 Thread.sleep(5000);
            }
        }

        // join方法作用：让当前调用这个方法的线程先执行完再执行其他线程
        Thread t1 = new MyThread("1号线程");
        t1.start();
        t1.join();

        Thread t2 = new MyThread("2号线程");
        t2.start();
        t2.join();

        Thread t3 = new MyThread("3号线程");
        t3.start();
        t3.join();
    }
}

在这里插入图片描述

Thread其他方法的说明

Thread 类还提供了诸如：yield、interrupt、守护线程、线程优先级等线程的控制方法，在开发中很少使用，在这里就不一一列出了

线程安全

什么是线程安全问题

什么是线程安全问题？

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

取钱的线程安全问题

场景：小明和小红是一对夫妻，他们有一个共同的账户，余额是10万元，如果小明和小红同时来取钱，并且2人各自都在取钱10万元，可能会出现什么问题呢？

有可能会出现2人都成功取钱10万元的结果

用程序模拟线程安全问题

需求

小明和小红是一对夫妻，他们有一个共同的账户，余额是10万元，模拟2人同时去取钱10万元

分析

  1. 需要提供一个账户类，接着创建一个账户对象代表2个人的共享账户
  2. 需要定义一个线程类（用于创建两个线程，分别代表小明和小红）
  3. 创建两个线程，传入同一个账户对象给两个线程处理
  4. 启动两个线程，同时去同一个账户对象中取钱10万元

代码实现

账户类

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) {
        // 先搞清楚是谁来取钱？
        String name = Thread.currentThread().getName();
        // 1、判断余额是否足够
        if(this.money >= money){
            System.out.println(name + "来取钱" + money + "成功！");
            this.money -= money;
            System.out.println(name + "来取钱后，余额剩余：" + this.money);
        }else {
            System.out.println(name + "来取钱：余额不足~");
        }
    }

    // get、set方法
    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 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);  // 取钱
    }
}

测试类

/**
 * 目标：模拟线程安全问题
 */
public class ThreadTest {
    public static void main(String[] args) {
         // 1、创建一个账户对象，代表两个人的共享账户
        Account acc = new Account("ICBC-110", 100000);

        // 2、创建两个线程，分别代表小明 小红，再去同一个账户对象中取钱10万
        new DrawThread(acc, "小明").start(); // 小明
        new DrawThread(acc, "小红").start(); // 小红
    }
}

在这里插入图片描述

线程同步

认识线程同步

线程同步

解决线程安全问题的方案

线程同步的思想

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

线程同步的常见方案

加锁：每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动解锁，然后其他线程才能再加锁进来

方式一：同步代码块

同步代码块

作用：把访问共享资源的核心代码给上锁，以此保证线程安全

synchronized(同步锁) {
	访问共享资源的核心代码
}

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

同步锁的注意事项

对于当前同时执行的线程来说，同步锁必须是同一把（同一个对象），否则会出bug

同步代码块的实现

IDEA里加同步锁的快捷方式：鼠标选中要上锁的核心代码，按住 Ctrl+Alt+T，然后选择第9项 synchronized 即可

依旧是前面那个取钱的例子，我们只需要将账户类稍微修改一下即可，代码如下

public class Account {
    private String cardId; // 卡号
    private double money; // 余额

    // ...

    // 取钱
    public void drawMoney(double money) {
        // 先搞清楚是谁来取钱？
        String name = Thread.currentThread().getName();
        // 1、判断余额是否足够
        // this正好代表共享资源！
        synchronized (this) {
            if(this.money >= money){
                System.out.println(name + "来取钱" + money + "成功！");
                this.money -= money;
                System.out.println(name + "来取钱后，余额剩余：" + this.money);
            }else {
                System.out.println(name + "来取钱：余额不足~");
            }
        }
    }

    // 如果是静态方法，建议使用 类名.class 作为锁
    public static void test(){
        synchronized (Account.class){

        }
    }

    // ...
}

在这里插入图片描述

问题：锁对象随便选择一个唯一的对象好不好呢？

不好，可能会影响其他无关线程的执行

锁对象的使用规范

  • 建议使用共享资源作为锁对象，对于实例方法建议使用 this 作为锁对象
  • 对于静态方法建议使用字节码（类名.class）对象作为锁对象

方式二：同步方法

同步方法

作用：把访问共享资源的核心方法给上锁，以此保证线程安全

修饰符 synchronized 返回值类型 方法名称(形参列表) {
	操作共享资源的代码
}

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

同步方法底层原理

  • 同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码
  • 如果方法是实例方法：同步方法默认用 this 作为锁对象
  • 如果方法是静态方法：同步方法默认用 类名.class 作为锁对象

同步方法代码实现

账户类修改如下

public class Account {
    private String cardId; // 卡号
    private double money; // 余额

    // ...
    
    // 同步方法
    public synchronized void drawMoney(double money) {
        // 先搞清楚是谁来取钱？
        String name = Thread.currentThread().getName();
        // 1、判断余额是否足够
        if(this.money >= money){
            System.out.println(name + "来取钱" + money + "成功！");
            this.money -= money;
            System.out.println(name + "来取钱后，余额剩余：" + this.money);
        }else {
            System.out.println(name + "来取钱：余额不足~");
        }
    }

    // ...
}

方式三：Lock锁

Lock锁

  • Lock锁是JDK5开始提供的一个新的锁定操作，通过它可以创建出锁对象进行加锁和解锁，更灵活、更方便、更强大

  • Lock是接口，不能直接实例化，可以采用它的实现类ReentrantLock来构建Lock锁对象

    在这里插入图片描述

Lock的常用方法
在这里插入图片描述

Lock锁代码实现

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Account {
    private String cardId; // 卡号
    private double money; // 余额
    // 创建了一个锁对象
    private final Lock lk = new ReentrantLock();

    // ...

    // 小明 小红线程同时过来的
    public void drawMoney(double money) {
        // 先搞清楚是谁来取钱？
        String name = Thread.currentThread().getName();
        
        // 为了防止try里面的代码块出现异常而导致无法解锁，
        // 我们需要对其进行异常处理，并将解锁操作放到finally里面
        try {
            lk.lock(); // 加锁
            // 1、判断余额是否足够
            if(this.money >= money){
                System.out.println(name + "来取钱" + money + "成功！");
                this.money -= money;
                System.out.println(name + "来取钱后，余额剩余：" + this.money);
            }else {
                System.out.println(name + "来取钱：余额不足~");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lk.unlock(); // 解锁
        }
    }

    // ...
}

线程通信【了解】

什么是线程通信？

当多个线程共同操作共享的资源时，线程间通过某种方式互相告知自己的状态，以相互协调，并避免无效的资源争夺

线程通信的常见模型（生产者与消费者模型）

  • 生产者线程负责生产数据
  • 消费者线程负责消费生产者生产的数据
  • 注意：生产者生产完数据应该等待自己，通知消费者消费；消费者消费完也应该等待自己，再通知生产者生产

Object类的等待和唤醒方法
在这里插入图片描述

注意：上述方法应该使用当前同步锁对象进行调用

为了更好地理解生产者与消费者模型，我们来看一个例子：

  • 3个生产者线程，负责生产包子，每个线程每次只能生产1个包子放在桌子上
  • 2个消费者线程负责吃包子，每人每次只能从桌子上拿1个包子吃
  • 同一时刻，只能有一个生产者生产包子，或只能有一个消费者吃包子

代码实现

桌子类

import java.util.ArrayList;
import java.util.List;

public class Desk {
    private List<String> list = new ArrayList<>();

    // 放1个包子的方法
    // 厨师1 厨师2 厨师3
    public synchronized void put() {
        try {
            String name = Thread.currentThread().getName();
            // 判断是否有包子
            if(list.size() == 0){
                list.add(name + "做的肉包子");   // 没有包子，生产包子
                System.out.println(name + "做了一个肉包子~~");
                Thread.sleep(2000);

                // 先唤醒别人, 再等待自己，顺序不能错
                this.notifyAll();
                this.wait();
            }else {
                // 有包子了，不做了。
                // 唤醒别人, 等待自己
                this.notifyAll();
                this.wait();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 吃货1 吃货2
    public synchronized void get() {
        try {
            String name = Thread.currentThread().getName();
            if(list.size() == 1){
                // 有包子，吃了
                System.out.println(name  + "吃了：" + list.get(0));
                list.clear();
                Thread.sleep(1000);
                this.notifyAll();
                this.wait();
            }else {
                // 没有包子
                this.notifyAll();
                this.wait();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

测试类

/**
 * 目标：了解一下线程通信
 */
public class ThreadTest {
    public static void main(String[] args) {
        //   需求：3个生产者线程，负责生产包子，每个线程每次只能生产1个包子放在桌子上
        //      2个消费者线程负责吃包子，每人每次只能从桌子上拿1个包子吃
        Desk desk  = new Desk();

        // 创建3个生产者线程（3个厨师）
        new Thread(() -> {
            while (true) {
                desk.put();
            }
        }, "厨师1").start();

        new Thread(() -> {
            while (true) {
                desk.put();
            }
        }, "厨师2").start();

        new Thread(() -> {
            while (true) {
                desk.put();
            }
        }, "厨师3").start();

        // 创建2个消费者线程（2个吃货）
        new Thread(() -> {
            while (true) {
                desk.get();
            }
        }, "吃货1").start();

        new Thread(() -> {
            while (true) {
                desk.get();
            }
        }, "吃货2").start();
    }
}

在这里插入图片描述

线程池

认识线程池

什么是线程池？

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

不使用线程池的问题

用户每发起一个请求，系统后台就需要创建一个新线程来处理，这样下次有新任务来了又要创建新线程来处理，而创建新线程的开销是很大的，并且请求过多时，肯定会产生大量的线程出来，这样会严重影响系统的性能

线程池的工作原理
在这里插入图片描述

创建线程池

Java中谁代表线程池？

JDK5.0 起提供了代表线程池的接口：ExecutorService

如何得到线程池对象？

  • 方式一：使用 ExecutorService 的实现类 ThreadPoolExecutor 自创建一个线程池对象
  • 方式二：使用 Executors（线程池的工具类）调用方法返回不同特点的线程池对象

ThreadPoolExecutor的构造器

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
							BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory,
							RejectedExecutionHandler handler)
  • 参数一：corePoolSize : 指定线程池的核心线程的数量
  • 参数二：maximumPoolSize：指定线程池的最大线程数量
  • 参数三：keepAliveTime ：指定临时线程的存活时间
  • 参数四：unit：指定临时线程存活的时间单位(秒、分、时、天）
  • 参数五：workQueue：指定线程池的任务队列
  • 参数六：threadFactory：指定线程池的线程工厂
  • 参数七：handler：指定线程池的任务拒绝策略（线程都在忙，任务队列也满了的时候，新任务来了该怎么处理）

创建一个线程池

public class ThreadPoolTest1 {
    public static void main(String[] args) {
        // 1、通过ThreadPoolExecutor创建一个线程池对象
        ExecutorService pool = new ThreadPoolExecutor(3, 5, 8,
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.CallerRunsPolicy());
    }
}

线程池的注意事项

1、临时线程什么时候创建？

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

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

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

线程池处理Runnable任务

ExecutorService的常用方法
在这里插入图片描述

新任务拒绝策略

在这里插入图片描述

代码实现

MyRunnable类

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        // 描述任务
        System.out.println(Thread.currentThread().getName() + " ==> 输出666~~");
        try {
            Thread.sleep(Integer.MAX_VALUE);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

测试类

import java.util.concurrent.*;

public class ThreadPoolTest1 {
    public static void main(String[] args) {
        // 1、通过ThreadPoolExecutor创建一个线程池对象
        ExecutorService pool = new ThreadPoolExecutor(3, 5, 8,
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.CallerRunsPolicy());

        Runnable target = new MyRunnable();
        pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
        pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
        pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
        pool.execute(target); // 复用前面的核心线程
        pool.execute(target);
        pool.execute(target);
        pool.execute(target); // 任务队列已满

        // 到了临时线程的创建时机了
        pool.execute(target);
        pool.execute(target);

        // 到了新任务的拒绝时机了！
        pool.execute(target);

        // pool.shutdown(); // 等着线程池的任务全部执行完毕后，再关闭线程池
        // pool.shutdownNow(); // 立即关闭线程池！不管任务是否执行完毕！
    }
}

在这里插入图片描述

线程池处理Callable任务

ExecutorService的常用方法
在这里插入图片描述

代码实现

MyCallable类

import java.util.concurrent.Callable;

/**
 * 1、让这个类实现Callable接口
 */
public class MyCallable implements Callable<String> {
    private int n;
    public MyCallable(int n) {
        this.n = n;
    }

    // 2、重写call方法
    @Override
    public String call() throws Exception {
        // 描述线程的任务，返回线程执行返回后的结果
        // 需求：求1-n的和返回
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return Thread.currentThread().getName() + "求出了1-" + n + "的和是：" + sum;
    }
}

测试类

import java.util.concurrent.*;

public class ThreadPoolTest2 {
    public static void main(String[] args) throws Exception {
        // 1、通过ThreadPoolExecutor创建一个线程池对象
        ExecutorService pool = new ThreadPoolExecutor(3, 5, 8,
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.CallerRunsPolicy());

        // 2、使用线程处理Callable任务
        Future<String> f1 = pool.submit(new MyCallable(100));
        Future<String> f2 = pool.submit(new MyCallable(200));
        Future<String> f3 = pool.submit(new MyCallable(300));
        Future<String> f4 = pool.submit(new MyCallable(400));

        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());
    }
}

在这里插入图片描述

Executors工具类实现线程池

什么是Executors

Executors 是一个线程池的工具类，提供了很多静态方法用于返回不同特点的线程池对象

在这里插入图片描述

注意：这些方法的底层，都是通过线程池的实现类ThreadPoolExecutor创建的线程池对象

Executors使用可能存在的陷阱

大型并发系统环境中，使用Executors如果不注意可能会出现系统风险。

在这里插入图片描述

其它细节知识：并发、并行

进程

  • 正在运行的程序（软件）就是一个独立的进程
  • 线程是属于进程的，一个进程中可以同时运行很多个线程
  • 进程中的多个线程其实是并发和并行执行的

并发的含义

进程中的线程是由CPU负责调度执行的，但CPU能同时处理线程的数量有限，为了保证全部线程都能往前执行，CPU会轮询为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发。

并行的理解

在同一个时刻上，同时有多个线程在被CPU调度执行。

其它细节知识：线程的生命周期

什么是线程的生命周期

  • 也就是线程从生到死的过程中，经历的各种状态及状态转换
  • 理解线程这些状态有利于提升并发编程的理解能力

Java线程的状态

  • Java中总共定义了6种状态
  • 6种状态都定义在Thread类的内部枚举类中
    在这里插入图片描述

线程的6种状态互相转换

在这里插入图片描述

线程的6种状态总结

在这里插入图片描述

乐观锁

前面我们学到的，都是悲观锁，就是一上来就加锁，没有安全感，每次只能一个线程进入访问完毕后，再解锁，线程安全，但是性能较差

什么是乐观锁

一开始不上锁，认为是没有问题的，大家一起跑，等要出现线程安全问题的时候才开始控制，线程安全，并且性能较好

例子

有1个变量，100个线程，每个线程都要对其加100次

不加锁

MyRunnable.java

public class MyRunnable implements Runnable{
    private int cnt;     // 记录浏览人数

    @Override
    public void run() {
        // 加100次
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " cnt --------> " + (++cnt));
        }
    }
}

Test1.java

public class Test1 {
    public static void main(String[] args) {
        // 需求：1个变量，100个线程，每个线程对其加100次
        Runnable target = new MyRunnable();

        for (int i = 0; i < 100; i++) {
            new Thread(target).start();
        }
    }
}

加的顺序不一定是一个一个地加，还有可能出现加不到10000的情况，因为有可能在同一时刻两个线程同时抢到了执行权，对同一个数字进行加1，结果相同，但是少了一次加法

在这里插入图片描述

加悲观锁

MyRunnable.java

public class MyRunnable implements Runnable{
    private int cnt;     // 记录浏览人数

    @Override
    public void run() {
        // 加100次
        for (int i = 0; i < 100; i++) {
            synchronized(this) {
                System.out.println(Thread.currentThread().getName() + " cnt --------> " + (++cnt));
            }
        }
    }
}

没有问题

在这里插入图片描述

加乐观锁

加乐观锁后，当有两个线程同时抢到执行权时，一个线程在对变量修改完成后，要赋值回去的时候会进行判断，若变量已经被修改了，则这一轮修改作废，重新进行一轮修改

MyRunnable2.java

public class MyRunnable2 implements Runnable{
    // 整数修改的乐观锁：用原子类实现
    private AtomicInteger cnt = new AtomicInteger();

    @Override
    public void run() {
        // 加100次
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " cnt --------> " + cnt.incrementAndGet());
        }
    }
}

Test2.java

public class Test2 {
    public static void main(String[] args) {
        // 需求：1个变量，100个线程，每个线程对其加100次
        Runnable target = new MyRunnable2();

        for (int i = 0; i < 100; i++) {
            new Thread(target).start();
        }
    }
}

在这里插入图片描述

多线程练习题

需求描述

有100份礼品，小红、小明两人同时发送，当剩下的礼品数小于10份的时候则不再送出，利用多线程模拟该过程并将线程的名称打印出来，并最后在控制台分别打印小红、小明分别送出了多少份礼物

代码

SendThread.java

import java.util.List;
import java.util.Random;

// 发送礼品
public class SendThread extends Thread {
    private List<String> gift;
    private int cnt;    // 计数

    public SendThread(List<String> gift, String name) {
        super(name);
        this.gift = gift;
    }

    @Override
    public void run() {
        // 发礼品
        // 注意：锁必须唯一
        Random r = new Random();
        String name = Thread.currentThread().getName();

        while (true) {
            synchronized(gift) {
                if (gift.size() < 10) {
                    break;
                }

                String rs = gift.remove(r.nextInt(gift.size()));
                System.out.println(name + "发出了：" + rs);
                cnt++;
            }
        }
    }

    public int getCnt() {
        return cnt;
    }
}

Demo.java

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class Demo1 {
    public static void main(String[] args) throws Exception {
        // 创建100份礼品
        List<String> gift = new ArrayList<>();
        String[] names = {"口红", "鲜花", "包包", "剃须刀", "皮带", "手表"};
        Random r = new Random();    // 随机分配礼品名称
        for (int i = 0; i < 100; i++) {
            gift.add(names[r.nextInt(names.length)] + (i+1));
        }
        System.out.println(gift);

        // 定义线程类，创建线程对象，去集合中拿礼品给别人
        SendThread xh = new SendThread(gift, "小红");
        xh.start();

        SendThread xm = new SendThread(gift, "小明");
        xm.start();

        xh.join();
        xm.join();

        System.out.println("小红送出了" + xh.getCnt() + "份礼物");
        System.out.println("小明送出了" + xm.getCnt() + "份礼物");
    }
}

在这里插入图片描述

程序喵正在路上
关注
专栏目录
java从入门到精通API02
cgblpx的博客
02-09 2739
文章目录1 多线程11.1 进程1.1.1 概念1.1.2 特点1.2 线程1.2.1 概念1.2.2 进程和线程的关系1.3 多线程的特性1.3.1 随机性1.3.2 线程状态![在这里插入图片描述](https://img-blog.csdnimg.cn/81eeac448385475a9856ed7acd95ab35.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAY2dibHB4,size_20
Java从入门到精通十二(java线程)
jgdabc的博客
03-05 1810
Java从入门到精通十二（java线程）什么是线程（thread）？二级目录三级目录 什么是线程（thread）？ 二级目录 三级目录
牛逼！Java 从入门到精通，超全汇总版
热门推荐
程序员cxuan的个人主页
05-06 7万+
文章目录Java 基础Head First JavaJava 核心技术卷一Java 编程思想设计模式Head First 设计模式图解设计模式设计模式重学 Java 设计模式Java 进阶Java 并发编程实战Java 并发编程艺术Java 并发编程之美图解Java多线程设计模式JVM深入理解 Java 虚拟机Java 虚拟机规范HotSpot 实战自己动手写 Java 虚拟机MySQLMySQL 基础教程SQL 基础教程深入浅出 MySQLMySQL 必知必会SQL 必知必会高性能 MySQLMySQL
完整的Java从小白到大牛的自学路线
程序员高级码农的博客
03-15 1358
我相信这些读者或多或少都有一些 Java 基础，但由于看不到全貌，学了一段时间很容易迷失。所以我在寻思着能不能写一个学习的地图或者路线，让读者能知道下一步该学什么，自己离大厂的 offer还有多远的距离。一个人最怕的不是路途遥远，而是看不到胜利曙光。这篇文章主要内容包括(干货满满)：学Java有哪些就业方向？数据结构和算法设计模式计算机基础Java 入门Java 高手进阶基础框架（SSM）微服务框架常用中间件数据库分布式架构必须掌握的工具软件学习资源网站列表汇总。
Java多线程入门（狂神说）
zwt174309的博客
04-07 756
文章目录前言线程与进程线程进程线程的创建线程的三种创建方式1.继承Thread类2.实现Runnable接口3.实现Callable接口线程状态线程的五大状态获取线程状态线程常用方法停止线程线程休眠sleep（）线程的礼让yield（）线程强制执行join（）线程的优先级setPriority（int newPriority）守护线程setDeamon()线程同步对象共享问题同步方法和同步代码块同步方法同步代码块死锁死锁产生的条件Lock锁公平锁synchronized 和 Lock的区别关于多线程访问同步
关东升老师从小白到大牛系列丛书（由清华大学出版社出版）
hacker707的博客
12-15 1万+
关东升老师从小白到大牛系列丛书（由清华大学出版社出版），感兴趣的可以购买!!!
java从入门到精通pdf脚本之家，大牛深入讲解
2401_84415234的博客
04-23 998
由于文案过于长，在此就不一一介绍了，这份Java后端架构进阶笔记内容包括：Java集合，JVM、Java并发、微服务、SpringNetty与 RPC 、网络、日志 、Zookeeper 、Kafka 、RabbitMQ 、Hbase 、MongoDB、Cassandra 、Java基础、负载均衡、数据库、一致性算法、Java算法、数据结构、分布式缓存等等知识详解。本知识体系适合于所有Java程序员学习，关于以上目录中的知识点都有详细的讲解及介绍，掌握该知识点的所有内容对你会有一个质的提升，
狂神说Java的多线程课程总结
qq_43558964的博客
04-15 2910
这个课程只能算是个入门，内容有点少。
Java基础教程-10-多线程
kc44601的博客
04-09 1712
多线程 -- 线程安全 -- 线程进阶 --线程池 -- 生产者消费者
java从入门到进阶
misaka___的博客
10-07 5591
在博主认为，对于入门级学习java的最佳学习方法莫过于视频+博客+书籍+总结，前三者博主将淋漓尽致地挥毫于这篇博客文章中，至于总结在于个人，实际上越到后面你会发现学习的最好方式就是阅读参考官方文档其次就是国内的书籍，博客次之，这又是一个层次了，这里暂时不提后面再谈。博主将为各位入门java保驾护航，各位只管冲鸭！！！上天是公平的，只要不辜负时间，时间自然不会辜负你。 何谓学习？博主所理解的学习，它是一个过程，是一个不断累积、不断沉淀、不断总结、善于传达自己的个人见解以及乐于分享的过程。 文章目录 一、Jav
Java零基础到大牛实战进阶指南
08-31
从Java语言基础语法讲起，逐步深入面向对象编程、集合框架、多线程、网络编程等核心知识，并结合实际项目案例，引导学习者将理论知识应用于实战中。此外，还涵盖了Java Web开发、Spring框架、数据库操作等进阶内容，...
Java并发编程从入门到精通(pdf)(附源码)
01-16
并发编程是现代软件开发中的重要组成部分，尤其是在Java这种多线程支持的语言中，理解和掌握并发编程技术至关重要。本书旨在帮助初学者快速入门，并逐步精通Java并发编程，从而提升软件性能和系统效率。 本书首先会...
Java入门经典教程：从菜鸟到大牛
通过深入学习这个最经典的Java入门教程，初学者将能够掌握基础语法、面向对象编程概念、异常处理、IO流、多线程、网络编程以及使用Java进行数据库连接等核心技能。随着学习的深入，开发者还可以进一步探索J2EE的Web...
Java基础07
最新发布
m0_74977981的博客
11-11 532
如图下图：每个case中都有一个break，如果没有这个break，就不会跳出case，直到遇见break为止。
JAVA-01-变量
LJH_laura_li的博客
11-08 396
在方法、构造函数或块内部定义的变量。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 234
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
Java基于小程序公考学习平台的设计与实现（附源码，文档）
chusheng1840的博客
11-09 911
Java基于小程序公考学习平台的设计与实现，小程序公考学习平台使用Java语言进行编码，使用Mysql创建数据表保存本系统产生的数据。系统可以提供信息显示和相应服务，其管理小程序公考学习平台信息，查看小程序公考学习平台信息，管理小程序公考学习平台。总之，小程序公考学习平台集中管理信息，有着保密性强，效率高，存储空间大，成本低等诸多优点。它可以降低信息管理成本，实现信息管理计算机化。关键词：小程序公考学习平台；Java语言；Mysql。
基于 SpringBoot 实现QQ邮箱验证码注册功能
2301_79201049的博客
11-06 650
找到并开通以下的邮件协议服务，而且服务开启也较为简单，需要我们发送一个短信到指定的号码，开启后平台会提供一个授权码，一定要记住这个授权码，发邮件的时候需要这个。host 是根据服务主机区分，网易邮箱是 smtp.163.com, qq邮箱是 smtp.qq.com。其中的 username 是你第一步中操作的邮箱账号，nickname 是接收者收到邮件中显示的发件人。发送邮件的核心依赖是 mail ，由于该项目还涉及其他依赖就全都导进来了。（1）首先打开QQ邮箱，点击设置并来到账号页面。
java_方法重写/覆盖(override)
HHppGo的博客
11-07 332
方法覆盖（重写）就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序喵正在路上

你的鼓励是我创作最大的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值