7382 字
37 分钟
Java中的多线程
2023-05-19
2023-12-08
Java
JavaSE

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

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

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

两个取钱线程共享同一个 Account，但余额判断和扣款之间没有互斥保护。如果两者都在第一次扣款完成前通过余额检查，就可能都进入取款分支，破坏余额不能被重复支取的约束。问题在于检查与更新不是一个不可分割的操作；某次看似正常的打印顺序并不能证明线程安全，也不能把某个最终余额当作每次运行的固定结果。

解决方法：线程同步#

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

① 同步代码块#

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 + "来取钱，余额不足！");
        }
    }
}

结果如下：

同步代码块把余额检查、取款提示和余额更新都放在同一个 Account 对象的监视器保护下。按本例初始余额与取款金额，先获锁的一方完成扣款后，另一方再检查时余额已不足；谁先取到钱仍由调度决定。关键不是指定打印顺序，而是让所有访问同一账户的取款线程使用同一把锁，避免同时通过旧余额检查。

② 同步方法#

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

运行结果

这里三个存钱线程与两个取钱线程围绕同一账户协作：存钱逻辑检查余额是否为零，取钱逻辑检查余额是否足够，并通过账户对象的 notifyAll() 与 wait() 传递继续工作的机会。wait() 会释放该对象的监视器，notifyAll() 不会立即释放锁，也不保证谁先执行。实际使用应在 while 条件循环中等待并在醒来后重查条件，不能把本例的 if 与固定人物交替当成可靠的生产者消费者协议。

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)执行任务，返回未来任务对象获取线程结果，一般用于执行Callable任务
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();    //等待任务执行完毕再关闭
    }
}

拒绝策略样例：
本例线程池的核心线程数为三、最大线程数为五，等待队列容量为五，并配置 AbortPolicy。在前面提交的任务仍被长时间休眠占住、尚未完成的条件下，前三个任务启动核心线程，接着五个任务入队，再来两个任务使用扩展线程；继续提交就会触发拒绝并抛出 RejectedExecutionException。这是配置和任务占用情况的推导，不代表任何负载下第十一个任务都必然被拒绝。

线程池运行样例：
每次 execute(target) 都提交一次 Runnable 执行，即使传入同一个任务对象，也不代表线程池只执行一次。任务先循环打印，再进入长时间休眠；休眠期间工作线程仍被这次任务占用，队列中的任务必须等待工作线程腾出位置。线程复用发生在一次任务结束之后，因此不能把多个线程名称的交错输出等同于队列任务已经全部完成，也不应依赖输出的固定顺序。

③ 线程池处理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());
    }
}

线程池运行样例：
四次 submit 分别提交参数为一百、二百、三百和四百的 MyCallable，每个任务按前面的 call() 实现累加从一到该上限的整数，并把说明字符串作为结果。主线程按 f1、f2、f3、f4 的顺序调用 get()，所以结果的读取顺序由这几行代码决定，并不表示任务按同样顺序完成；若对应任务尚未结束，get() 会等待，任务失败则通过 Future 暴露异常。

④ （重要！） 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任务的影响
        // 其次，如果中间某个线程异常，其余线程都死亡
    }
}

运行样例如下:
两个任务都提交给同一个 Timer，而 Timer 只有一条执行任务的线程。任务 A 内部休眠五秒时，这条线程仍被占用，任务 B 即使已到计划时间也只能等待；设置两秒周期并不保证任务能准点开始，也不能简单把实际周期恒定相加成七秒。若任务抛出未捕获的运行时异常并终止 Timer 线程，其余待调度任务也会受到影响，因此应把串行占用与定时参数分别理解。

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

运行样例如下：
本例创建三条工作线程，分别周期调度任务 A、B、C。A 长时间休眠会占用一条工作线程，但同一周期任务不会因此并发重入；B 的除零异常会终止 B 这次周期任务后续的调度，而不是让整个线程池和 C 一起停止。只要仍有可用工作线程，C 可以继续被调度，但线程池资源不足时其他任务仍会延迟，因此“互不影响”应理解为任务异常被隔离，而非无条件准点执行。

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

② 并发与并行#

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

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

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

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

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

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

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

Java 线程六种状态及典型转换条件

原理示意：NEW 调用 start() 后进入 RUNNABLE，后者同时包括等待调度与执行中的情况。竞争对象监视器失败进入 BLOCKED，等待其他线程动作可进入 WAITING，带时限的等待进入 TIMED_WAITING。wait() 释放监视器，醒来后还要重新竞争锁；sleep() 则不释放已经持有的锁，超时也不意味着马上得到执行机会。

注意以下几点：
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方法而死亡。
HTML5+CSS3总览
© 2026 Wang-nine. All Rights Reserved. / RSS / Sitemap
Powered by Astro & Fuwari