JavaSE基础学习——多线程

最新推荐文章于 2023-04-03 22:01:12 发布

KnightZer0

最新推荐文章于 2023-04-03 22:01:12 发布

阅读量123

点赞数

文章标签： java idea

本文链接：https://blog.csdn.net/weixin_44018911/article/details/124320353

版权

1. 多线程的创建

1.1 方式一：继承Thread类

定义一个子类MyThread继承线程类java.lang.Thread，重写run()方法
创建MyThread类的对象
调用线程对象的start()方法启动线程（启动后还是执行run方法的）

/**
    目标：多线程的创建方式一：继承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，无法继承其他类，不利于扩展。

注意：

调用start启动线程而不是直接调用run方法
将子线程任务放在主线程任务之前

1.2 方式二：

1.2.1 实现Runnable接口

定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法
创建MyRunnable任务对象
把MyRunnable任务对象交给Thread处理
调用线程对象的start()方法启动线程

方式二优缺点：

优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强
缺点：编程多一层对象包装，如果线程有执行结果是不可以直接返回的

1.2.2 实现Runnable接口（匿名内部类形式）

可以创建Runnable的匿名内部类对象
交给Thread处理
调用线程对象的start()启动线程

/**
    目标：学会线程的创建方式二（匿名内部类形式）
 */
public class ThreadDemo2Other {
    public static void main(String[] args) {
        // 3、创建一个任务对象
        Runnable target = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("子线程执行输出1：" + i);
                }
            }
        };
        // 4、把任务对象交给Thread处理
        Thread t = new Thread(target);
        // 5、启动线程
        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);
        }
    }
}

1.3 方式三：利用Callable、FutureTask接口实现

得到任务对象
定义类实现Callable接口，重写call方法，封装要做的事情
用FutureTask把Callable对象封装成线程任务对象
把线程任务对象交给Thread处理
调用Thread的start方法启动线程，执行任务
线程执行完毕后，通过FuturreTask的get方法去获取任务执行的结果。

/**
    目标：学会线程的创建方式三：实现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);
        // 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任务没有执行完毕，这里的代码会等待，直到线程1跑完才提取结果。
            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;
    }
}

方式三优缺点：

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

3种方式对比
在这里插入图片描述

2. Thread常用API

有很多线程在执行的时候，如何去区分这些线程

需要使用Thread的常用方法：getName()、setName()、currentThread()等

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

/**
    目标：线程的API
 */
public class ThreadDemo01 {
    // main方法是由主线程负责调度的
    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类的线程休眠方法

/**
    目标：线程的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);
            }
        }
    }
}

3. 线程安全

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

4. 线程同步

为了解决线程安全问题
核心思想：
加锁，把共享资源进行上锁，每次只能一个线程进入访问完毕以后解锁，然后其他线程才能进来。

4.1 方式一：同步代码块

作用：把出现线程安全问题的核心代码给上锁
原理：每次只能一个线程进入，执行完毕后自动解锁，其他线程才可以进来执行

public void drawmoney(double money) {
        // 0、获取是谁来取钱，线程的名字就是人名
        String name = Thread.currentThread().getName();
        // 同步代码块
        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 + "来取钱，余额不足！");
            }
        }
    }

锁对象的规范要求：

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

4.2 方式二：同步方法

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

同步方法底层原理
同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码
如果方法是实例方法：同步方法默认用this作为锁对象。但是代码要高度面向对象！
如果方法是静态方法：同步方法默认用类名.class作为的锁对象

4.3 Lock锁

为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock，更加灵活、方便。
Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作。
Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来构建Lock锁对象。

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(); // 解锁
        }

    }
}

5. 线程池【重点】

5.1 线程池概述

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

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

在这里插入图片描述
ThreadPoolExecutor构造器的参数说明

临时线程什么时候创建？

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

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

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

5.3 线程池处理Runnable任务

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(10000000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class ThreadPoolDemo1 {
    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(); // 会等待全部任务执行完毕之后再关闭

    }
}

5.4 线程池处理Callable任务

/**
    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 Thread.currentThread().getName() + "执行 1-" + n + "的和， 结果是：" + sum;
    }
}

public class ThreadPoolDemo2 {
    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(500));

//        String rs = f1.get();
//        System.out.println(rs);

        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());


    }
}

5.5 Executors工具类实现线程池

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

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

Executors不适合做大型互联网场景的线程池方案，建议使用ThreadPoolExecutor来制定线程池参数，这样可以明确线程池的运行规则，规避资源耗尽的风险

6. 补充知识：定时器

6.1 方式一：Timer

在这里插入图片描述
Timer定时器的特点和存在的问题

Timer是单线程，处理多个任务按照顺序执行，存在延时与设置定时器的时间有出入
可能因为其中的某个任务的异常使Timer线程死掉，从而影响后续任务执行

6.2 ScheduledExecutorService定时器（推荐）

在这里插入图片描述

public class TimerDemo2 {
    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(100000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, 0, 2, TimeUnit.SECONDS);

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

7. 补充知识：线程的并发并行、生命周期

7.1 线程的并发并行

并发：CPU分时轮询的执行线程
并行：同一个时刻同时在执行

7.2 线程的生命周期

在这里插入图片描述

KnightZer0

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
JavaSE基础学习——多线程

1. 多线程的创建1.1 方式一：继承Thread类定义一个子类MyThread继承线程类java.lang.Thread，重写run()方法创建MyThread类的对象调用线程对象的start()方法启动线程（启动后还是执行run方法的）/** 目标：多线程的创建方式一：继承Thread类实现 */public class ThreadDemo1 { public static void main(String[] args) { // 3、new一个新线
复制链接

扫一扫