Java-进阶篇【多线程】---08

1：多线程概叙

什么是线程？
线程(thread)是一个程序内部的一条执行路径。
我们之前启动程序执行后，main方法的执行其实就是一条单独的执行路径。
public static void main(String[] args) {
    // 代码…
    for (int i = 0; i < 10; i++) {
        System.out.println(i);
    }
    // 代码...
}

程序中如果只有一条执行路径，那么这个程序就是单线程的程序。
多线程是指从软硬件上实现多条执行流程的技术。

 2：多线程的创建　　之　　方式一：继承Thread类

Thread类
　　Java是通过 java.lang.Thread 类来代表线程的。 
　　按照面向对象的思想，Thread类应该提供了实现多线程的方式。
多线程的实现方案一：继承Thread类
　　定义一个子类MyThread继承线程类java.lang.Thread，
　　重写run()方法
　　创建MyThread类的对象
　　调用线程对象的start()方法启动线程（启动后还是执行run方法的）
方式一优缺点：
　　优点：编码简单
　　缺点：线程类已经继承Thread，无法继承其他类，不利于扩展。

1、为什么不直接调用了run方法，而是调用start启动线程。
　　直接调用run方法会当成普通方法执行，此时相当于还是单线程执行。
　　只有调用start方法才是启动一个新的线程执行。
2、把主线程任务放在子线程之前了。
　　这样主线程一直是先跑完的，相当于是一个单线程的效果了。

方式一是如何实现多线程的？
　　继承Thread类
　　重写run方法
　　创建线程对象
　　调用start()方法启动。
优缺点是什么？
　　优点：编码简单
　　缺点：存在单继承的局限性，线程类继承Thread后，不能继承其他类，不便于扩展

package com.itheima.d1_create;

/**
   目标：多线程的创建方式一：继承Thread类实现。
 */
public class ThreadDemo1 {
    public static void main(String[] args) {
        // 3、new一个新线程对象
        Thread t = new MyThread();
        // 4、调用start方法启动线程（执行的还是run方法）
        t.start();

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

/**
   1、定义一个线程类继承Thread类
 */
class MyThread extends Thread{
    /**
       2、重写run方法，里面是定义线程以后要干啥
     */
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行输出：" + i);
        }
    }
}

  3：多线程的创建　　之　　方式一：实现Runnable接口

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

Thread的构造器
　　public Thread(String name)    　　　　　　　　　　　　可以为当前线程指定名称
　　public Thread(Runnable target)    　　　　　　　　　　封装Runnable对象成为线程对象
　　public Thread(Runnable target ，String name )    封装Runnable对象成为线程对象，并指定线程名称

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

package com.itheima.d1_create;

/**
   目标：学会线程的创建方式二，理解它的优缺点。
 */
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);
        }
    }
}

package com.itheima.d1_create;

/**
   目标：学会线程的创建方式二(匿名内部类方式实现，语法形式)
 */
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);
        }
    }
}

4：多线程的创建　　之　　方式一：JDK 5.0新增：实现Callable接口

前2种线程创建方式都存在一个问题：
    他们重写的run方法均不能直接返回结果。
    不适合需要返回线程执行结果的业务场景。
怎么解决这个问题呢？
    JDK 5.0提供了Callable和FutureTask来实现。
    这种方式的优点是：可以得到线程执行的结果。

多线程的实现方案三：利用Callable、FutureTask接口实现。
　　1、得到任务对象
　　　　定义类实现Callable接口，重写call方法，封装要做的事情。
　　　　用FutureTask把Callable对象封装成线程任务对象。
　　2、把线程任务对象交给Thread处理。
　　3、调用Thread的start方法启动线程，执行任务
　　4、线程执行完毕后、通过FutureTask的get方法去获取任务执行的结果。
FutureTask的API
　　public FutureTask<>(Callable call)    　　　　　　把Callable对象封装成FutureTask对象。
　　public V get() throws Exception    　　　　　　　　获取线程执行call方法返回的结果。
方式三优缺点：
　　优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。
　　　　可以在线程执行完毕后去获取线程执行的结果。
　　缺点：编码复杂一点。

package com.itheima.d1_create;

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

/**
   目标：学会线程的创建方式三：实现Callable接口，结合FutureTask完成。
 */
public class ThreadDemo3 {
    public static void main(String[] args) {
        // 3、创建Callable任务对象
        Callable<String> call = new MyCallable(100);
        // 4、把Callable任务对象 交给 FutureTask 对象
        //  FutureTask对象的作用1： 是Runnable的对象（实现了Runnable接口），可以交给Thread了
        //  FutureTask对象的作用2： 可以在线程执行完毕之后通过调用其get方法得到线程执行完成的结果
        FutureTask<String> f1 = new FutureTask<>(call);
        // 5、交给线程处理
        Thread t1 = new Thread(f1);
        // 6、启动线程
        t1.start();

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

        try {
            // 如果f1任务没有执行完毕，这里的代码会等待，直到线程1跑完才提取结果。
            String rs1 = f1.get();
            System.out.println("第一个结果：" + rs1);
        } catch (Exception e) {
            e.printStackTrace();
        }

        try {
            // 如果f2任务没有执行完毕，这里的代码会等待，直到线程2跑完才提取结果。
            String rs2 = f2.get();
            System.out.println("第二个结果：" + rs2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

/**
    1、定义一个任务类 实现Callable接口  应该申明线程任务执行完毕后的结果的数据类型 【泛型声明返回结果为 String类型】
 */
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;
    }
}

5：Thread 常用API说明

Thread常用API说明
　　Thread常用方法：获取线程名称getName()、设置名称setName()、获取当前线程对象currentThread()
　　至于Thread类提供的诸如：yield、join、interrupt、不推荐的方法 stop 、守护线程、线程优先级等线程的控制方法，在开发中很少使用，
　　这些方法会在高级篇以及后续需要用到的时候再为大家讲解。

当有很多线程在执行的时候，我们怎么去区分这些线程呢？
　　此时需要使用Thread的常用方法：getName()、setName()、currentThread()等。

Thread获取和设置线程名称
　　String getName​()    　　　　　　获取当前线程的名称，默认线程名称是Thread-索引
　　void setName​(String name)    将此线程的名称更改为指定的名称，通过构造器也可以设置线程名称

Thread类获得当前线程的对象
　　public static Thread currentThread()：    返回对当前正在执行的线程对象的引用
注意
 1、此方法是Thread类的静态方法，可以直接使用Thread类调用。
 2、这个方法是在哪个线程执行中调用的，就会得到哪个线程对象。

Thread的构造器
　　public Thread(String name)    可以为当前线程指定名称
　　public Thread(Runnable target)    封装Runnable对象成为线程对象
　　public Thread(Runnable target ，String name )    封装Runnable对象成为线程对象，并指定线程名称

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

package com.itheima.d2_api;

public class MyThread extends Thread{
    public MyThread() {
    }

    public MyThread(String name) {
        // 为当前线程对象设置名称，送给父类的有参数构造器初始化名称 【直接创建线程的对象的时候就可以指定名字不需要setName去设置线程名字】
        super(name);
    }

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

package com.itheima.d2_api;
/**
    目标：线程的API
 */
public class ThreadDemo01 {
    // main方法是由主线程负责调度的
    public static void main(String[] args) {
        Thread t1 = new MyThread("1号");
        // t1.setName("1号");
        t1.start();
        System.out.println(t1.getName());

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

        // 哪个线程执行它，它就得到哪个线程对象（当前线程对象）
        // 主线程的名称就叫main  【获取主线程对象，修改名字】
        Thread m = Thread.currentThread();
        System.out.println(m.getName());
        m.setName("最牛的线程");

        for (int i = 0; i < 5; i++) {
            System.out.println( m.getName() + "输出：" + i);
        }
    }
}

package com.itheima.d2_api;
/**
    目标：线程的API
 */
public class ThreadDemo02 {
    // main方法是由主线程负责调度的
    public static void main(String[] args) throws Exception {
        for (int i = 1; i <= 5; i++) {
            System.out.println("输出：" + i);
            if(i == 3){
                // 让当前线程进入休眠状态
                // 段子：项目经理让我加上这行代码，如果用户愿意交钱，我就注释掉。
                Thread.sleep(3000);
            }
        }
    }
}

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

线程安全问题
　　多个线程同时操作同一个共享资源的时候可能会出现业务安全问题，称为线程安全问题
取钱模型演示
　　需求：小明和小红是一对夫妻，他们有一个共同的账户，余额是10万元。
　　如果小明和小红同时来取钱，而且2人都要取钱10万元，可能出现什么问题呢？

package com.itheima.d3_thread_safe;

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

package com.itheima.d3_thread_safe;

/**
   取钱的线程类
 */
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);
    }
}

package com.itheima.d3_thread_safe;

/**
    需求：模拟取钱案例。
 */
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();
    }
}

 7：线程同步

线程同步：为了解决线程安全问题。

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

 8：线程同步　　方式一：同步代码块　　　　synchronized 

同步代码块
　　作用：把出现线程安全问题的核心代码给上锁。
　　原理：每次只能一个线程进入，执行完毕后自动解锁，其他线程才可以进来执行。
synchronized(同步锁对象) {
    操作共享资源的代码(核心代码)
}

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

锁对象用任意唯一的对象好不好呢?
　　不好，会影响其他无关线程的执行。 【如下 this 就是锁，如果使用常量 "aaa"那么不管谁家来取钱都是一把锁，会影响其他人操作【一家人共用一把锁】【常量会锁住千万人取钱】】
锁对象的规范要求
　　规范上：建议使用共享资源作为锁对象。【this，使用账户对象这个共享资源来锁住】
　　对于实例方法建议使用this作为锁对象。
　　对于静态方法建议使用字节码（类名.class）对象作为锁对象。

同步代码块是如何实现线程安全的？
　　对出现问题的核心代码使用synchronized进行加锁
　　每次只能一个线程占锁进入访问
同步代码块的同步锁对象有什么要求？ 　　【使用共享资源作为锁对象，如下的 this 】   
　　对于实例方法建议使用this作为锁对象。
　　对于静态方法建议使用字节码（类名.class）对象作为锁对象

package com.itheima.d4_thread_synchronized_code;

/**
    账户类：余额，卡号
 */
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+"来取钱，余额不足！");
            }
        }
    }
}

package com.itheima.d4_thread_synchronized_code;

/**
  线程类
 */
public class DrawThread extends Thread{
    private Account acc;
    public DrawThread(Account acc, String name){
        super(name);
        this.acc = acc;
    }

    @Override
    public void run() {
        // 小明 小红  ： acc
        acc.drawMoney(100000);
    }
}

package com.itheima.d4_thread_synchronized_code;

public class TestSafeDemo {
    public static void main(String[] args) {
        // 测试线程安全问题
        // 1、创建一个共享的账户对象。
        Account acc = new Account("ICBC-111" , 100000);

        // 2、创建2个线程对象，操作同一个账户对象
        new DrawThread(acc, "小明").start();
        new DrawThread(acc,"小红").start();
    }
}

 9：线程同步　　方式二：同步方法　　　　synchronized

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

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

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

1、是同步代码块好还是同步方法好一点？
　　同步代码块锁的范围更小，同步方法锁的范围更大

同步方法是如何保证线程安全的？
　　对出现问题的核心方法使用synchronized修饰
　　每次只能一个线程占锁进入访问

同步方法的同步锁对象的原理？    
　　对于实例方法默认使用this作为锁对象。
　　对于静态方法默认使用类名.class对象作为锁对象。

package com.itheima.d5_thread_synchronized_method;

/**
    账户类：余额，卡号
 */
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+"来取钱，余额不足！");
        }
    }
}

 10：线程同步　　方式三：Lock锁

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

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

package com.itheima.d6_thread_synchronized_lock;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
    账户类：余额 , 卡号。
 */
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(); // 解锁
        }

    }
}

 11：线程池 概叙

 

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

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

 

 12：线程池 实现的API,　　参数说明　　　　ThreadPoolExecutor

 

谁代表线程池？:JDK 5.0起提供了代表线程池的接口：ExecutorService

如何得到线程池对象
　　方式一：使用ExecutorService的实现类 ThreadPoolExecutor 自创建一个线程池对象
　　　　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
　　　　【比如最多10个线程，任务队列最多5个任务，10个线程都在忙，任务队列最多缓存5个任务，第11个任务来了，咋办，配置策略，比如拒绝，抛异常】

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

 13：线程池处理 Runnable 任务

ThreadPoolExecutor创建线程池对象示例
ExecutorService pools = new ThreadPoolExecutor(3, 5
        , 8 , TimeUnit.SECONDS, new ArrayBlockingQueue<>(6),
            Executors.defaultThreadFactory() , new ThreadPoolExecutor.AbortPolicy());

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

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

package com.itheima.d8_threadpool;

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

package com.itheima.d8_threadpool;

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(); // 会等待全部任务执行完毕之后再关闭（建议使用的）
    }
}

14：线程池处理 Callable 任务【得到线程执行结果】

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

package com.itheima.d8_threadpool;

import java.util.concurrent.Callable;

/**
    1、定义一个任务类 实现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;
    }
}

package com.itheima.d8_threadpool;

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

15：Executors 工具类实现线程池

Executors 得到线程池对象的常用方法
Executors：线程池的工具类通过调用方法返回不同类型的线程池对象。 
　　public static ExecutorService newCachedThreadPool()   　　　　　　　　 线程数量随着任务增加而增加，如果线程任务执行完毕且空闲了一段时间则会被回收掉。
　　public static ExecutorService newFixedThreadPool​(int nThreads)    创建固定线程数量的线程池，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程替代它。
　　public static ExecutorService newSingleThreadExecutor ()    　　　　　　创建只有一个线程的线程池对象，如果该线程出现异常而结束，那么线程池会补充一个新线程。
　　public static ScheduledExecutorService newScheduledThreadPool​(int corePoolSize)    创建一个线程池，可以实现在给定的延迟后运行任务，或者定期执行任务。 

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

Executors使用可能存在的陷阱
大型并发系统环境中使用Executors如果不注意可能会出现系统风险
　　public static ExecutorService newFixedThreadPool​(int nThreads)    允许请求的任务队列长度是Integer.MAX_VALUE，
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　可能出现OOM错误（ java.lang.OutOfMemoryError ）【扛不住大任务，队列过长】
　　public static ExecutorService newSingleThreadExecutor()    　　　　允许请求的任务队列长度是Integer.MAX_VALUE，
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　可能出现OOM错误（ java.lang.OutOfMemoryError ）
　　public static ExecutorService newCachedThreadPool()    　　　　　　创建的线程数量最大上限是Integer.MAX_VALUE，【线程过多，任务过多，都会OOM,内存扛不住】
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　线程数可能会随着任务1:1增长，也可能出现OOM错误（ java.lang.OutOfMemoryError ）
　　public static ScheduledExecutorService newScheduledThreadPool​    创建的线程数量最大上限是Integer.MAX_VALUE，线程数可能会随着任务1:1增长，
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　也可能出现OOM错误（ java.lang.OutOfMemoryError ）(int corePoolSize)

package com.itheima.d8_threadpool;

import java.util.concurrent.*;

/**
    目标：使用Executors的工具方法直接得到一个线程池对象。
 */
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()); // 已经没有多余线程了
    }
}

package com.itheima.d8_threadpool;

import java.util.concurrent.Callable;

/**
    1、定义一个任务类 实现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;
    }
}

Executors工具类底层是基于什么方式实现的线程池对象？
　　线程池ExecutorService的实现类：ThreadPoolExecutor

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

16：定时器

 

 

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

定时器的实现方式
　　方式一：Timer
　　方式二： ScheduledExecutorService

Timer定时器
构造器：
　　public Timer()    创建Timer定时器对象
方法：
　　public void schedule​(TimerTask task, long delay, long period)    开启一个定时器，按照计划处理TimerTask任务
Timer定时器的特点和存在的问题
　　1、Timer是单线程，处理多个任务按照顺序执行，存在延时与设置定时器的时间有出入。
　　2、可能因为其中的某个任务的异常使Timer线程死掉，从而影响后续任务执行。

package com.itheima.d9_timer;

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

/**
    目标：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定时器
　　ScheduledExecutorService是 jdk1.5中引入了并发包，目的是为了弥补Timer的缺陷, ScheduledExecutorService内部为线程池。

Executors的方法
　　public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)　　　　　　　　　　　　　　　　　　　　 得到线程池对象
　　public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)    周期调度方法

ScheduledExecutorService的优点
　　1、基于线程池，某个任务的执行情况不会影响其他定时任务的执行
　　因为这个不是基于单线程

package com.itheima.d9_timer;

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

/**
    目标：Timer定时器的使用和了解。
 */
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);

    }
}

 

17：并发，并行

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

简单说说并发和并行的含义
　　并发：CPU分时轮询的执行线程。
　　并行：同一个时刻同时在执行

17：线程的生命周期

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

18：线程通信

什么是线程通信、如何实现？
　　所谓线程通信就是线程间相互发送数据，线程间共享一个资源即可实现线程通信。

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

线程通信实际应用场景
　　生产者与消费者模型：生产者线程负责生产数据，消费者线程负责消费生产者产生的数据。
　　要求：生产者线程生产完数据后唤醒消费者，然后等待自己，消费者消费完该数据后唤醒生产者，然后等待自己。

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

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

package com.itheima.d7_thread_comunication;

/**
   呼叫系统。
 */
public class CallSystem {
    // 定义一个变量记录当前呼入进来的电话。
    public static int number = 0; // 最多只接听一个。

    /* 接入电话
     */
    public synchronized static void call() {
        try {
            number++;
            System.out.println("成功接入一个用户，等待分发~~~~");

            // 唤醒别人 : 1个
            CallSystem.class.notify();
            // 让当前线程对象进入等待状态。
            CallSystem.class.wait();

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
       分发电话
     */
    public synchronized static void receive() {
        try {
            String name = Thread.currentThread().getName();
            if(number == 1){
                System.out.println(name + "此电话已经分发给客服并接听完毕了~~~~~");
                number--;
                // 唤醒别人 : 1个
                CallSystem.class.notify();
                CallSystem.class.wait(); // 让当前线程等待
            }else {
                // 唤醒别人 : 1个
                CallSystem.class.notify();
                CallSystem.class.wait(); // 让当前线程等待
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

package com.itheima.d7_thread_comunication;

public class CallThread extends Thread{
    @Override
    public void run() {
        // 不断的打入电话
        while (true){
            CallSystem.call();
        }
    }
}

package com.itheima.d7_thread_comunication;

/**
   接电话线程类
 */
public class ReceiveThread extends Thread{
    @Override
    public void run() {
        // 1号  2号
        while (true){
            CallSystem.receive();
        }
    }
}

package com.itheima.d7_thread_comunication;

public class TestDemo {
    public static void main(String[] args) {
        // 1、生产者线程：负责不断接收打进来的电话
        CallThread call = new CallThread();
        call.start();

        // 2、消费者线程：客服，每个客服每次接听一个电话
        ReceiveThread r1 = new ReceiveThread();
        r1.start();
    }
}