Java中的多线程使用以及总结（超详细~值得一看！）

本文链接：https://blog.csdn.net/qq_55748865/article/details/130806020

想要更好更炫酷的阅读体验，欢迎访问我的博客：https://wang-nine.github.io/
点击下面的超链接快速访问
我的博客
本篇文章的地址

详细的描述了Java中多线程的创建、使用、同步问题，以及线程池的创建、使用问题，详细的描述了定时器的创建和使用，详细的分析了Java中六种不同的线程转态以及转换。

文章目录

title: Java中的多线程
date: 2023-05-19 22:00:00
author: 枉玖
summary: Java中的多线程
categories: JavaSE

1.Java中的多线程创建

java中多线程的创建可以分为三种不同的形式：

① 继承Thread类

具体步骤：

1.定义一个类MyThread继承
2.创建MyThread对象
3.调用线程对象的start方法启动线程（启动后会自动执行MyThread中重写的run()方法）
具体的例子如下

public class ThreadDemo1 {
    public static void main(String[] args) {
        /**
         * 3.new一个线程对象
         */
        Thread t = new MyThread();
        /**
         * 4.调用start()方法执行线程
         */
        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);
        }
    }
}

注意：
1.为什么不直接调用run方法，而是调用start启动线程
答：直接调用run方法会当成普通方法执行，此时还是相当于单线程执行。
2.为什么主线程任务放在子线程之后？
答：否则会先执行主线程任务再执行子线程任务。

优缺点：
优点：编程简单
缺点：单继承的局限性，不能继承其他类，不便于扩展。

② 实现Runnable接口

具体步骤：

1.定义一个线程任务类MyRunnable实现Runnable接口，重写run方法
2.创建MyRunnable对象
3.把MyRunnable对象交给Thread处理
具体的例子如下

public class ThreadDemo2 {
    public static void main(String[] args) {
        /**
         * 2.创建MyRunnable对象
         */
        Runnable target = new MyRunnable();

        /**
         * 3.把MyRunnable对象交给Thread处理
         */
        Thread t = new Thread(target);
        t.start();

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


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

优缺点：
优点：扩展性强，可以继续继承和实现。
缺点：如果线程有执行结果不能直接返回。

注意：也可通过匿名内部类实现（建议的写法）

/**
 * 通过匿名内部类来实现
 */
new Thread(new MyRunnable() {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("匿名内部类子线程的输出" + i);

        }
    }
}).start();

③ 实现Callable接口，通过FutureTask接口接收返回值（JDK5新增）

1.得到任务对象
第一步：定义一个线程任务类MyCallable实现Callable接口，重写call方法，该方法可以返回结果
第二步：用Future吧Callable对象封装成线程任务对象
2.把线程任务对象交给Thread处理
3.调用Thread的start方法启动任务
4.线程执行完毕后，通过FutureTask的get方法获得结果

具体的例子如下

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

public class ThreadDemo3 {
    public static void main(String[] args) {
        /**
         * 3.创建任务对象
         */
        Callable<String> call1 = new MyCallable(100);

        /**
         * 4.把Callable任务对象交给FutureTask对象
         * FutureTask的作用1：FutureTask实现了Runnable接口，此时就可以交给Thread了
         * FutureTask的作用2：可以在线程执行完毕后调用get方法得到线程执行的结果
         */
        //Thread t = new Thread(call);  报错，Thread不能接收call对象
        FutureTask<String> f1 = new FutureTask<>(call1);

        /**
         * 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 {
            String rs1 = f1.get();   //直接调用call方法，可能还没有执行完，使用get时若发现线程未执行完会先等线程执行完毕
            System.out.println("第一个结果为：" + rs1);
        } catch (Exception e) {
           e.printStackTrace();
        }

        try {
            String rs2 = f2.get();   //直接调用call方法，可能还没有执行完，使用get时若发现线程未执行完会先等线程执行完毕
            System.out.println("第二个结果为：" + rs2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


/**
 * 1.定义一个实现类，实现Callable接口，记得声明结果的数据类型
 */
class MyCallable implements Callable<String> {
    /**
     * 2.重写call方法
     */

    private int n;

    public MyCallable(int n) {
        this.n = n;
    }

    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return "子线程执行的结果是" + sum;
    }
}

优缺点：
优点：扩展性强，可以继续继承和实现。
可以在线程执行完毕后获取线程执行的结果。
缺点：编程较为复杂。

注意：Callable 与 FutureTask 创建对象时都需要声明类型

2.Java中的多线程常用方法

① 线程名称有关的方法

方法名称	说明
void setName()	设置线程名称
String getName(String name)	获得线程名称
CuurentThread()	获取当前的线程对象，哪个线程执行，拿到哪个线程对象

也可在构造器中取名
public Thread(String name)
public Thread(Runnable target)
public Thread(Runnable target, String name)

② 线程休眠有关的方法

方法名称	说明
sleep(long time)	单位为ms

具体的例子如下

public class ThreadDemo1 {
    public static void main(String[] args) throws Exception {
        Thread t1 = new MyThread("一号线程");
        t1.start();
//        t1.setName("一号线程");
        System.out.println(t1.getName());

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

        //哪个线程执行，拿到哪个线程对象
        Thread m = Thread.currentThread();
        System.out.println(m.getName());
        for (int i = 1; i <= 5; i++) {
            System.out.println("Main线程输出" + i);
            if(i == 3)
                Thread.sleep(3 * 1000); //主线程休眠3000ms
        }
    }
}

线程的子类，自定义的线程MyThread

public class MyThread extends Thread{
    public MyThread(String name) {
        //让父类的构造器进行构造
        super(name);
    }

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

3.Java中的线程安全问题

问题描述

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

例如小明和小红有一个共同账户，余额为10万元，模拟两人同时取钱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) {
            //2.取钱
            System.out.println(name + "来取钱成功，吐出：" + money);
            //3.更新余额
            this.money -= money;
            System.out.println("取钱后剩余：" + this.money);
        } else {
            //4.余额不足
            System.out.println(name + "来取钱，余额不足！");
        }
    }

    /**
     * 获取
     * @return cardId
     */
    public String getCardId() {
        return cardId;
    }

    /**
     * 设置
     * @param cardId
     */
    public void setCardId(String cardId) {
        this.cardId = cardId;
    }

    /**
     * 获取
     * @return money
     */
    public double getMoney() {
        return money;
    }

    /**
     * 设置
     * @param money
     */
    public void setMoney(double money) {
        this.money = money;
    }

    public String toString() {
        return "Account{cardId = " + cardId + ", 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);
    }
}

③ 创建两个线程对象，传入同一个账户对象

④ 启动两个线程，去同一个账户对象中取钱10万

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

        /**
         * 2.创建两个线程对象，代表小明和小红同时取钱
         */
        new DrawThread(acc, "小明").start();
        new DrawThread(acc, "小红").start();
    }
}

注意会出现下面的错误样例：

在这里插入图片描述

解决方法：线程同步

针对上述错误解决线程安全问题：线程同步（同一个时刻仅有一个线程可以访问共享资源）

① 同步代码块

synchorized(同步锁对象) {
操作共享资源的代码（核心代码）
}

注意：同步锁对象对于不同的对象来说唯一即可，同一时间只能被一个人占用，因此可以使用字符串为同步锁对象，字符串在常量池中
注意：上述同步锁对象对于小明小红唯一，但是若有小黑小白另一家庭取钱，此时也会等待，此时会出问题。
锁对象使用任意的唯一对象可以吗？
答：不可以，会影响其他无关线程的执行。
锁对象的规范要求：使用共享资源作为锁对象
因此：对于实例方法：使用this作为锁对象
对于静态方法：使用字节码（类名.class)作为锁对象

实例代码如下(修改了上述的代码之后，结果正确)

public void DrawMoney(double money) {
    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("取钱后剩余：" + this.money);
        } else {
            //4.余额不足
            System.out.println(name + "来取钱，余额不足！");
        }
    }
}

结果如下：
在这里插入图片描述

② 同步方法

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

public synchronized void DrawMoney(double money) {     //同步方法
    String name = Thread.currentThread().getName(); //获取取钱人的姓名
    //1.判断账户中的钱是否足够
    if (this.money >= money) {
        //2.取钱
        System.out.println(name + "来取钱成功，吐出：" + money);
        //3.更新余额
        this.money -= money;
        System.out.println("取钱后剩余：" + this.money);
    } else {
        //4.余额不足
        System.out.println(name + "来取钱，余额不足！");
    }
}

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

注意，上述两种方法中，同步代码块性能较好，范围越小性能越好，相当于一个在厕所外面排队，一个在坑外面排队，但是同步方法更好些更直观，在实际应用中多数使用同步方法

③ 同步锁（JDK5后提供了新的锁对象Lock，更加的灵活方便）

Lock是接口，采用实现类ReentrantLock来构建Lock锁对象

常用api如下

方法名称	说明
public ReentrantLock()	获得Lock锁的实现类对象
void lock()	获得锁
void unlock()	释放锁

//用final修饰，锁对象是唯一且不可替换的
private final Lock lock = new ReentrantLock();
public void DrawMoney(double money) {     //同步方法
    String name = Thread.currentThread().getName(); //获取取钱人的姓名
    //1.判断账户中的钱是否足够
    lock.lock();    //上锁
    try {
        if (this.money >= money) {
            //2.取钱
            System.out.println(name + "来取钱成功，吐出：" + money);
            //3.更新余额
            this.money -= money;
            System.out.println("取钱后剩余：" + this.money);
        } else {
            //4.余额不足
            System.out.println(name + "来取钱，余额不足！");
        }
    } finally {
        lock.unlock();  //解锁
    }
}

注意：一、锁对象声明为final代表锁是唯一且不可替换的
二、unlock放在finally中，防止代码出错而不执行unlock导致程序卡死

4.Java中的多线程通信（综合以上内容的综合样例）

常用的模型：生产者与消费者模型

object中提供的等待唤醒方法如下

方法名称	说明
void wait()	当前线程等待并且释放所占锁，直到另外一个线程调用notify()或者notifyaAll
void notify()	唤醒正在等待的单个线程
void notufyAll()	唤醒正在等待的所有线程

上述方法应该使用当前同步锁对象调用
注意：一定是先唤醒别人在等待，相当于自己叫醒别人再晕过去，否则相当于自己先晕过去没法叫人。

实例代码如下
账户类：

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

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

    /**
     * 小红 小明：取钱
     *
     * @param money
     */
    public synchronized void DrawMoney(double money) {
        String name = Thread.currentThread().getName(); //取钱人
        try {
            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();
        }
    }


    /**
     * 亲爹 干爹 岳父：取钱
     *
     * @param money
     */
    public synchronized void depositMoney(double money) {
        String name = Thread.currentThread().getName(); //存钱人
        try {
            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 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() {
        //不断的存取前
        while (true) {
            acc.DrawMoney(100000);
            try {
                Thread.sleep(3 * 1000);     //每隔三秒取一次钱
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

存钱线程类：

/**
 * 取钱的线程类
 */
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.depositMoney(100000);
            try {
                Thread.sleep(2 * 1000);     //每隔两秒存一次钱
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

主程序：

public class ThreadDemo {
    public static void main(String[] args) {
        // 三个父亲线程（生产者） 两个孩子线程（消费者） 模拟存取钱通信思想（一存 一取）
        // 1.创建账户对象，代表五个人共同操作的账户
        Account acc = new Account("ICBC-999", 0);   //初始化零元

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

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

运行结果

在这里插入图片描述

5.线程池的创建以及使用

线程池是一个可以复用线程的技术。解决了每次都为新请求创建线程，导致开销较大的问题
JDK5.0起提供了代表线程池的接口：ExecutorService
得到线程池对象的两种办法：
一、使用ExecutorService的实现类ThreadPoolExecutor自己创建一个线程池对象。
二、使用Executors（线程池的工具类）调用方法放回不同特点的线程池对象。

① 线程池的API简介

ThreadPoolExecutor构造器：
public ThreadPoolExecutor（int corePoolSize
int maximumPoolSize,
long keepAliveTIme,
TimeUnit unit,
BlockingQueue workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
参数一：指定线程池的线程数量（核心线程）：corePoolsize -----> 不能小于0
参数二：指定线程池可支持的最大线程数：maximumPoolSize ------> 最大数量>=核心线程数量
参数三：指定临时线程的最大存活时间：keepAliveTime ------> 不能小于0
参数四：存活时间的单位（秒，分，时，天）：unit ------> 时间单位
参数五：指定任务队列：workQueue ------> 不能为null
参数六：指定用那个线程工厂创建线程：threadFactory ------> 不能为null
参数七：指定线程忙，任务慢的时候，新任务来了怎么办，即拒绝策略：handler ------> 不能为null

（重要！！！）注意两点：
临时线程什么时候创建：新任务提交时发现核心线程都在忙，任务队列满，还可以创建临时线程时才会创建。
什么时候开始拒绝任务：核心线程和临时线程都在忙，任务队列都满，新任务过来会拒绝。

ExecutorService的常用方法：

方法名称	说明
void execute(Runable command)	执行任务，无返回值，一般用于执行Runnable任务
Future submit(Callable Task	执行任务，返回未来任务对象获取线程结果，一般用于执行Runnable任务
void shutdown()	等待任务执行完毕后关闭线程池
List shutdownNow()	立即关闭，停止正在执行的任务，返回队列中未执行的任务

拒绝策略：

策略	详解
ThreadPoolExecutor.AbortPolicy	丢弃任务抛出RejectedExecutionException异常
ThreadPoolExecutor.DiscardPolicy	丢弃任务不抛出异常（不推荐）
ThreadPoolExecutor.DiscardOldestPolicy	抛弃等待最久的任务并把当前任务加入队列
ThreadPoolExecutor.CallerRunsPolicy	由主线程负责调用的run()方法绕过线程池直接执行，即来新任务主线程亲自服务

② 线程池处理Runnable任务

样例代码：
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(1000000);  //让其睡眠时间久一点，便于观察线程池的复用情况
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

线程池创建代码：

import java.util.concurrent.*;

public class threadPoolDemo1 {
    public static void main(String[] args) {
        // 1.创建线程池对象
        /**
         *     public ThreadPoolExecutor(int corePoolSize,
         *                               int maximumPoolSize,
         *                               long keepAliveTime,
         *                               TimeUnit unit,
         *                               BlockingQueue<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任务

样例代码（简单测试一下，Callable实现在上面写过，具体使用方式与Runnable一致）：

import java.util.concurrent.*;

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

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

线程池运行样例：
在这里插入图片描述

④ （重要！） Executors工具类实现线程池

Executors获得线程池的常用方法：

方法名称	说明
public static ExecutorService newCachedThreadPool()	线程数随着任务增加而增加，若线程任务执行完毕且空闲一段时间会被回收
public static ExecutorService newFixedThreadPool()	创建固定数量的线程池。若某个线程因为异常而结束，那么线程池会补充一个新线程代替它
public static ExecutorService newSingleThreadExecutor()	创建只有一个线程对象的线程池对象，如果该线程因为异常而结束，那么线程池会补充一个新线程
public static ScheduledExecutorService newScheduledThreadPool(int PoolSize)	创建一个线程池，可以实现在给定的延迟后运行任务，或者定期执行任务

注意：Executors的底层其实也是基于线程池的实现类ThreadPoolExecutor创建线程池对象
注意：大型并发环境使用Executors如果不注意可能会出现系统风险，例如阿里开发手册不建议使用Executors创建线程池对象，而是建议使用ThreadPoolExecutor自己创建

方法名称	存在问题
public static ExecutorService newCachedThreadPool()	允许请求的任务队列长度为Integer.MAX_VALUE，可能出现OOM错误(OutOfMemoryError)
public static ExecutorService newFixedThreadPool()	同上
public static ExecutorService newSingleThreadExecutor()	创建的线程数量上限为Integer.MAX_VALUE，线程数随着任务1:1增长，可能出现OOM错误(OutOfMemoryError)
public static ScheduledExecutorService newScheduledThreadPool(int PoolSize)	同上

6.补充知识

① 定时器

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

定时器的两种实现方式如下

Timer

构造器	说明
public Timer()	创建Timer定时器对象

方法	说明
public void schedule(TimerTask task, long delay, long period）	开启一个定时器，按照计划处理TimerTask任务，delay是延时，period是周期

注意：TimerTask是Runnable的实现类

存在的问题：
Timer是单线程，处理多个任务有序执行，存在演示与设置定时器的时间有出入
可能因为某个任务的异常使得Timer线程死掉，从而影响后续任务的执行

样例代码如下：

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

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() + "执行任务A~~~" + new Date());
                try {
                    Thread.sleep(5000); //休眠5s
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, 0, 2000); //三秒后执行，每隔两秒执行一次

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

        // 注意，本来A应该7s一次（2s间隔 + 5s睡眠），B应该2s一次
        // 实际情况与上述不符合，只存在一个线程，
        // B任务受到了A任务的影响
        // 其次，如果中间某个线程异常，其余线程都死亡
    }
}

运行样例如下:
在这里插入图片描述

ScheduledExecutorService

ScheduledExecutorService弥补了Timer的缺陷

Executors的方法	说明
public static ScheduledExecutorService newScheduledThreadPool(int PoolSize	得到线程池对象

ScheduledExecutorService的方法	说明
public Scheduled<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)	周期调度方法

优点：基于线程池，某个任务的执行情况不会影响其他任务的执行

样例代码如下：

import java.util.TimerTask;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

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() + "执行任务A~~~");
                //把该线程堵塞
                try {
                    Thread.sleep(100000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, 0, 2, TimeUnit.SECONDS);

        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行任务B~~~");
                System.out.println(10 / 0); //使该线程异常
            }
        }, 0, 3, TimeUnit.SECONDS);


        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行任务C~~~");
            }
        }, 0, 3, TimeUnit.SECONDS);
    }
}

运行样例如下：
在这里插入图片描述

异常不会影响
也不受其他任务的影响

② 并发与并行

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

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

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

③ （重点！！！）线程的生命周期

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

Java线程的状态：
Java总共定义了6种状态
6种状态都定义在Thread类的内部枚举类中。

线程6种状态的转换如下图

在这里插入图片描述

注意以下几点：
sleep()是睡眠，过程中不会释放锁对象，醒来后直接进入可运行状态
wait()是等待，过程中会释放锁对象，但是时间到了或者被notity时会重新获得锁对象，进入可运行状态

总结：

线程状态	描述
NEW（新建）	线程刚被创建，但是并未启动。
Runnable（可运行）	线程已经调用了start()等待CPU调度
Blocked（锁阻塞）	线程在执行的时候未竞争到锁对象，则该线程进入Blocked状态
Waiting（无限等待）	一个线程进入Waiting状态，另一个线程调用notify或者notifyAll方法才能够唤醒
Time Waiting（计时等待）	同waiting状态，有几个方法有超时参数，调用他们将进入Timed waiting状态。带有超时参数的常用方法有Thread.sleep和Object.wait
Teminated（被终止）	因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。