多线程

什么是线程？

线程(Thread)是一个程序内部的一条执行路径。
我们之前启动程序执行后，main方法执行其实就是一条单独的执行路径
程序中如果只有一条执行路径，那么这个程序就是单线程的程序。

多线程是什么？

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

多线程的创建

Thread类

Java是通过java.lang.Thread类来代表线程的。
按照面向对象的思想，Thread类应该提供了实现多线程的方式。

方式一：继承Thread类

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

public class ThreadDemo01 {
    public static void main(String[] args) {
        //3.new一个线程对象
        Thread t = new MyThread();
        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，无法继承其他类，不利于拓展

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

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

把主线程任务放在子线程之前了。

这样主线程一直是先跑完的，相当于是一个单线程的效果了。

方式二：实现Runnable接口

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

public class ThreadDemo02 {
    public static void main(String[] args) {
        Runnable runnable = new MyRunable();
        Thread t = new Thread(runnable);
        t.start();
        for (int i = 0; i < 10; i++) {
        System.out.println("主线程开始执行:"+i);
        }
    }
}

class MyRunable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("子线程在执行："+i);
        }
    }
}

方式二优缺点：

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

多线程的实现方案二：实现Runnable接口(匿名内部类形式)

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

public class ThreadDemoOther02 {
    public static void main(String[] args) {
        //创建一个任务对象
        Runnable a = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("子线程1执行输出：" + i);
                }
            }
        };
        // 把任务对象交给Thread处理
        Thread t = new Thread(a);
        t.start();
        
            Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 5; i++) {
                        System.out.println("子线程2执行输出：" + i);
                    }
                }
            });
            t1.start();


            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 5; i++) {
                        System.out.println("子线程3执行输出：" + i);
                    }
                }
            }).start();

            new Thread(() -> {
                for (int i = 0; i < 5; i++) {
                    System.out.println("子线程4执行输出：" + i);
                }
            }).start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出：" + i);
        }
        }
    }
output:
子线程2执行输出：0
子线程2执行输出：1
子线程2执行输出：2
子线程2执行输出：3
子线程2执行输出：4
子线程1执行输出：0
子线程1执行输出：1
子线程1执行输出：2
子线程1执行输出：3
子线程1执行输出：4
主线程执行输出：0
主线程执行输出：1
主线程执行输出：2
主线程执行输出：3
主线程执行输出：4
子线程4执行输出：0
子线程4执行输出：1
子线程4执行输出：2
子线程4执行输出：3
子线程4执行输出：4
子线程3执行输出：0
子线程3执行输出：1
子线程3执行输出：2
子线程3执行输出：3
子线程3执行输出：4

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

多线程的实现方案三：利用Callable、FutureTask接口实现

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

public class ThreadDemo03 {
    public static void main(String[] args) {
        Callable<String> call = new myCallable(100);
        //FutureTask对象的作用：是Runnable的对象(实现了Runnable接口)，可以交给Thread了
        FutureTask<String> f = new FutureTask<>(call);
        Thread t = new Thread(f);
        t.start();

        Callable<String> call2 = new myCallable(200);
        FutureTask<String> f2 = new FutureTask<>(call2);
        Thread t2 = new Thread(f2);
        t2.start();

        try {
            String rs1 = f.get();
            System.out.println(rs1);
        } catch (Exception e) {
            e.printStackTrace();
        }

        try {
            String rs2 = f2.get();
            System.out.println(rs2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class myCallable implements Callable<String> {
    private int n;
    public myCallable(int n) {
        this.n = n;
    }

    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= n; i++) {
            sum += i;
        }
        return "子线程结果是：" + sum;
    }
}
output:
子线程结果是：5050
子线程结果是：20100

FutureTask的API

方法名称	说明
public FutureTask<>(Callable call)	把Callable对象封装成FutureTask对象。
public V get() throws Exception	获取线程执行call方法返回的结果

Thread的常用方法

Thread常用API说明

Thread常用方法：获取线程名称getName()、设置名称setName()、获取当前线程对象currentThread()。
至于Thread类提供的诸如：yield、join、interrupt、不推荐的方法stop、守护线程、线程优先级等线程的控制方法，在开发中很少使用。

Thread类获得当前线程的对象

注意：

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

public class ThreadDemo01 {
    // main方法是由主线程负责调度的
    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(m.getName()+"输出："+i);
        }
    }
    
    public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+"输出："+i);
        }
    }
}
output:
Thread-0
Thread-1
main
main输出：0
Thread-1输出：0
Thread-1输出：1
Thread-1输出：2
Thread-1输出：3
Thread-1输出：4
main输出：1
main输出：2
main输出：3
main输出：4
Thread-0输出：0
Thread-0输出：1
Thread-0输出：2
Thread-0输出：3
Thread-0输出：4

Thread的构造器

方法名称	说明
public Thread(String name)	可以为当前线程指定名称
public Thread(Runnable target)	封装Runnable对象为线程对象
public Thread(Runnable target, String name)	封装Runnable对象为线程对象，并指定线程名称

Thread类的线程休眠方法

方法名称	说明
public static void sleep(long time)	让当前线程休眠指定的时间后再继续执行，单位为毫秒

public class ThreadDemo02 {
    public static void main(String[] args)throws Exception {
        for (int i = 1; i <= 5; i++) {
            System.out.println("主线程输出："+i);
            if (i==3){
                //让线程进入3秒休眠状态
                Thread.sleep(3000);
            }
        }
    }
}

线程安全

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

线程安全问题

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

出现的原因：

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

线程安全问题案例模拟

案例：取钱业务

需求：

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

分析：

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

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

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

/**
	共享账户类
*/
public class Account {
    private String cardID;//卡号
    private double money;//余额

    public Account() {
    }

    /**
     * 小明 小红取钱
     */
    public void drawMoney(double money) {
        //1.先获取是谁来取钱，线程的名字就是人名
        String name = Thread.currentThread().getName();
        //1.判断账户是否有钱
        if (this.money >= money) {
            //取钱
            System.out.println(name+"成功取出了"+money+"元");
            //更新余额
            this.money -= money;
            System.out.println(name+"取款后剩余："+this.money);

        }else {
            System.out.println(name+"来取钱，余额不足！");
        }
    }

    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 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);
    }
}
output:
小红成功取出了100000.0元
小明成功取出了100000.0元
小明取款后剩余：-100000.0
小红取款后剩余：0.0

线程同步

同步思想概述

线程同步

为了解决线程安全问题

取钱案例出现问题的原因？
- 多个线程同时执行，发现钱都是够的。
如何才能保证线程安全呢？
- 让多个线程实现先后依次访问共享资源，这样就解决了安全问题

线程同步的核心思想

加锁，把共享资源进行上锁，每次只能一个线程进入，访问完毕后解锁，然后其他线程才能进来。

方式一：同步代码块

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

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

锁对象要求

理论上：锁对象只要对于当前同时执行的线程来说是同一个对象即可。

/**
    小红小明在此取钱
 */
public void drawMoney(double money) {
    //看谁来这里取钱
    String name = Thread.currentThread().getName();
    //  同步代码块
    // 小明 小红
    // this == acc 共享账户
    synchronized (this) {
        //判断余额是否足够
        if (this.money>=money){
            //取钱
            System.out.println(name+"取钱成功，本次取款:"+money);
            //更新余额
            this.money-=money;
            System.out.println(name+"取款后，剩余："+this.money);
        }else {
            System.out.println(name+"取款余额不足！");
        }
    }
}

锁对象用任意唯一的对象好不好呢？

不好，会影响其他无关线程的执行。

锁对象的规范要求

规范上：建议使用共享资源作为锁对象
对于实例方法建议使用this作为锁对象。

对于静态方法，建议使用字节码（类名.class）对象作为锁对象

/**
    假设100个人来调用这个方法，
 */
public static void run(){
    synchronized (Account.class){
        //这样每次就只能有一个人来调用
    }
}

方式二：同步方法

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

格式：

修饰符 synchronized 返回值类型	方法名称(形参列表){
    	操作共享资源
}

public synchronized void drawMoney(double money) {
    String name = Thread.currentThread().getName();

    if (this.money>=money){
        System.out.println(name+"取钱成功！取了"+money+"元");
        //更新余额
        this.money-=money;
        System.out.println(name+"取款后剩余"+this.money);
    }else {
        System.out.println(name+"余额不足！");
    }
}

同步方法底层原理

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

是同步代码块好还是同步方法好一点？

同步代码块锁的范围更小，同步方法锁的范围更大

Lock锁

为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock，更加灵活、方便
Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作
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) {
        String name = Thread.currentThread().getName();
        lock.lock();//上锁
        try {
            if (this.money >= money) {
                System.out.println(name + "取钱成功！取了" + money + "元");
                //更新余额
                this.money -= money;
                System.out.println(name + "取款后剩余" + this.money);
            } else {
                System.out.println(name + "余额不足！");
            }
        } finally {
            lock.unlock();//释放锁
        }
    }
}

线程通信

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

所谓线程通信就是线程间相互发送数据。

线程通信常见形式

通过共享一个数据的方式实现。
根据共享数据的情况决定自己该怎么做，以及通知其他线程怎么做。

线程通信实际应用模型

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

线程通信案例模拟

模拟手机接电话系统，有电话就接听，没有电话就等待、
线程通信的前提：线程通信通常是在多个线程操作同一个共享资源的时候需要进行通信，切要保证线程安全。

/**
    模拟线程通信，来电提醒线程，  接电话线程
 */
public class Phone {
    private boolean flag = false;
    public void run(){
    //a,负责来电提醒的线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    while (true) {
                        synchronized (Phone.this){
                            if (!flag){
                                //代表有来电提醒
                                System.out.println("有电话正在呼入！！");
                                flag = true;//代表继续等待呼入电话
                                Phone.this.notify();
                                Phone.this.wait();
                            }
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();

        //b,负责接电话线程，正式接听了
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    //不断的接听电话
                    while (true) {
                        synchronized (Phone.this){
                            if (flag){
                                //可以接听电话了
                                System.out.println("电话接听中，通话了5分钟结束了！");
                                flag = false;//代表继续等待呼入电话
                                Thread.sleep(5000);
                                //唤醒别人，等待自己
                                Phone.this.notify();
                                Phone.this.wait();
                            }
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }

    public static void main(String[] args) {
        //1,创建一部手机对象
        Phone huawei = new Phone();
        huawei.run();
    }
}
output:
有电话正在呼入！！
电话接听中，通话了5分钟结束了！
有电话正在呼入！！
电话接听中，通话了5分钟结束了！

Object类的等待和唤醒方法：

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

注意：

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

线程池

线程池概述

什么是线程池？

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

不使用线程池的问题

如果用户每发起一个请求，后台就创建一个新的线程来处理，下次新任务来了又要创建新线程，而创建新线程的开销是很大的，这样会严重影响系统的性能。

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

谁代表线程池？

JDK5.0起提供了线程池的接口：ExecutorService

如何得到线程池对象

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

ThreadPoolExecutor构造器的参数说明

线程池常见面试题

临时线程什么时候创建？

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

什么时候会开始拒绝任务?

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

小结

谁代表线程池？

ExecutorService接口

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

线程池处理Runnable任务

ThreadPoolExecutor创建线程池对象示例

ExecutorService

ExecutorService的常用方法

方法名称	说明
void execute(Runnable command)	执行任务/命令，没有返回值，一般用来执行 Runnable任务
Future submit(Callable task)	执行任务，返回未来任务对象获取线程结果，一般拿来执行Callable任务
void shutdown()	等任务执行完毕后关闭线程池
List shutdownNow()	立刻关闭，停止正在执行的任务，并返回队列中未执行的任务

新任务拒绝策略

策略	详解
ThreadPoolExecutor.AbortPolicy	丢弃任务并抛出RejectedExecutionException异常。是默认的策略
ThreadPoolExecutor.DiscardPolicy	丢弃任务，但是不抛出异常这是不推荐的做法
ThreadPoolExecutor.DiscardOldestPolicy	抛弃队列中等待最久的任务然后把当前任务加入队列
ThreadPoolExecutor.CallerRunsPolicy	由主线程负责调用任务的run()方法从而绕过线程池直接执行

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println(Thread.currentThread().getName() + "输出了：HelloWorld ==>" + i);
        }
            try {
                System.out.println(Thread.currentThread().getName()+"本任务与线程绑定了，线程进入休眠了");
                Thread.sleep(5000000);
            } 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();//  会等待全部任务执行完毕之后再关闭
    }
}
output:
pool-1-thread-2输出了：HelloWorld ==>1
pool-1-thread-2输出了：HelloWorld ==>2
pool-1-thread-2输出了：HelloWorld ==>3
pool-1-thread-2输出了：HelloWorld ==>4
pool-1-thread-3输出了：HelloWorld ==>1
pool-1-thread-2输出了：HelloWorld ==>5
pool-1-thread-1输出了：HelloWorld ==>1
pool-1-thread-1输出了：HelloWorld ==>2
pool-1-thread-1输出了：HelloWorld ==>3
pool-1-thread-3输出了：HelloWorld ==>2
pool-1-thread-3输出了：HelloWorld ==>3
pool-1-thread-3输出了：HelloWorld ==>4
pool-1-thread-3输出了：HelloWorld ==>5
pool-1-thread-1输出了：HelloWorld ==>4
pool-1-thread-1输出了：HelloWorld ==>5
pool-1-thread-2本任务与线程绑定了，线程进入休眠了
pool-1-thread-3本任务与线程绑定了，线程进入休眠了
pool-1-thread-1本任务与线程绑定了，线程进入休眠了
pool-1-thread-4输出了：HelloWorld ==>1
pool-1-thread-4输出了：HelloWorld ==>2
pool-1-thread-4输出了：HelloWorld ==>3
pool-1-thread-4输出了：HelloWorld ==>4
pool-1-thread-4输出了：HelloWorld ==>5
pool-1-thread-4本任务与线程绑定了，线程进入休眠了
pool-1-thread-5输出了：HelloWorld ==>1
pool-1-thread-5输出了：HelloWorld ==>2
pool-1-thread-5输出了：HelloWorld ==>3
pool-1-thread-5输出了：HelloWorld ==>4
pool-1-thread-5输出了：HelloWorld ==>5
pool-1-thread-5本任务与线程绑定了，线程进入休眠了
Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task Thread[Thread-0,5,main] rejected from java.util.concurrent.ThreadPoolExecutor@378bf509[Running, pool size = 5, active threads = 5, queued tasks = 5, completed tasks = 0]

线程池处理Callable任务

public class MyCallable implements Callable<String> {
    private int n;

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

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

    }
}
output:
pool-1-thread-1执行1-100的结果是:4950
pool-1-thread-2执行1-200的结果是:19900
pool-1-thread-3执行1-300的结果是:44850
pool-1-thread-2执行1-400的结果是:79800
pool-1-thread-3执行1-500的结果是:124750

线程池如何处理Callable任务，并得到任务执行完后返回的结果
- 使用ExecutorService的方法：
- Future submit(Callable command)

Executors工具类实现线程池

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

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

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

public class ThreadPoolDemo3 {
    public static void main(String[] args) {
        //1.创建固定线程数的线程池
        ExecutorService pool = Executors.newFixedThreadPool(3);

        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
    }
}
output:
pool-1-thread-1输出了：HelloWorld ==>1
pool-1-thread-1输出了：HelloWorld ==>2
pool-1-thread-3输出了：HelloWorld ==>1
pool-1-thread-3输出了：HelloWorld ==>2
pool-1-thread-3输出了：HelloWorld ==>3
pool-1-thread-3输出了：HelloWorld ==>4
pool-1-thread-3输出了：HelloWorld ==>5
pool-1-thread-1输出了：HelloWorld ==>3
pool-1-thread-1输出了：HelloWorld ==>4
pool-1-thread-1输出了：HelloWorld ==>5
pool-1-thread-2输出了：HelloWorld ==>1
pool-1-thread-2输出了：HelloWorld ==>2
pool-1-thread-2输出了：HelloWorld ==>3
pool-1-thread-2输出了：HelloWorld ==>4
pool-1-thread-2输出了：HelloWorld ==>5
pool-1-thread-3本任务与线程绑定了，线程进入休眠了
pool-1-thread-1本任务与线程绑定了，线程进入休眠了
pool-1-thread-2本任务与线程绑定了，线程进入休眠了

Executors使用可能存在的陷阱

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

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

定时器

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

定时器的实现方法

方式一：Timer
方式二：ScheduledExecutorService

Timer定时器

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

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

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

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

public class TimerDemo01 {
    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() + "定时器BBB开始执行一次" + 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, 2000);
    }
}
output:
Timer-0定时器AAA开始执行一次Sat Jan 22 23:26:42 CST 2022
Timer-0定时器BBB开始执行一次Sat Jan 22 23:26:47 CST 2022
Exception in thread "Timer-0" java.lang.ArithmeticException: / by zero
	at com.csl.d8_timer.TimerDemo01$2.run(TimerDemo01.java:28)
	at java.base/java.util.TimerThread.mainLoop(Timer.java:556)
	at java.base/java.util.TimerThread.run(Timer.java:506)

ScheduledExecutorService定时器

ScheduledExecutorService是jdk 1.5中引入了并发包，目的是为了弥补Timer的缺陷，ScheduledExecutorService内部为线程池

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

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

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");
                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() + "执行输出：BBB");
                System.out.println(10 / 0);
            }
        }, 0, 2, TimeUnit.SECONDS);

        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行输出：CCC");
            }
        }, 0, 2, TimeUnit.SECONDS);
    }
}
output:
pool-1-thread-2执行输出：BBB
pool-1-thread-3执行输出：CCC
pool-1-thread-1执行输出：AAA
pool-1-thread-3执行输出：CCC
pool-1-thread-3执行输出：CCC
pool-1-thread-2执行输出：CCC

线程并发与并行

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

并发的理解

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

并行的理解

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

线程的生命周期

posted @ 2022-01-22 23:53 tryAgainCs 阅读(31) 评论(0) 编辑收藏举报

刷新页面返回顶部

再试一次Again

多线程

多线程