javase加强，十一、多线程

最新推荐文章于 2024-08-08 14:30:51 发布
最新推荐文章于 2024-08-08 14:30:51 发布
阅读量182 收藏
点赞数
分类专栏： Javase 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42403145/article/details/126111402
版权

文章目录

多线程的实现

  • 多线程的实现方案一：

    • 定义一个子类继承Thread类

    • 重写run方法

    • 创建子类对象

    • 调用子类对象的start方法启动线程

  • 优缺点：

    • 优点是编码简单
    • 缺点是存在单继承的局限，子类继承了Thread类之后不能继承其他类，不利于扩展

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

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

  • 不能把主线程任务放在子线程之前，因为这样主线程一直是先跑完的，相当于是一个单线程的效果了。

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);
        }
    }
}
  • 多线程实现方式二：实现Runnable接口
    • 定义一个线程任务类MyRunnable实现Runnable接口
    • 重写run方法
    • 创建MyRunnable任务对象
    • 把MyRunnable任务对象交给Thread处理。
    • 调用线程对象的start()方法启动线程
构造器说明
public Thread(String name)可以为当前线程指定名称
public Thread(Runnable target)封装Runnable对象成为线程对象
public Thread(Runnable target ，String name )封装Runnable对象成为线程对象，并指定线程名称
  • 优缺点
    • 线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强
    • 编程多一层对象包装，如果线程有执行结果是不可以直接返回的。
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的匿名内部类对象。
    • ②交给Thread处理。
    • ③调用线程对象的start()启动线程。
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);
        }
    }
}

  • 多线程实现方式三：利用Callable、FutureTask接口实现。

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

  • FutureTask的API

方法名称说明
public FutureTask<>(Callable call)把Callable对象封装成FutureTask对象。
public V get() throws Exception获取线程执行call方法返回的结果。
  • 方式三优缺点：
    • 优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。
    • 可以在线程执行完毕后去获取线程执行的结果。
    • 缺点：编码复杂一点。
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任务没有执行完毕，这里的代码会等待，直到线程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;
    }
}
  • 三种方式对比：
方式优点缺点
继承Thread类编程比较简单，可以直接使用Thread类中的方法扩展性较差，不能再继承其他的类，不能返回线程执行的结果
实现Runnable接口扩展性强，实现该接口的同时还可以继承其他的类。编程相对复杂，不能返回线程执行的结果
实现Callable接口扩展性强，实现该接口的同时还可以继承其他的类。可以得到线程执行的结果编程相对复杂

Thread常用API

  • 获取线程名称getName()、设置名称setName()、获取当前线程对象currentThread()
方法名称说明
String getName()获取当前线程的名称，默认线程名称是Thread-索引
void setName(String name)将此线程的名称更改为指定的名称，通过构造器也可以设置线程名称
方法名称说明
public static Thread currentThread()：返回对当前正在执行的线程对象的引用
  • 注意：
    • 1、此方法是Thread类的静态方法，可以直接使用Thread类调用。
    • 2、这个方法是在哪个线程执行中调用的，就会得到哪个线程对象。
方法名称说明
public Thread(String name)可以为当前线程指定名称
public Thread(Runnable target)封装Runnable对象成为线程对象
public Thread(Runnable target ，String name )封装Runnable对象成为线程对象，并指定线程名称
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);
        }
    }
}

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);
        }
    }
}
  • 线程休眠
方法名称说明
public static void sleep(long time)让当前线程休眠指定的时间后再继续执行，单位为毫秒。

线程安全

  • 线程安全问题出现的原因？

    • 存在多线程并发
    • 同时访问共享资源
    • 存在修改共享资源

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

    • ①：需要提供一个账户类，创建一个账户对象代表2个人的共享账户。
    • ②：需要定义一个线程类，线程类可以处理账户对象。
    • ③：创建2个线程对象，传入同一个账户对象。
    • ④：启动2个线程，去同一个账户对象中取钱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) {
        // 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;
    }

}

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

线程同步

同步代码块

  • 作用：把出现线程安全问题的核心代码给上锁。
  • 原理：每次只能一个线程进入，执行完毕后自动解锁，其他线程才可以进来执行。
  • 锁对象的规范要求
    • 规范上：建议使用共享资源作为锁对象。
    • 对于实例方法建议使用this作为锁对象。
    • 对于静态方法建议使用字节码（类名.class）对象作为锁对象。
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;
    }

//    // 100个线程人
//    public static void run(){
//        synchronized (Account.class){
//
//        }
//    }


    /**
      小明 小红
     */
    public void drawMoney(double money) {
        // 1、拿到是谁来取钱
        String name = Thread.currentThread().getName();
        // 同步代码块
        // 小明 小红
        // this == acc 共享账户
        synchronized (this) {
            // 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+"来取钱，余额不足！");
            }
        }
    }
}

同步方法

  • 把出现线程安全问题的核心方法给上锁。
  • 底层原理：
    • 同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。
    • 如果方法是实例方法：同步方法默认用this作为的锁对象。但是代码要高度面向对象！
    • 如果方法是静态方法：同步方法默认用类名.class作为的锁对象。
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;
    }

    /**
      小明 小红
       this == acc
     */
    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+"来取钱，余额不足！");
        }
    }
}

同步锁

  • Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来构建Lock锁对象。
方法名称说明
public ReentrantLock()获得Lock锁的实现类对象
  • Lock的API
方法名称说明
void lock()获得锁
void unlock()释放锁
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(); // 解锁
        }

    }
}

线程池

  • 一种可以复用线程的技术

  • 代表线程池的接口：ExecutorService

  • 得到线程池对象的方法

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

  • ThreadPoolExecutor构造器的参数说明

public ThreadPoolExecutor(int corePoolSize,
						int maximumPoolSize,
						long keepAliveTime,
						TimeUnit unit,
						BlockingQueue<Runnable> workQueue,
						ThreadFactory threadFactory,
						RejectedExecutionHandler handler)

  • 参数一：指定线程池的线程数量（核心线程）： corePoolSize ， 不能小于0

    参数二：指定线程池可支持的最大线程数： maximumPoolSize，最大数量 >= 核心线程数量

    参数三：指定临时线程的最大存活时间： keepAliveTime，不能小于0

    参数四：指定存活时间的单位(秒、分、时、天)： unit，时间单位

    参数五：指定任务队列： workQueue，不能为null

    参数六：指定用哪个线程工厂创建线程： threadFactory，不能为null

    参数七：指定线程忙，任务满的时候，新任务来了怎么办： handler，不能为null

  • 线程池常见面试题

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

  • 线程池处理Runnable任务

  • ExecutorService的常用方法

方法名称说明
void execute(Runnable command)执行任务/命令，没有返回值，一般用来执行 Runnable 任务
Future submit(Callable task)执行任务，返回未来任务对象获取线程结果，一般拿来执行 Callable 任务
void shutdown()等任务执行完毕后关闭线程池
ListshutdownNow()立刻关闭，停止正在执行的任务，并返回队列中未执行的任务
  • 新任务拒绝策略
策略详解
ThreadPoolExecutor.AbortPolicy丢弃任务并抛出RejectedExecutionException异常。是默认的策略
ThreadPoolExecutor.DiscardPolicy：丢弃任务，但是不抛出异常 这是不推荐的做法
ThreadPoolExecutor.DiscardOldestPolicy抛弃队列中等待最久的任务 然后把当前任务加入队列中
ThreadPoolExecutor.CallerRunsPolicy由主线程负责调用任务的run()方法从而绕过线程池直接执行
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(); // 会等待全部任务执行完毕之后再关闭（建议使用的）
    }
}
  • 线程池处理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 = 1; 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());
    }
}
  • Executors工具类实现线程池（有风险，大型互联网不要用）
  • Executors的底层其实也是基于线程池的实现类ThreadPoolExecutor创建线程池对象的。
  • Executors得到线程池对象的常用方法
方法名称说明
public static ExecutorService newCachedThreadPool()线程数量随着任务增加而增加，如果线程任务执行完毕且空闲了一段时间则会被回收掉。
public static ExecutorService newFixedThreadPool(int nThreads)创建固定线程数量的线程池，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程替代它。
public static ExecutorService newSingleThreadExecutor ()创建只有一个线程的线程池对象，如果该线程出现异常而结束，那么线程池会补充一个新线程。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)创建一个线程池，可以实现在给定的延迟后运行任务，或者定期执行任务。
public class ThreadPoolDemo3 {
    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()); // 已经没有多余线程了
    }
}

定时器

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

Timer

构造器说明
public Timer()创建Timer定时器对象
方法说明
public void schedule([TimerTask](file:///D:/course/基础阶段/API文档/docs/api/java.base/java/util/TimerTask.html) task, long delay, long period)开启一个定时器，按照计划处理TimerTask任务
  • Timer定时器的特点和存在的问题
    • 1、Timer是单线程，处理多个任务按照顺序执行，存在延时与设置定时器的时间有出入。
    • 2、可能因为其中的某个任务的异常使Timer线程死掉，从而影响后续任务执行。
public class TimerDemo1 {
    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() + "执行AAA~~~" + new Date());
//                try {
//                    Thread.sleep(5000);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
            }
        }, 0, 2000);

        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行BB~~~"+ new Date());
                System.out.println(10/0);
            }
        }, 0, 2000);

        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行CCC~~~"+ new Date());
            }
        }, 0, 3000);
    }
}

ScheduledExecutorService定时器

  • 优点：基于线程池，某个任务的执行情况不会影响其他定时任务的执行。
Executors的方法说明
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)得到线程池对象
ScheduledExecutorService的方法说明
public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)周期调度方法
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);

    }
}
数二150种子选手
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
EQQ代码简易版.zip适合javaSE 基于多线程面向对象思想，接口集合等基础技术
01-11
《基于JavaSE的EQQ代码简易版：多线程与面向对象实践》 在Java编程领域，Java Standard Edition（JavaSE）是学习的基础，它提供了丰富的API和强大的工具，为开发桌面应用程序、服务器端应用以及分布式系统提供了...
关于线程 thread (3)线程的同步
童年纸飞机的博客
03-22 462
同步问题的提出。 线程同步主要是为了防止多个线程访问同一个数据对象的时候，对数据造成破坏。因为从一开始我们就讲了，线程自身有的资源很少，大部分是和其他线程共享进程中的资源。 例如两个线程 A 和 B，都操作同一个对象，并且修改这个对象里面的数据。假设有两个线程，想改同一个字符串的内容。看看会有什么后果。 package Thread; public class ThreadDemo2 imple...
Java知识点二十二：多线程、继承Thread类 和 实现Runnable接口、start方法原理、线程同步
GQ的博客
06-12 655
程序：是为完成特定任务，用某种语言编写的一组特定指令的集合进程：线程：**单线程：**同一个时刻，只允许执行一个线程**多线程：**同一个时刻，可以执行多个线程，比如：一个qq进程，可以同时打开多个聊天窗口，一个迅雷进程，可以同时下载多个文件并发：同一个时刻，，造成一种：“貌似同时”的错觉，简单的来说，。并行：同一个时刻，。创建线程的两种方式：使用Thread：应用案例：​ 请编写程序,开启一个线程，该线程每隔1秒。在控制台输出“瞄瞄,我是小猫咪对上题改进:当输出80次唶嗒,我是小猫咪，结束该线程说明：
大数据 -- java14 多线程 线程池 同步安全机制
昭阳爱米彩的博客
04-14 788
1、Thread : 线程 创建多线程的第一种方式: 继承Thread类。 创建多线程的第二种方式: 实现Runnable接口。 创建多线程的第三种方式: 实现Callable接口。 第一种方法步骤: (1)创建一个自定义类继承Thread类。 (2)这个类要重写Thread类中的run方法。 为什么是run()方法呢？ 当线程启动之后，执行的代码逻辑仅是run.
高并发之——深度解析ScheduledFutureTask类源码
冰河的专栏
03-01 4354
JDK 1.5提供的ScheduledThreadPoolExecutor执行定时任务时，会将任务封装成ScheduledFutureTask对象。那么，ScheduledFutureTask对象有何特殊之处？今天，我们就一起来手撕ScheduledFutureTask类的源码，来深入理解ScheduledFutureTask类的细节。 类的层级关系 从ScheduledFutureTask类的定...
一个简单的线程池（仿java的ScheduledFuture）
键盘春秋的博客
04-17 1672
需求最近公司有一个奇葩的需求：让我把一个java的客户端插件转换为C#版本。 转换并不难，由于有java客户端的源码，基本只要照着“翻译”即可实现，实际上我是将java代码复制到C#工程中然后通过改bug的方式实现的。 由于java和C#很相似，这个干问题并不大，但是有几个java的库C#并没有。而且由于我想要将C#的DLL放到Unity中使用，所以没办法使用高版本的.NET库，导致我需要手动实
JavaSE笔记11111
10-15
JavaSE是Java标准版，是Java编程的基础，涵盖了面向对象编程、集合框架、I/O流、多线程和反射等多个核心知识点。 面向对象是Java的核心特性，它包括三大特征：继承、多态和封装。继承使得子类可以继承父类的属性和...
JavaSE总结及思维导图.zip
11-20
7. **多线程**：Java支持多线程编程，Thread类和Runnable接口是实现多线程的主要方式。通过线程同步机制（如synchronized关键字、wait()、notify()方法）来处理并发问题。 8. **反射机制**：反射允许我们在运行时...
javase+项目练习(一)
11-03
在本项目中，我们将深入理解和运用Java语言的关键特性，包括面向对象编程、异常处理、集合框架、IO流、多线程以及网络编程等。 首先，面向对象编程是Java的核心，我们需要掌握类、对象、继承、封装和多态这些概念。...
javase阶段15个实战项目代码
09-21
5. 多线程：多线程项目有助于理解并发编程，可能包括线程同步、线程池和异步操作的实现。 6. 网络编程：Java提供Socket编程接口，使得创建网络应用程序成为可能，如简单的聊天室或文件传输应用。 7. 数据库连接：...
合理使用线程池以及线程变量
栗少的博客
06-10 558
https://mp.weixin.qq.com/s/BdVqvm2wLNv05vMTieevMg
java 绑定线程池中的线程 BindThreadPool
u012233832的专栏
10-09 755
package com.sibo.concurrent; import io.netty.util.concurrent.DefaultEventExecutor; import io.netty.util.concurrent.EventExecutor; import java.util.concurrent.atomic.AtomicInteger; /** * @author YU...
Java线程池
豪猪的博客
02-13 331
什么是线程池（thread pool）？          在面向对象编程中，创建和销毁对象是很费时间的，因为创建一个对象要获取内存资源或者其它更多资源。在Java中更是如此，虚拟机将试图跟踪每一个对象，以便能够在对象销毁后进行垃圾回收。所以提高服务程序效率的一个手段就是尽可能减少创建和销毁对象的次数，特别是一些很耗资源的对象创建和销毁，这就是”池化资源”技术产生的原因。
[Thread] new Thread改造成ExecutorService线程池管理
prettyleg的博客
07-01 1005
new Thread改造成ExecutorService线程池管理1、new Thread的弊端2、通过Executors进行线程池管理Executors 提供另外3种线程池管理。newCachedThreadPool：newScheduledThreadPoolnewSingleThreadExecutor 1、new Thread的弊端 new Thread(new Runnable() { ...
【Spring Boot】高效配置管理: 易用性与灵活性并重
weixin_68020300的博客
08-07 1253
本文探讨了Spring Boot中多样化的配置读取方法及其应用场景，强调了配置管理的重要性，并展示了Spring Boot如何通过灵活多变的配置选项简化这一过程。此外，文章还展望了配置管理领域未来的技术趋势和发展方向。对于任何希望深入了解Spring Boot配置管理的开发者来说，这是一篇不容错过的好文。
C++ - 函数重载
jiaowenjie的专栏
08-06 329
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
伐木工 (100%用例)D卷 (Java&&Python&&C++&&Node.js&&C语言)
荆赫同艺的博客
08-07 232
一根 4米长的树木，伐木工不需要切割为 2*2，省去切割成本，直接整根树木交易，为 4*1，收益最大为 4。方式二: 3,2,2,3，但方式二，伐木工多切割一次，增加了切割成本却卖了一样的价格，因此并不是最优收益。一根 2 米长的树木，伐木工不切割，为2*1，收益最大为 2。一根5 米长的树木，伐木工切割为 2*3,收益最大为 6。输出最优收益时的各个树木长度，以空格分隔，按升序排列。一根 10 米长的树木，伐木工可以切割。方式一:3,4,4，也可以切割为。
Spring事务
c1tenj2的博客
08-07 436
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
反射和注解
最新发布
supercool7的博客
08-08 255
反射的基本步骤包括获取Class对象、获取类的信息（构造函数、方法、字段等），然后通过Constructor、Method、Field等类的实例进行具体的操作。注解以@符号开头，通常紧跟着一个标识符，后面可以跟一些参数，用于给类、方法、字段等添加元数据信息，这些信息可以在编译时、运行时被读取和处理。通过Class类，可以获取类的构造函数、方法、字段等信息，而不需要在编译时确定这些信息。Spring、SpringBoot、Mybatis等框架中都大量使用了反射机制。此外，开发者还可以定义自己的注解，通过。
JavaSE多线程与集合框架深度解析
本资源主要涵盖了Java标准版（JavaSE）的一些核心概念和重要特性，特别是关于多线程、常用类、枚举类与注解以及Java集合框架和泛型的深入讲解。以下是各章节的详细内容： 八、多线程 这部分介绍了多线程的基本概念...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值