线程，线程池一些知识点

线程

---

实现线程的三种方式

继承 Thread 类创建线程

步骤

• 定义继承 Thread 的子类，并重写 run() 方法

• 创建继承 Thread 的子类实例，即创建了线程对象

• 调用 start() 方法启动线程

示例代码

• 继承 Thread 类->MyThread.java

    package com.dao.thead.core;
    
    /**
     * 继承 Thread 类创建线程
     *
     * @author 阿导
     * @version 1.0
     * @fileName com.dao.thead.core.MyThead.java
     * @CopyRright (c) 2018-万物皆导
     * @created 2018-04-11 13:32:00
     */
    public class MyThread extends Thread {
    
        /**
         * 重写 run 方法
         *
         * @author 阿导
         * @time 2018/4/11
         * @CopyRight 万物皆导
         * @param
         * @return void
         */
        @Override
        public void run(){
            System.out.println("这是继承 Thread 类创建线程。");
        }
    }
    
    

• 调用

    //启动继承 Thread  类的线程
    new MyThread().start();

实现 Runnable 接口创建线程

步骤

• 定义实现 Runnable 的子类，并重写实现 run() 方法

• 创建实现 Runnable 的子类实例，并用这个实例作为 Thread 的 target 来创建 Thread 对象，这个 Thread 对象才是真正的线程对象

• 调用 start() 方法启动线程

示例代码

• 实现 Runnable 类->MyRunnable.java

 
    package com.dao.thead.core;
    
    /**
     * 实现 Runnable 接口创建线程
     *
     * @author 阿导
     * @version 1.0
     * @fileName com.dao.thead.core.MyRunnable.java
     * @CopyRright (c) 2018-万物皆导
     * @created 2018-04-11 13:32:00
     */
    public class MyRunnable implements Runnable {
    
        /**
         * 实现 run 方法
         *
         * @author 阿导
         * @time 2018/4/11
         * @CopyRight 万物皆导
         * @param
         * @return void
         */
        @Override
        public void run() {
            System.out.println("这里是实现 Runnable 接口创建线程。");
        }
    }

    

• 调用

    //启动实现 Runnable 接口的线程
    new Thread(new MyRunnable()).start();

使用 Callable 和 Future 创建线程

和 Runnable 接口不一样，Callable 接口提供了一个 call（）方法作为线程执行体，call() 方法比 run() 方法功能要强大。

步骤

• 定义实现 Callable 的子类，并实现 call() 方法

• 使用 FutureTask 类来包装实现 Callable 的子类，其包装的返回值(泛型)应和对应子类保持一致

• 将 FutureTask 对象作为 Thread 的 target 创建线程，并通过 start() 来启用线程

• 然后通过 get() 方法获取返回值，该阶段，线程会进入阻塞状态，直到所有线程结束。

示例代码

• 实现 Callable 类->MyCallable.java

 
    package com.dao.thead.core;
    
    import java.util.concurrent.Callable;
    
    /**
     * 使用 Callable 和 Future 创建线程
     *
     * @author 阿导
     * @version 1.0
     * @fileName com.dao.thead.core.MyCallable.java
     * @CopyRright (c) 2018-万物皆导
     * @created 2018-04-11 13:33:00
     */
    public class MyCallable implements Callable<String> {
    
        /**
         * 实现 call() 方法
         * @author 阿导
         * @time 2018/4/11
         * @CopyRight 杭州微财科技有限公司
         * @param
         * @return java.lang.String
         */
        @Override
        public String call() throws Exception {
            System.out.println("这是使用 Callable 和 Future 创建线程。");
            return "万物皆导";
        }
    }


    

• 调用

      //使用 FutureTask 获取实现 Callable 的线程
      FutureTask<String> task=new FutureTask<String>(new MyCallable());
      //将任务放入线程执行，实质上还是以 Callable 对象来创建并启动线程
      new Thread(task,"测试带返回值的线程").start();
      //查看线程返回值，get() 方法会阻塞，直到子线程执行结束才返回
      System.out.println("带回来的结果:"+task.get());

对比三种线程的实现方式

• 线程只是实现 Runnable 或实现 Callable 接口，还可以继承其他类。

• 这种方式下，多个线程可以共享一个 target 对象，非常适合多线程处理同一份资源的情形。

• 但是编程稍微复杂，如果需要访问当前线程，必须调用 Thread.currentThread() 方法。

• 继承 Thread 类的线程类不能再继承其他父类（Java 单继承决定）。

注：一般推荐采用实现接口的方式来创建多线程

一些案例

案例来自于一些哥们和我分享的面试题，目前我这边听到最多的就是设计死锁和线程安全问题，下面我对这两个问题一一分析，不当之处，欢迎指正，我一贯认为写博客其实就是帮助自己成长的一种形式，也是给自己记录笔记，在各位大佬的指正下，我会成长的更快。

死锁问题

如何设置一个死锁程序？可能很多人一下子很蒙圈，若能理清什么是死锁，然后反向考虑，问题便很简单，一般来说产生死锁的原因就是资源申请不下来，线程一直处于阻塞等待状态，那么反向考虑只需要2个线程便能设计一个死锁程序，暂且设定两个线程 A、B ，并设置两个条件必须同时在一个线程拥有这两个条件才能执行结束，否则两个线程就处于阻塞状态，这样便设计出死锁程序了，话不多说，直接撸代码。

/**
 * 死锁程序设计
 *
 * @author 阿导
 * @CopyRight 万物皆导
 * @Created 2019年03月25日 14:22:00
 */
public class DeadThread {
    /**
     *  AB 执行的必要条件
     */
    private static Object conditionAB = new Object();
    /**
     * BA 执行的必要条件
     */
    private static Object conditionBA = new Object();

    /**
     * 主程序
     * @param args
     */
    public static void main(String[] args) {
        // 线程 A
        Thread threadA = new Thread(()->{
         synchronized (conditionAB){
             System.out.println("A 线程开始");


             System.out.println("A 线程即将进入阻塞状态");

             synchronized (conditionBA){
                 System.out.println("A 线程阻塞状态结束");
             }

             System.out.println("A 线程结束");

         }
        });

        // 线程 B
        Thread threadB = new Thread(()->{
            synchronized (conditionBA){
                System.out.println("B 线程开始");

                System.out.println("B 线程即将进入阻塞状态");

                synchronized (conditionAB){
                    System.out.println("B 线程阻塞状态结束");
                }

                System.out.println("B 线程结束");

            }
        });

        threadA.start();
        threadB.start();
    }
}

线程安全问题

前几天，过去和我共事的一个小哥们说他去面试了蚂蚁金服，他说面试官给他一个线程安全方面的问题，思路不是很清晰，因为阿导面试经验不是很丰富，对那些所谓的面试套路，面试题存储量是很少的，来杭州总共面试两次，都是同一个大佬，也没怎么太刁难我，所以很多面试题目我都表示很慌的，既然哥们有求于我，那怎么也得仗义相助一下，首先蚂蚁金服那位大佬的面试题如下：

学生成绩数据查询、修改、打印功能
【场景描述】
使用多线程方式，实现学生成绩数据查询、修改、打印功能。
线程A：从数据库中获取学生的成绩数据（stu_id, score1, score2, score3），stu_id代表学生ID，score1 - score3是代表三门课的成绩
线程B：会对这三门课的成绩进行修改
线程C：会对这三门课的成绩进行打印输出

【要求】
1.在线程B修改成绩的过程中，线程C不能对成绩进行打印，线程A不能读取数据
2.线程A从数据库读取数据的过程中，线程B不能修改成绩，线程C也不能打印成绩
3.线程C打印成绩的过程中，线程A不能读取数据，线程B不能修改数据。
4.主线程用于检测3个线程的状态，如果线程挂了，则重启线程。

学生成绩服务接口：

/**
 * 查询学生成绩
 * @param stuId 学生ID，由cmd控制台输入
 * @return 学生成绩模型
 **/
public StudentDO StudentService.queryStudent(String stuId);

/**
 * 修改学生成绩
 * @param student 学生模型，由cmd控制台输入
 * @return 修改影响记录数
 **/
public int StudentService.updateStudent(StudentDO student);

/**
 * 打印学生成绩
 * @param student 学生模型
 **/
public void StudentService.printStudent(StudentDO student);


public class StudentManager {
    public static void main(String[] args) {
       // TODO 完成此处的代码

    }
}

当哥们发过来面试题的时候，我这边因为在忙项目，并没仔细看题目，我以为是侧重点是线程竞争问题，等我这边事情忙完了，我仔细审题了一遍，发现这应该考虑的是线程安全问题。

其实实现方式有很多种，最为简单的无非就是加个锁，我这边以重入锁为例，大家也可以尝试其他的实现方式，比如通过 Semaphore 类控制访问线程的个数，话不多说，以下是我的代码示例。

package com.dao.example;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 线程安全问题
 *
 * @author 阿导
 * @CopyRight 萬物皆導
 * @Created 2019年03月25日 16:55:00
 */
public class ThreadSafe {

    /**
     * 重入锁锁定当前执行的对象，只是测试，正式环境慎用，防止导致死锁的情况
     */
    private static Lock lock = new ReentrantLock();

    /**
     * 业务实现，只是示例，实际写代码应该单独写一个类去实现接口，建议平时开发注意依赖倒置原则
     */
    private StudentService studentService = new StudentService() {
        @Override
        public StudentDO queryStudent(Long stuId) {
            System.out.println(getThread() + "查询学生信息:" + stuId);
            return new StudentDO();
        }

        @Override
        public int updateStudent(StudentDO student) {
            System.out.println(getThread() + "更新学生信息:" + student.getId());

            return 0;
        }

        @Override
        public void printStudent(StudentDO student) {
            System.out.println(getThread() + "打印学生信息:" + student.getId());

        }
    };

    private String getThread() {

        return Thread.currentThread().getName()+"("+Thread.currentThread().getId()+")";
    }

    /**
     * 打印学生成绩适配器
     */
    private StudentServiceAdapter printAdapter = new PrintAdapter();
    /**
     * 更新学生成绩适配器
     */
    private StudentServiceAdapter updateAdapter = new UpdateAdapter();
    /**
     * 查询学生信息适配器
     */
    private StudentServiceAdapter queryAdapter = new QueryAdapter();

    /**
     * 主方法(用学生 ID 自加1 表示执行序次,若是次序一致则表示每一步都是互斥的)
     *
     * @param args
     */
    public static void main(String[] args) {
        ThreadSafe main = new ThreadSafe();
        StudentDO studentDO = new StudentDO();
        Long id = 0L;
        studentDO.setId(id);
        // 根据适配器选择不同的操作
        Thread threadA = null;
        Thread threadB = null;
        Thread threadC = null;

        // 主线程检测线程状态
        while (true) {
            threadA = keepThreadLive(threadA, main.studentService, studentDO, main.queryAdapter,"A");
            threadB = keepThreadLive(threadB, main.studentService, studentDO, main.updateAdapter,"B");
            threadC = keepThreadLive(threadC, main.studentService, studentDO, main.printAdapter,"C");
        }

    }

    /**
     * 确保线程是活的
     *
     * @param thread
     * @param studentService
     * @param studentDO
     * @param serviceAdapter
     * @return
     * @author 阿导
     * @time 2019/3/26 9:49
     * @CopyRight 万物皆导
     */
    private static Thread keepThreadLive(Thread thread, StudentService studentService, StudentDO studentDO, StudentServiceAdapter serviceAdapter,String name) {
          if (thread == null) {
            (thread = getThread(studentService, studentDO, serviceAdapter)).setName(name);
            System.out.println("创建线程："+thread.getName()+"("+thread.getId()+")学生信息："+studentDO.getId());
            thread.start();
        } else if (!thread.isAlive()) {
            (thread = getThread(studentService, studentDO, serviceAdapter)).setName(name);
            System.out.println("重启线程："+thread.getName()+"("+thread.getId()+")学生信息："+studentDO.getId());
            thread.start();
        }
        return thread;
    }


    /**
     * 业务处理适配接口层
     *
     * @author 阿导
     * @CopyRight 萬物皆導
     * @created 2019/3/25 17:08
     * @Modified_By 阿导 2019/3/25 17:08
     */
    interface StudentServiceAdapter {
        /**
         * 适配处理
         *
         * @param studentService
         * @param studentDO
         * @return
         * @author 阿导
         * @time 2019/3/25 17:10
         * @CopyRight 萬物皆導
         */
        void doAdapter(StudentService studentService, StudentDO studentDO);
    }

    class PrintAdapter implements StudentServiceAdapter {

        /**
         * 适配处理：打印學生成績
         *
         * @param studentService
         * @param studentDO
         * @return
         * @author 阿导
         * @time 2019/3/25 17:10
         * @CopyRight 萬物皆導
         */
        @Override
        public void doAdapter(StudentService studentService, StudentDO studentDO) {
            studentService.printStudent(studentDO);
        }
    }

    class UpdateAdapter implements StudentServiceAdapter {

        /**
         * 适配处理：更新學生信息
         *
         * @param studentService
         * @param studentDO
         * @return
         * @author 阿导
         * @time 2019/3/25 17:10
         * @CopyRight 萬物皆導
         */
        @Override
        public void doAdapter(StudentService studentService, StudentDO studentDO) {
            studentService.updateStudent(studentDO);
        }
    }

    class QueryAdapter implements StudentServiceAdapter {

        /**
         * 适配处理：查詢學生信息
         *
         * @param studentService
         * @param studentDO
         * @return
         * @author 阿导
         * @time 2019/3/25 17:10
         * @CopyRight 萬物皆導
         */
        @Override
        public void doAdapter(StudentService studentService, StudentDO studentDO) {
            studentService.queryStudent(studentDO.getId());
        }
    }


    /**
     * 获取线程
     *
     * @param studentService
     * @param studentDO
     * @param serviceAdapter
     * @return
     * @author 阿导
     * @time 2019/3/25 17:03
     * @CopyRight 萬物皆導
     */
    private static Thread getThread(StudentService studentService, StudentDO studentDO, StudentServiceAdapter serviceAdapter) {
        return new Thread(() -> {
            while (true) {
                try {
                    lock.lock();
                    studentDO.setId(studentDO.getId() + 1L);
                    // 根据适配器去选择不同的操作
                    serviceAdapter.doAdapter(studentService, studentDO);
                    // 模拟业务处理
                }  finally {
                    lock.unlock();
                    try {
                        Thread.sleep(1000L);
                    } catch (InterruptedException e) {
//                        e.printStackTrace();
                    }

                }
            }
        });

    }

}


/**
 * 学生操作业务接口层
 *
 * @author 阿导
 * @CopyRight 萬物皆導
 * @created 2019/3/25 16:56
 * @Modified_By 阿导 2019/3/25 16:56
 */

interface StudentService {
    /**
     * 查询学生成绩
     *
     * @param stuId 学生ID，由cmd控制台输入
     * @return 学生成绩模型
     **/

    StudentDO queryStudent(Long stuId);

    /**
     * 修改学生成绩
     *
     * @param student 学生模型，由cmd控制台输入
     * @return 修改影响记录数
     **/

    int updateStudent(StudentDO student);

    /**
     * 打印学生成绩
     *
     * @param student 学生模型
     **/

    void printStudent(StudentDO student);
}

/**
 * 学生实体
 *
 * @author 阿导
 * @CopyRight 萬物皆導
 * @created 2019/3/25 16:56
 * @Modified_By 阿导 2019/3/25 16:56
 */

class StudentDO {
    /**
     *
     */
    private Long id;

    private Integer score1;
    private Integer score2;
    private Integer score3;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public Integer getScore1() {
        return score1;
    }

    public void setScore1(Integer score1) {
        this.score1 = score1;
    }

    public Integer getScore2() {
        return score2;
    }

    public void setScore2(Integer score2) {
        this.score2 = score2;
    }

    public Integer getScore3() {
        return score3;
    }

    public void setScore3(Integer score3) {
        this.score3 = score3;
    }
}

辅助三剑客

说到线程就不得不说三个辅助类，分别是 CountDownLatch 、CyclicBarrier 、Semaphore ，这个三个的区别点在哪呢？我的观点是时间点的问题，CountDownLatch 侧重于指定数量线程完成后才处理后续的流程，比如赛跑中我们只记录前3名，那么前三名到达终点便结束比赛；CyclicBarrier 侧重于指定数量线程同时启动，比如赛跑中为了保持公平，所有选手必须在听到发令枪后才能开始起跑；Semaphore 侧重于线程并发数量控制，比如只有3个封闭式赛道（只有跑完了才能换人跑），所以每次最多3个人在跑道上跑（有点不恰当，别介意），下面阿导使用代码一一诠释。

• CountDownLatch：因为是兄弟，所以才我们才等你一起到终点

未完待续

• CyclicBarrier：为了公平，我们等你一起开始我们的故事

未完待续

• Semaphore：因为资源有限，我们只能通过竞争去占用资源

未完待续

线程池

为什么要用线程池？

• 在程序运行过程中，线程资源是稀缺的，为了减少线程创建和销毁，使得线程得以重复利用，所以使用线程池。

• 防止滥用线程，通过线程池，可以有效的控制工作中的线程数量，防止服务器 CPU 或者内存消耗过多导致崩溃，造成重大损失。

线程池的构造方法

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
            this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,Executors.defaultThreadFactory(), defaultHandler);
    }
        
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
                this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,threadFactory, defaultHandler);
    }
    
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler) {
            this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,Executors.defaultThreadFactory(), handler);
    }
    
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
         if (corePoolSize < 0 ||
             maximumPoolSize <= 0 ||
             maximumPoolSize < corePoolSize ||
             keepAliveTime < 0)
             throw new IllegalArgumentException();
         if (workQueue == null || threadFactory == null || handler == null)
             throw new NullPointerException();
         this.corePoolSize = corePoolSize;
         this.maximumPoolSize = maximumPoolSize;
         this.workQueue = workQueue;
         this.keepAliveTime = unit.toNanos(keepAliveTime);
         this.threadFactory = threadFactory;
         this.handler = handler;
    }
    
    

观察其构造方法，发现最终调的是参数最多的那个构造方法，只是根据经验，一些参数给了默认值，减少开发者传入参数过多带来的困扰，下面讲述一下各个参数代表的含义。

• corePoolSize：线程池核心线程数量

核心池的大小，这个参数跟后面讲述的线程池的实现原理有非常大的关系。在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，除非调用了 prestartAllCoreThreads()或者 prestartCoreThread() 方法，从这2个方法的名字就可以看出，是预创建线程的意思，即在没有任务到来之前就创建corePoolSize 个线程或者一个线程。默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到 corePoolSize 后，就会把到达的任务放到缓存队列当中

• maximumPoolSize：线程池最大线程数量

线程池最大线程数，这个参数也是一个非常重要的参数，它表示在线程池中最多能创建多少个线程

• keepAliveTime：当活跃线程数大于核心线程数时，空闲的多余线程最大存活时间

表示线程没有任务执行时最多保持多久时间会终止。默认情况下，只有当线程池中的线程数大于 corePoolSize 时，keepAliveTime 才会起作用，直到线程池中的线程数不大于 corePoolSize，即当线程池中的线程数大于 corePoolSize 时，如果一个线程空闲的时间达到 keepAliveTime，则会终止，直到线程池中的线程数不超过 corePoolSize。但是如果调用了 allowCoreThreadTimeOut(boolean)方法，在线程池中的线程数不大于 corePoolSize 时，keepAliveTime 参数也会起作用，直到线程池中的线程数为0

• unit：存活时间的单位

参数 keepAliveTime 的时间单位，有7种取值，在 TimeUnit 类中有7种静态属性：

           TimeUnit.DAYS;               //天
           TimeUnit.HOURS;             //小时
           TimeUnit.MINUTES;           //分钟
           TimeUnit.SECONDS;           //秒
           TimeUnit.MILLISECONDS;      //毫秒
           TimeUnit.MICROSECONDS;      //微妙
           TimeUnit.NANOSECONDS;       //纳秒

• workQueue：存放任务的队列

一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列有以下几种选择：

(1) ArrayBlockingQueue

(2) LinkedBlockingQueue

(3) SynchronousQueue

ArrayBlockingQueue 和 PriorityBlockingQueue 使用较少，一般使用 LinkedBlockingQueue 和 Synchronous。线程池的排队策略与 BlockingQueue 有关。

• threadFactory：线程工厂，用来创建线程

• handler：超出线程范围和队列容量的任务的处理程序

表示当拒绝处理任务时的策略，有以下四种取值：

(1) ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常

(2) ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常

(3) ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）

(4) ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

线程实现原理

• 首先用户先提交线程任务

• 首先判断线程池核心线程是否都在执行任务，若没有（核心线程空闲或者还有核心线程没有被创建）则创建新的线程来执行任务，若核心线程都在执行任务，进入下一流程

• 然后判断线程池队列是否已经满了，若没有，则将新提交的任务放入线程队列中，若已满；进入下一流程

• 判断线程是否都处于工作状态，若没有，则新创建一个线程来执行任务，若已经满了，则交给饱和策略来处理这个任务

需要云服务器的不要错过优惠

阿里云低价购买云服务，值得一看