JAVA基础加强篇10——多线程

于 2022-07-29 17:26:17 发布
阅读量167 收藏
点赞数
分类专栏： JAVA基础加强篇 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chu_dianxia/article/details/126058676
版权

多线程课程安排

什么是线程？

  • 线程（thread）是一个程序内部的一条执行路径。

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

    在这里插入图片描述

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

多线程是什么？

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

多线程用在哪里，有什么好处？

在这里插入图片描述

  • 再例如：消息通信、淘宝、京东系统都离不开多线程技术。

课程安排

在这里插入图片描述

多线程的创建

方式一：继承 Thread 类

Thread 类
  • Java 是通过 java.lang.Thread 类来代表线程的。
  • 按照面向对象的思想，Thread 类应该提供了实现多线程的方式。
多线程的实现方案一：继承 Thread 类
  1. 定义一个子类 MyThread 继承线程类 java.lang.Thread，重写 run() 方法
  2. 创建 MyThread 类的对象
  3. 调用线程对象的 start() 方法启动线程（启动后还是执行 run 方法的）
/**
 * @author : gxd
 * @date : 2022/7/12 9:43
 * 目标：多线程的创建方式一：继承Thread类实现。
 * 1. 定义一个子类 MyThread 继承线程类 java.lang.Thread，重写 run() 方法
 * 2. 创建 MyThread 类的对象
 * 3. 调用线程对象的 start() 方法启动线程（启动后还是执行 run 方法的）
 */
public class ThreadTest1 {
    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，无法继承其他类，不利于扩展。
小结
  1. 为什么不直接调用了 run 方法，而是调用 start 启动线程。
    • 直接调用 run 方法会当成普通方法执行，此时相当于还是单线程执行。
    • 只有调用 start 方法才是启动一个新的线程执行。
  2. 把主线程任务放在了子线程之前了。
    • 这样主线程一直是先跑完的，相当于是一个单线程的效果了。
总结
  1. 方式一是如何实现多线程的？
    • 继承 Thread 类
    • 重写 run 方法
    • 创建线程对象
    • 调用 start() 方法启动。
  2. 优缺点是什么？
    • 优点：编码简单
    • 缺点：存在单继承的局限性，线程类继承 Thread 后，不能继承其他类，不便于扩展。

方式二：实现 Runnable 接口

多线程的实现方案二：实现 Runnable 接口
  1. 定义一个线程任务类 MyRunnable 实现 Runnable 接口，重写 run() 方法。
  2. 创建 MyRunnable 任务对象。
  3. 把 MyRunnable 任务对象交给 Thread 处理。
  4. 调用线程对象的 start() 方法启动线程。
/**
 * @author : gxd
 * @date : 2022/7/12 11:24
 * 目标：多线程的实现方案二：实现 Runnable 接口
 * 1. 定义一个线程任务类 MyRunnable 实现 Runnable 接口，重写 run() 方法。
 * 2. 创建 MyRunnable 任务对象。
 * 3. 把 MyRunnable 任务对象交给 Thread 处理。
 * 4. 调用线程对象的 start() 方法启动线程。
 */
public class ThreadTest2 {
    public static void main(String[] args) {
        //3、创建一个任务对象
        MyRunnable target = new MyRunnable();
        //4、把任务对象交给 Thread 处理
        Thread t = new Thread(target);
        //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);
        }
    }
}
Thread 的构造器

在这里插入图片描述

方式二优缺点：
  • 优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。
  • 缺点：编程多一层对象包装，如果线程有执行结果是不可以直接返回的。
总结
  1. 第二种方式是如何创建线程的？
    • 定义一个线程任务类 MyRunnable 实现 Runnable 接口，重写 run() 方法
    • 创建 MyRunnable 对象
    • 把 MyRunnable 任务对象交给 Thread 线程对象处理。
    • 调用线程对象的 start() 方法启动线程
  2. 第二种方式的优点
    • 优点：线程任务类只是实现了 Runnable 接口，可以继续继承和实现。
    • 缺点：如果线程有执行结果是不能直接返回的。
多线程的实现方案二：实现 Runnable 接口（匿名内部类形式）
  1. 可以创建 Runnable 的匿名内部类对象。
  2. 交给 Thread 处理。
  3. 调用线程对象的 start() 启动线程。
/**
 * @author : gxd
 * @date : 2022/7/12 14:13
 * 目标 多线程的实现方案二：实现 Runnable 接口（匿名内部类形式）
 * 1. 可以创建 Runnable 的匿名内部类对象。
 * 2. 交给 Thread 处理。
 * 3. 调用线程对象的 start() 启动线程。
 */
public class ThreadTest2Other {
    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);
        }
    }
}

方式三：JDK5.0新增：实现 Callable 接口

  1. 前2种线程创建方式都存在一个问题：
    • 他们重写的 run 方法均不能直接返回结果。
    • 不适合需要返回线程执行结构的业务场景。
  2. 怎么解决这个问题呢？
    • JDK 5.0 提供了 Callable 和 FutureTask 来实现。
多线程的实现方案三：利用 Callable、FutureTask 接口实现。
  1. 得到任务对象
    1. 定义类实现 Callable 接口，重写 Call 方法，封装要做的事情。
    2. 用 FutureTask 把 Callable 对象封装成线程任务对象。
  2. 把线程任务对象交给 Thread 处理。
  3. 调用 Thread 的 start 方法启动线程，执行任务
  4. 线程执行完毕后、通过 FutureTask 的 get 方法去获取任务执行的结果。
/**
 * @author : gxd
 * @date : 2022/7/12 14:50
 * 目标： 多线程的实现方案三：利用 Callable、FutureTask 接口实现。
 * 1. 得到任务对象
 *    1. 定义类实现 Callable 接口，重写 Call 方法，封装要做的事情。
 *    2. 用 FutureTask 把 Callable 对象封装成线程任务对象。
 * 2. 把线程任务对象交给 Thread 处理。
 * 3. 调用 Thread 的 start 方法启动线程，执行任务
 * 4. 线程执行完毕后、通过 FutureTask 的 get 方法去获取任务执行的结果。
 */
public class ThreadTest3 {
    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);
        //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 = 0; i <= n; i++) {
            sum += i;
        }
        return "子线程执行的结果是：" + sum;
    }
}
FutureTask 的 API

在这里插入图片描述

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

  1. 3种方式对比

    在这里插入图片描述

Thread 的常用方法

Thread 常用 API 说明

  • Thread 常用方法：获取线程名称 getName()、设置名称 setName()、获取当前线程对象 currentThread()。
  • 至于 Thread 类提供的诸如：yield、join、interrupt、不推荐的方法 stop、守护线程、线程优先级等线程的控制方法，在开发中很少使用，这些方法会在高级篇以及后续需要用到的时候在为大家讲解。

Thread 获取和设置线程名称

在这里插入图片描述

Thread 类获得当前线程的对象

在这里插入图片描述

注意：

  • 1、此方法是 Thread 类的静态方法，可以直接使用 Thread 类调用。
  • 2、这个方法是在哪个线程执行中调用的，就会得到哪个线程对象。

线程类：

/**
 * @author : gxd
 * @date : 2022/7/12 15:53
 */
public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "输出：" + i);
        }
    }
}

程序：

/**
 * @author : gxd
 * @date : 2022/7/12 15:55
 * 目标：学会使用 Thread 常用 API 
 */
public class ThreadTest1 {
    public static void main(String[] args) {
        Thread t1 = new MyThread();
        t1.setName("1号线程");
        t1.start();
        System.out.println(t1.getName());

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

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

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

Thread 的构造器

在这里插入图片描述

线程类：

/**
 * @author : gxd
 * @date : 2022/7/12 15:53
 */
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);
        }
    }
}

程序：

/**
 * @author : gxd
 * @date : 2022/7/12 15:55
 * 目标：学会使用 Thread 常用 API 
 */
public class ThreadTest1 {
    public static void main(String[] args) {
        Thread t1 = new MyThread("1号线程");
        //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);
        }
    }
}

Thread 类的线程休眠方法

在这里插入图片描述

/**
 * @author : gxd
 * @date : 2022/7/12 16:16
 * 目标：学会使用 Thread 类的线程休眠方法
 */
public class ThreadTest2 {
    public static void main(String[] args) throws Exception {
        for (int i = 0; i <= 5 ; i++) {
            System.out.println("输出：" + i);
            if (i == 3){
                //让当前线程进入休眠状态
                //段子：项目经理让我加上这行代码，如果用户原意交钱，我就注释掉。优化
                Thread.sleep(3000);
            }
        }
    }
}

总结

  1. Thread 常用方法

    在这里插入图片描述

  2. Thread 常用构造器

    在这里插入图片描述

线程安全

线程安全问题是什么、发生的原因

线程安全问题
  • 多个线程同时操作同一个共享资源的时候可能会出现业务安全问题，称为线程安全问题。
取钱模型演示
  • 需求：小明和小红是一对夫妻，他们有一个共同的账户，余额是 10 万元。
  • 如果小明和小红同时来取钱，而且 2 人都要取钱 10 万元，可能出现什么问题呢？

在这里插入图片描述

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

线程安全问题案例模拟

案例 取钱业务

需求：

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

分析：

  1. 需要提供一个账户类，创建一个账户对象代表 2 个人的共享账户。
  2. 需要定义一个线程类，线程类可以处理账户对象。
  3. 创建 2 个线程对象，传入同一个账户对象。
  4. 启动 2 个线程，去同一个账户对象中取钱 10 万。

账户类：

/**
 * @author : gxd
 * @date : 2022/7/12 16:54
 */
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){
            //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;
    }
}

线程类：

/**
 * @author : gxd
 * @date : 2022/7/12 16:56
 * 取钱的线程类
 */
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);
    }
}

程序：

/**
 * @author : gxd
 * @date : 2022/7/12 17:00
 * 案例 取钱业务
 *
 * 需求：
 * - 小明和小红是一对夫妻，他们有一个共同的账户，余额是 10 万元，模拟 2 人同时去取钱 10 万。
 *
 * 分析：
 * 1. 需要提供一个账户类，创建一个账户对象代表 2 个人的共享账户。
 * 2. 需要定义一个线程类，线程类可以处理账户对象。
 * 3. 创建 2 个线程对象，传入同一个账户对象。
 * 4. 启动 2 个线程，去同一个账户对象中取钱 10 万。
 */
public class ThreadTest {
    public static void main(String[] args) {
        //1、定义线程类，创建一个共享的账户对象
        Account acc = new Account("IBCD-666",100000);

        //2、创建2个线程对象，代表小明和小红同时进来了
        new DrawThread(acc,"小明").start();
        new DrawThread(acc,"小红").start();
    }
}
总结
  1. 线程安全问题发生的原因是什么？
    • 多个线程同时访问同一个共享资源且存在修改该资源。

线程同步

同步思想概述

线程同步
  • 为了解决线程安全问题。
    1. 取钱案例出现问题的原因？
      • 多个线程同时执行，发现账户都是够钱的。
    2. 如何才能保证线程安全呢？
      • 让多个线程实现先后依次访问共享资源，这样就解决了安全问题
线程同步的核心思想
  • 加锁，把共享资源进行上锁，每次只能一个线程进入访问完毕以后解锁，然后其他线程才能进来。
总结
  1. 线程同步解决安全问题的思想是什么？
    • 加锁：让多个线程实现先后依次访问共享资源，这样就解决了安全问题。

方式一：同步代码块

同步代码块

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

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

    在这里插入图片描述

账户实体类：

/**
 * @author : gxd
 * @date : 2022/7/12 16:54
 */
public class Account {
    private String cardId;
    private double money;//账户的余额

    public Account() {
    }

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

    //静态方法使用 字节码（类名.class）对象作为锁对象。
    public static void run(){
        synchronized (Account.class){

        }
    }

    /**
     * 小明  小红：取钱过程
     */
    public void drawMoney(double money) {
        //0、先获取是谁来取钱，线程的名字就是人名
        String name = Thread.currentThread().getName();
        //同步代码块
        //this == acc 共享账户
        //实例方法使用 this 作为锁对象。
        synchronized (this) {
            //1、判断账户是否够钱
            if (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;
    }
}

线程类：

/**
 * @author : gxd
 * @date : 2022/7/12 16:56
 * 取钱的线程类
 */
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);
    }
}

程序：

/**
 * @author : gxd
 * @date : 2022/7/12 17:00
 * 案例 取钱业务
 *
 * 需求：
 * - 小明和小红是一对夫妻，他们有一个共同的账户，余额是 10 万元，模拟 2 人同时去取钱 10 万。
 *
 * 分析：
 * 1. 需要提供一个账户类，创建一个账户对象代表 2 个人的共享账户。
 * 2. 需要定义一个线程类，线程类可以处理账户对象。
 * 3. 创建 2 个线程对象，传入同一个账户对象。
 * 4. 启动 2 个线程，去同一个账户对象中取钱 10 万。
 */
public class ThreadTest {
    public static void main(String[] args) {
        //1、定义线程类，创建一个共享的账户对象
        Account acc = new Account("IBCD-666",100000);

        //2、创建2个线程对象，代表小明和小红同时进来了
        new DrawThread(acc,"小明").start();
        new DrawThread(acc,"小红").start();
    }
}
锁对象要求
  • 理论上：锁对象只要对于当前同时执行的现场来说是同一个对象即可。
小结
  1. 锁对象用任意唯一的对象好不好呢？
    • 不好，会影响其他无关线程的执行。
  2. 锁对象的规范要求
    • 规范上：建议使用共享资源作为锁对象。
    • 对于实例方法建议使用 this 作为锁对象。
    • 对于静态方法建议使用 字节码（类名.class）对象作为锁对象。
总结
  1. 同步代码块是如何实现线程安全的？
    • 对出现问题的核心代码使用 synchronized 进行加锁
    • 每次只能一个线程占锁进入访问
  2. 同步代码块的同步锁对象有什么要求？
    • 对于实例方法建议使用 this 进行锁对象。
    • 对于静态方法建议使用字节码（类名.class）对象作为锁对象。

方式二：同步方法

同步方法
  • 作用：把出现线程安全问题的核心方法给上锁。
  • 原理：每次只能一个线程进入，执行完毕以后自动解锁，其他线程才可以进行执行。
格式

在这里插入图片描述

账户实体类：

/**
 * @author : gxd
 * @date : 2022/7/12 16:54
 */
public class Account {
    private String cardId;
    private double money;//账户的余额

    public Account() {
    }

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

    /**
     * 小明  小红：取钱过程
     * 同步方法： 修饰符 synchronized 返回值类型 方法名称(形参列表){ 操作共享资源的代码}
     */
    public synchronized void drawMoney(double money) {
        //0、先获取是谁来取钱，线程的名字就是人名
        String name = Thread.currentThread().getName();
        //1、判断账户是否够钱
        if (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;
    }
}

线程类：

/**
 * @author : gxd
 * @date : 2022/7/12 16:56
 * 取钱的线程类
 */
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);
    }
}

程序：

/**
 * @author : gxd
 * @date : 2022/7/12 17:00
 * 案例 取钱业务
 *
 * 需求：
 * - 小明和小红是一对夫妻，他们有一个共同的账户，余额是 10 万元，模拟 2 人同时去取钱 10 万。
 *
 * 分析：
 * 1. 需要提供一个账户类，创建一个账户对象代表 2 个人的共享账户。
 * 2. 需要定义一个线程类，线程类可以处理账户对象。
 * 3. 创建 2 个线程对象，传入同一个账户对象。
 * 4. 启动 2 个线程，去同一个账户对象中取钱 10 万。
 */
public class ThreadTest {
    public static void main(String[] args) {
        //1、定义线程类，创建一个共享的账户对象
        Account acc = new Account("IBCD-666",100000);

        //2、创建2个线程对象，代表小明和小红同时进来了
        new DrawThread(acc,"小明").start();
        new DrawThread(acc,"小红").start();
    }
}
同步方法底层原理
  • 同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。
  • 如果方法是实例方法：同步方法默认用 this 作为锁对象。但是代码要高度面向对象！
  • 如果方法是静态方法：同步方法默认用 类名.class 作为锁对象。
小结：
  1. 是同步代码块好还是同步方法好一点？
    • 同步代码锁的范围更小，同步方法锁的范围更大。
总结
  1. 同步方法是如何保证线程安全的？
    • 对出现问题的核心方法使用 synchronized 修饰
    • 每次只能一个线程占锁进入访问
  2. 同步方法的同步锁对象的原理？
    • 对于实例方法默认使用 this 作为锁对象。
    • 对于静态方法默认使用 类名.class 对象作为锁对象。

方法三：Lock 锁

Lock 锁

  • 为了更清晰的表达如何锁和释放锁，JDK5 以后提供了一个新的锁对象 Lock，更加灵活、方便。

  • Lock 实现提供比使用 synchronized 方法和语句可以获得更广泛的锁定操作。

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

    在这里插入图片描述

Lock 的 API

在这里插入图片描述

账户实体类：

/**
 * @author : gxd
 * @date : 2022/7/12 16:54
 */
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 void drawMoney(double money) {
        //0、先获取是谁来取钱，线程的名字就是人名
        String name = Thread.currentThread().getName();
        lock.lock();//上锁
        try {
            //1、判断账户是否够钱
            if (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 + "来取钱，余额不足！");
            }
        } finally {
            lock.unlock();//解锁
        }
    }

    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;
    }
}

线程类：

/**
 * @author : gxd
 * @date : 2022/7/12 16:56
 * 取钱的线程类
 */
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);
    }
}

程序：

/**
 * @author : gxd
 * @date : 2022/7/12 17:00
 * 案例 取钱业务
 *
 * 需求：
 * - 小明和小红是一对夫妻，他们有一个共同的账户，余额是 10 万元，模拟 2 人同时去取钱 10 万。
 *
 * 分析：
 * 1. 需要提供一个账户类，创建一个账户对象代表 2 个人的共享账户。
 * 2. 需要定义一个线程类，线程类可以处理账户对象。
 * 3. 创建 2 个线程对象，传入同一个账户对象。
 * 4. 启动 2 个线程，去同一个账户对象中取钱 10 万。
 */
public class ThreadTest {
    public static void main(String[] args) {
        //1、定义线程类，创建一个共享的账户对象
        Account acc = new Account("IBCD-666",100000);

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

线程通信[了解]

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

  • 所谓线程通信就是线程间相互发送数据，线程通信通常通过共享一下数据的方式实现。
  • 线程间会根据共享数据的情况决定自己该怎么做，以及通知其他线程怎么做。

线程通信常见模型

  • 生产者与消费者模型：生产者线程负责生产数据，消费者线程负责消费数据。
  • 要求：生产者线程生产完数据后，唤醒消费者，然后等待自己；消费者消费完该数据后，唤醒生产者，然后等待自己。

线程通信案例模拟

  • 假如有这样一个场景，小明和小红有三个爸爸，爸爸们负责存钱，小明和小红负责取钱，必须一存、一取。

    在这里插入图片描述

  • 线程通信的前提：线程通信通常是在多个线程操作同一个共享资源的时候需要进行通信，且要保证线程安全。

账户实体类

/**
 * @author : gxd
 * @date : 2022/7/12 16:54
 */
public class Account {
    private String cardId;
    private double money;//账户的余额

    public Account() {
    }

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

    /**
     * 亲爹、干爹、岳父存钱
     */
    public synchronized void deposit(double money) {
        try {
            String name = Thread.currentThread().getName();
            if (this.money == 0){
                //没钱了，存钱
                this.money += money;
                System.out.println(name  + "来存钱" + money +"成功！存钱后余额是:" + this.money);
                //有钱了，唤醒被人，等待自己
                this.notifyAll();//唤醒所有线程
                this.wait();//锁对象，让当前线程进入等待！
            }else {
                //有钱，不存钱
                this.notifyAll();//唤醒所有线程
                this.wait();//锁对象，让当前线程进入等待！
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 小明 小红 取钱
     */
    public synchronized void drawMoney(double money) {
        try {
            String name = Thread.currentThread().getName();
            if (this.money >= money){
                //取钱：可取
                this.money -= money;
                System.out.println(name + "来取钱" + money + "成功！余额是：" + this.money);

                //没钱了
                this.notifyAll();//唤醒所有线程
                this.wait();//锁对象，让当前线程进入等待！
            }else {
                //钱不够，不可取。
                //唤醒别人，等待别人
                this.notifyAll();//唤醒所有线程
                this.wait();//锁对象，让当前线程进入等待！
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    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;
    }
}

存钱线程：

/**
 * @author : gxd
 * @date : 2022/7/12 16:56
 * 存钱的线程类
 */
public class DepositThread extends Thread{
    //接收处理的账户对象
    private Account acc;
    public DepositThread(Account acc, String name){
        super(name);
        this.acc = acc;
    }

    @Override
    public void run() {
        //亲爹、干爹、岳父存钱
        while (true){
            acc.deposit(100000);
            try {
                Thread.sleep(2000);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

取钱线程：

/**
 * @author : gxd
 * @date : 2022/7/12 16:56
 * 取钱的线程类
 */
public class DrawThread extends Thread{
    //接收处理的账户对象
    private Account acc;
    public DrawThread(Account acc, String name){
        super(name);
        this.acc = acc;
    }

    @Override
    public void run() {
        //小明 小红取钱
        while (true){
            acc.drawMoney(100000);
            try {
                Thread.sleep(3000);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

程序：

/**
 * @author : gxd
 * @date : 2022/7/12 17:00
 * 案例 线程通信案例模拟
 * - 假如有这样一个场景，小明和小红有三个爸爸，爸爸们负责存钱，小明和小红负责取钱，必须一存、一取。
 * - 线程通信的前提：线程通信通常是在多个线程操作同一个共享资源的时候需要进行通信，且要保证线程安全。
 *
 */
public class ThreadTest {
    public static void main(String[] args) {
        //目标：了解线程通信的流程
        //使用3个爸爸存钱（生产者）2个孩子取钱（消费者）模拟线程通信思想
        //1、创建账户对象，代表5个人共同操作的用户
        Account acc = new Account("IBCD-666",0);

        //2、创建2个取钱线程代表小明和小红
        new DrawThread(acc,"小明").start();
        new DrawThread(acc,"小红").start();

        //3、创建3个存钱线程代表：亲爹、干爹、岳父。
        new DepositThread(acc,"亲爹").start();
        new DepositThread(acc,"干爹").start();
        new DepositThread(acc,"岳父").start();
    }
}

Object 类的等待和唤醒方法：

在这里插入图片描述

注意：

  • 上述方法应该使用当前同步锁对象进行调用。

总结

  1. 线程通信的三个常见方法

    在这里插入图片描述

注意：

  • 上述方法应该使用当前同步锁对象进行调用。

线程池[重点]

线程池概述

什么是线程池？
  • 线程池就是一个可以复用线程的技术。
不使用线程池的问题
  • 如果用户每发起一个请求，后天就创建一个新线程来处理，下次新任务来了又要创建新线程，而创建新线程的开销是很大的，这样会严重影响系统的性能。
线程池的工作原理

在这里插入图片描述

线程池实现的API、参数说明

谁代表线程池？
  • JDK5.0起提供了代表线程池的接口：ExecutorService
如何得到线程池对象

  • 方式一：使用 ExecutorService 的实现类 ThreadPoolExectutor 自创建一个线程池对象

    在这里插入图片描述

  • 方式二：使用 Executors（线程池的工具类）调用方法返回不同特点的线程对象

ThreadPoolExecutor 构造器的参数说明

在这里插入图片描述

线程池常见面试题
  1. 临时线程什么时候创建啊？
    • 新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程。
  2. 什么时候会开始拒绝任务？
    • 核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始任务拒绝。
总结

  1. 谁代表线程池？

    • ExecutorService 接口

  2. ThreadPoolExecutor 实现线程池对象的七个参数时候是什么意思？

    • 使用线程池的实现类 ThreadPoolExecutor

      在这里插入图片描述

线程池处理 Runnable 任务

ThreadPoolExecutor 创建线程池对象示例

在这里插入图片描述

ExecutorService 的常用方法

在这里插入图片描述

新任务拒绝策略

在这里插入图片描述

Runnable线程类：

/**
 * @author : gxd
 * @date : 2022/7/13 16:04
 */
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "输出了：HelloWorld ==>" + i);
        }
        try {
            System.out.println(Thread.currentThread().getName() + "本任务与线程绑定了，线程进入休眠了~~~");
            Thread.sleep(1000000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

程序：

/**
 * @author : gxd
 * @date : 2022/7/13 15:57
 * 目标：自定义一个线程池对象处理Runnable任务，并测试其特性。
 */
public class ThreadPoolTest1 {
    public static void main(String[] args) {
        //1、创建线程池对象
        // public ThreadPoolExecutor(int corePoolSize,
        //                              int maximumPoolSize,
        //                              long keepAliveTime,
        //                              TimeUnit unit,
        //                              BlockingQueue<Runnable> workQueue,
        //                              ThreadFactory threadFactory,
        //                              RejectedExecutionHandler handler) {
        ExecutorService pool = new ThreadPoolExecutor(3,5,6,
                TimeUnit.SECONDS,new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

        //2、给任务线程池处理
        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.execute(target);

        //关闭线程池（开发中一般不会使用）
        //pool.shutdownNow();//立即关闭，解释任务没有完成，丢失任务的！
        //pool.shutdown();//会等待全部任务执行完毕之后再关闭。相比shutdownNow 建议使用，整体不建议使用
    }
}
总结
  1. 线程池如何处理 Runnable 任务
    • 使用 ExecutorService 的方法：
    • void execute(Runnable target)

线程池处理 Callable 任务

ExecutorService 的常用方法

在这里插入图片描述

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 {
        int sum = 0;
        for (int i = 0; i <= n; i++) {
            sum += i;
        }
        return Thread.currentThread().getName() + "执行1-" + n + "的和，结果是：" + sum;
    }
}

程序：

/**
 * @author : gxd
 * @date : 2022/7/13 15:57
 * 目标：自定义一个线程池对象处理Callable任务，并测试其特性。
 */
public class ThreadPoolTest2 {
    public static void main(String[] args) throws Exception {
        //1、创建线程池对象
        // public ThreadPoolExecutor(int corePoolSize,
        //                              int maximumPoolSize,
        //                              long keepAliveTime,
        //                              TimeUnit unit,
        //                              BlockingQueue<Runnable> workQueue,
        //                              ThreadFactory threadFactory,
        //                              RejectedExecutionHandler handler) {
        ExecutorService pool = new ThreadPoolExecutor(3,5,6,
                TimeUnit.SECONDS,new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

        //2、给任务线程池处理
        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));
        Future<String> f5 = 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());
        System.out.println(f5.get());
    }
}
总结
  1. 线程池如何处理 Callable 任务，并得到任务执行完后返回的结果。
    • 使用 ExecutorService 的方法：
    • Future submit(Callable task)

Executors 工具实现线程池

Executors 得到线程池对象的常用方法

  • Executors：线程池的工具类通过调用方法返回不同类型的线程池对象。

    在这里插入图片描述

注意：Executors 的底层其实也是基于线程池的实现类 ThreadPoolExecutor 创建线程池对象的。

/**
 * @author : gxd
 * @date : 2022/7/13 15:57
 * 目标：使用 Executors 的工具方法直接得到一个线程池对象。
 */
public class ThreadPoolTest3 {
    public static void main(String[] args) throws Exception {
        //1、创建固定线程数据的线程池
        ExecutorService pool = Executors.newFixedThreadPool(3);

        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());//已经没有多余线程了
    }
}
Executors 使用可能存在的陷阱

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

    在这里插入图片描述

    在这里插入图片描述

总结
  1. Executors 工具类底层是基于什么方式实现的线程池对象？
    • 线程池 ExecutorService 的实现类：ThreadPoolExecutor
  2. Executors 是否适合做大型互联网场景的线程池方案？
    • 不合适。
    • 建议使用 ThreadPoolExecutor 来指定线程池参数，这样可以明确线程池的运行规则规避资源耗尽的风险。

补充知识：定时器

定时器

  • 定时器是一种控制任务延时调用，或者周期调用的技术。
  • 作用：闹钟、定时邮件发送。

定时器的实现方式

  • 方式一：Timer
  • 方式二：ScheduledExecutorService

Timer 定时器

在这里插入图片描述

Timer 定时器的特点和存在的问题

  1. Timer 是单线程，处理多个任务按照顺序执行，存在延时与设置定时器的时间有出入。
  2. 可能因为其中的某个任务的异常是 Timer 线程死掉，从而影响后续任务知悉。
/**
 * @author : gxd
 * @date : 2022/7/19 9:27
 * 目标：Timer定时器的使用和了解
 */
public class TimerTest1 {
    public static void main(String[] args) {
        //1、创建 Timer 定时器
        Timer timer = new Timer();//定时器本身就是一个单线程
        //2、调用方法，处理定时任务
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行了AA！" + new Date());
                //try {
                //    Thread.sleep(5000);
                //} catch (InterruptedException e) {
                //    e.printStackTrace();
                //}
            }
        },3000,2000);
        /**
         * Timer 定时器的特点和存在的问题
         * 1. Timer 是单线程，处理多个任务按照顺序执行，存在延时与设置定时器的时间有出入。
         * 2. 可能因为其中的某个任务的异常是 Timer 线程死掉，从而影响后续任务知悉。
         *
         */
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行了BB！" + new Date());
                System.out.println(10/0);
            }
        },3000,2000);

        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行了一次！" + new Date());
            }
        },3000,2000);
    }
}

ScheduledExecutorService 定时器

  • ScheduledExecutorService 是 jdk1.5 中引入了并发包，目的是为了弥补 Timer 的缺陷，ScheduledExecutorService 内部为线程池。

    在这里插入图片描述

ScheduledExecutorService的优点

  1. 基于线程池，某个任务的执行情况不会影响其他定时任务的执行。
/**
 * @author : gxd
 * @date : 2022/7/19 9:48
 * 目标：ScheduledExecutorService 定时器使用
 */
public class ScheduledExecutorServiceTest2 {
    public static void main(String[] args) {
        //1、创建 ScheduledExecutorService 线程池，做定时器
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(3);

        //2、开启定时任务
        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行输出：AAA  ==>" + new Date());
                try {
                    Thread.sleep(4000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },0,2, TimeUnit.SECONDS);

        /**
         * ScheduledExecutorService的优点
         * 1. 基于线程池，某个任务的执行情况不会影响其他定时任务的执行。
         */
        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行输出：BBB  ==>" + new Date());
                System.out.println(10/0);
            }
        },0,2, TimeUnit.SECONDS);

        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行输出：CCC  ==>" + new Date());
            }
        },0,2, TimeUnit.SECONDS);
    }
}

补充知识：并发、并行

并发与并行

  • 正在运行的程序（软件）就是一个独立的线程，线程是属于进程的，多个线程其实是并发与并行同时进行的。

并发的理解：

  • CPU 同时处理线程的数量有限。
  • CPU 会轮询为系统的每个线程服务，由于 CPU 切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发。

在这里插入图片描述

并行的理解：

  • 在同一时刻上，同时有多个线程在被 CPU 处理并执行。

    在这里插入图片描述

总结

  1. 简单说说并发和并行的含义
    • 并发：CPU 分时轮询的执行流程。
    • 并行：同一个时刻同时在执行。

补充知识：线程的生命周期

线程的状态

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

Java 线程的状态

  • Java 总共定义了 6 中状态。

  • 6 中状态都定义在 Thread 类的内部枚举类中。

    在这里插入图片描述

线程的 6 种状态互相转换

在这里插入图片描述

线程的 6 种状态总结

在这里插入图片描述

注意：

总结

  1. 线程的六种状态

    在这里插入图片描述

J寒
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java线程基础
zeo_123的博客
04-03 370
Thread，意为线程，Thread类实现了Runnable接口，重写了里面唯一的run方法，但是里面的run方法由于target属性为null，并没有执行实现了Runnable接口的run方法。这种方式创建线程，需要继承Thread类，然后重写run方法，在run方法里面写上想实现的业务逻辑，这里让其每隔一秒在控制台输出“喵喵叫”，在main方法里实例化Cat对象，调用start方法启动线程。并发：同一个时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简单的说，单核cpu实现的多任务就是并发。
java 子线程
shengyao15的专栏
04-23 133
java 主线程调用子线程后 可以用join的方式等待子线程返回， 再继续。 也可以用CompletionService 的take().get() 方法得到返回结果后再继续。 [code="java"] ExecutorService es = Executors.newFixedThreadPool(10); CompletionService cs = new Execu...
Java中的父线程与子线程
weixin_34120274的博客
09-22 126
为什么80%的码农都做不了架构师？>>> ...
Java多线程编程之创建子线程
蔡政洁的博客
02-16 5212
目录一、基础知识（1）进程（2）线程（3）主线程二、创建子线程（1）通过实现Runnable接口（2）通过继承Thread线程类（3）使用匿名内部类和Lambda表达式实现线程体 一、基础知识 学习线程之前先了解一下有关的基础知识 （1）进程 一般可以在同一时间内执行多个程序的操作系统都有进程的概念。一个进程就是一个执行中的程序， 而每一个进程都有自己独立的一块内存空间、一组系统资源。在进程的概念...
java主线程等待所有子线程执行完毕再执行
热门推荐
延宝小白马的博客
07-18 5万+
        java主线程等待所有子线程执行完毕在执行，这个需求其实我们在工作中经常会用到，比如用户下单一个产品，后台会做一系列的处理，为了提高效率，每个处理都可以用一个线程来执行，所有处理完成了之后才会返回给用户下单成功，下面就说一下我能想到的方法，欢迎大家批评指正： 1  用sleep方法，让主线程睡眠一段时间，当然这个睡眠时间是主观的时间，是我们自己定的，这个方法不推荐，但是在这里还是...
Java基础 学习笔记 Markdownr版
06-27
4. 多线程：在10多线程.md中，介绍了如何创建和管理Java线程，包括Thread类、Runnable接口，以及同步机制如synchronized关键字、wait()、notify()和notifyAll()方法。多线程技术是实现并发执行的关键，有助于提高...
java多媒体与多线程处理实验
03-05
### Java多媒体与多线程...通过本次实验，学生不仅掌握了Java多线程编程的基础知识，还学会了如何利用多线程优化程序性能，特别是在多媒体应用领域，如动画、音视频处理等，为后续更复杂的应用开发奠定了坚实的基础。
115个Java面试题和答案——终极列表
09-14
Java面试题是每个Java开发者在求职过程中必须面对的挑战，涵盖范围广泛，从基础概念到高级特性和设计模式。这份终极列表包含115个Java面试题和答案，旨在帮助求职者全面准备，以期在面试中表现出色。以下是部分核心...
Java数组,Java数组,多线程编程
07-14
Java数组是程序设计中的基本构建块，它允许程序员存储多个相同类型的数据在一个...以上就是关于Java数组、Java环境配置以及Java多线程编程的相关知识点。掌握这些内容，可以帮助开发者编写更高效、更健壮的Java程序。
java中父进程与子进程
zhangqindabendan的博客
02-07 8275
转自：https://my.oschina.net/hosee/blog/509557 以前在学习操作系统的时候，一直记得的父线程死后，子线程也消失了。然而今天在查资料中，发现有点疑惑，在此记录一下。 Java编写的程序都运行在Java虚拟机（JVM）中，在JVM的内部，程序的多任务是通过线程来实现的。 每用java命令启动一个java应用程序，就会启动一个JVM进程。在同一个JVM进程中，
java怎么创建子线程_Java创建子线程的两种方法
weixin_33836042的博客
02-27 2986
摘要：其实两种方法归结起来看还是一种，都是利用Thread的构造器进行创建，区别就是一种是无参的，一种是有参的。一、继承Thread线程类：通过继承Thread类，重写run方法，子类对象就可以调用start方法启动线程，JVM就会调用此线程的run方法。代码如下：public class MyThread extends Thread {public MyThread() {super();}@...
java开启子线程的方法及优化
sinat_32176267的博客
08-22 1万+
1.new Thread的弊端 执行一个异步任务你还只是如下new Thread吗？ 1 2 3 4 5 6 7 new Thread(new Runnable() {        @Override     public void run() {         // TODO Au...
java主线程结束和子线程结束之间的关系
u013905744的专栏
06-26 2万+
情况1：正常情况下，主线程启动了子线程，主线程、子线程各自执行，彼此不受影响。（如评论所述，确实有问题，main线程执行完成之后，java虚拟机就退出了，那是不是可以这样猜想，main线程退出，那么Lift off thread也会退出，导致虚拟机中没有线程运行了，于是退出进程？请大神解释） 当你在run一个Java application的时候，这个时候系统会开一个进程。然后这个进程启动了Ma...
java匿名启动线程_使用匿名内部类：来创建线程的两种方式
weixin_39689297的博客
02-27 900
【Java】基础31：创建线程的两种方式谢谢你的观看。今天是我自学Java的第31天。你的观看便是对我最大的鼓励。话不多说，开始今天的学习：线程的创建有两种方式，昨天学习过其中的一种：创建一个类，继承自Java里的Thread类，并重写run方法。最后再创建自定义线程的对象，并调用start方法，这样就启动一个线程了。那么Thread到底是个什么东西呢？一、Thread类在Java里面线程就是一个...
Java子线程如何运行子程序方法,Java入门:线程
weixin_32703763的博客
03-10 652
相关概念进程是操作系统管理的，每个进程都拥有自己独立的内存空间，拥有自己独立的一整套变量，进程和进程之间不共享内存。多线程线程是同一个进程中的多个线程，他们共享内存和变量。线程是轻量级的进程，线程是进程的组成部分，是进程中某个单一顺序的控制流，又称为轻量进程。进程是线程组成的，线程只能在一个进程中的内部执行。创建线程的资源消耗比创建进程小很多。进程与进程之间，在内存方面是独立的，而同一个进程的各个...
Java_多线程-在方法中开启子线程
WY001的博客
02-27 1033
public void scienceArchive(List<FinishedFile> list) throws Exception { System.out.println("主线程开始。。。。。"); //开启子线程 ThreadFactory scanerThreadFactory = new ThreadFactoryBuilder() .setNameFormat("子-%d").build(); Ex.
Java基础强化教程——张孝祥讲授
"Java基础加强--张孝祥版.ppt" 这份资料是张孝祥主讲的Java基础强化课程，由传智播客提供。课程旨在提升学员的Java编程技能，内容涵盖了诸多Java进阶主题，包括但不限于Eclipse的使用技巧、静态导入、可变参数、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值