01. 就该这么学并发 - 线程的创建(多姿势)

本章开始,咸鱼君将开启一个新的专栏 就该这么学并发 来记录学习Java并发编程的相关内容~

前言

说到**并发编程,就不得不先说多线程,因为并发的本质就是多线程的处理**

进程和线程

• 进程 (ps: 每一个程序就是一个进程)

进程指运行中的应用程序,每个程序运行时就会开启一个进程
进程是系统分配资源的最小单位
进程有独立系统资源(进程间的资源是隔离的)
每个进程至少有一个线程

- 线程 (ps: 进程至少有一个线程)

线程依托于进程
线程除了支持本身运行的一点系统资源外(如: 
控制线程运行的线程控制块,保留局部变量和少数参数的栈空间)
不额外拥有独立的资源,但是共享进程的资源
线程也是CPU调度的最小单位

我们眼见为实,右键打开windows系统的任务管理器

CPU调度执行策略简介

CPU如何调度进程/线程呢?

CPU依托于**CPU调度算法**来调度,如下

• RR(Round Robin)

时间片轮转调度算法,每个进程/线程会被分配一个时间片,
在这个时间片的时间段内,允许进程/线程运行

• FIFO((First In First Out)

先进先出算法,按照进程就绪的先后顺序来使用CPU

• SCBF(Shortest CPU Burst First)

短进程优先算法,先给每个进程都设置一个优先级,
根据比较优先级来确定下一个执行的进程；
将一些相对短的进程优先级适当提高

• Virtual RR

虚拟轮转法,时间片轮转法的改进算法

• PSA(Priority Scheduling Algorithm)

优先级算法,给每一个进程一个优先级,
优先级越高的事件先执行

• 其它……

看完以上调度算法, 大家留下个

CPU有很多调度算法,并不仅仅只有RR时间片调度

这么个印象就好

因为现在说起线程调度, 很多文章开口就是**时间片调度,可能会造成误解, 认为CPU调度只有RR算法一种, 这显然是不严谨**的.

JVM虚拟机简介

JVM是一个**虚构出来的计算机,是通过在实际的计算机上仿真模拟**各种计算机功能来实现的.

引入Java语言虚拟机后,Java语言在不同平台上运行时不需要重新编译.Java语言使用Java虚拟机屏蔽了与具体平台相关的信息,使得**Java语言只需生成在Java虚拟机上运行的目标代码,就可以在多种平台上不加修改地运行**

简而言之

JVM就是个翻译器,依托于它,java才实现了 “一次编译,多处(平台)运行!”

当然,和C,C++等编译语言不同的点在于,java编译出来的是**字节码文件,也就是“.class”文件,这种文件被JVM所认识,再由JVM来翻译解释成具体平台的可执行文件,而后可被具体平台运行**.

简单的流程关系如下:

java文件(.java)--编译-->(.class)---->(JVM)解释---->(可执行文件)运行

所以

有人说JAVA是编译型语言,也有人说是解释型语言,其实都没什么问题!

线程的生命周期

下面我们进入本章的正题,着重讲解下线程的**生命周期**!

先来张线程生命周期的纲要图,方便大家理解,后续针对每个节点细讲.

线程大致有五种状态

本章, 我们聊聊线程生命周期的第一个状态“新建”.

新建(New)

当线程对象对创建后,即进入了新建状态

- 此时JVM为其分配内存,并初始化其成员变量的值；

- 此时线程对象没有表现出任何线程的动态特征,程序也不会执行线程的线程执行体run()；

线程的创建分为

• 无返回值

• 有返回值

下面我们一一示例

无返回值的创建方式

• 继承Thread类

class ExtendsThread extends Thread {
    // 重写run方法
    @Override
    public void run() {
        System.out.println("子线程" + Thread.currentThread().getName() + "正在执行 ");
    }
}

class Test {
    public static void main(String[] args) throws Exception {
        ExtendsThread t = new ExtendsThread();
        t.start();
}

当然,我们也可以简单点,使用**匿名类**的方式创建

class Test {
    public static void main(String[] args) throws Exception {
        Thread t = new Thread(){
               public void run(){
                   System.out.println("Thread Running");
               }  
             };
        t.start();
}

• 实现Runnable接口

public class ImpRunnableThread implements Runnable {
　//重写run方法　
  @Override
  public void run(){
　　log.info("子线程{}正在执行 ",Thread.currentThread().getName());
　　}
}

//测试
class Test {
    public void main(String[] args){
        ImpRunnableThread t = new ImpRunnableThread();
        Thread thread = new Thread(t);
        thread.start();
    } 
}

同样,我们可以使用匿名类的方式创建

public class Test {
    public static void main(String[] args) throws Exception {
        Thread t = new Thread(new Runnable(){
            @Override
            public void run() {
                System.out.println("Runnable running");
            }
        });
        t.start();
    }
}

有返回值的创建方式

• 使用Callable和Future创建线程

public class ImpCallableThread implements Callable {
    //重写call方法
    @Override
    public String call() {
        log.info("子线程{}正在执行 ",Thread.currentThread().getName());
        return "返回值";
    }
}
//测试
class Test {
    public void main(String[] args){
        FutureTask task = new FutureTask(new  ImpCallableThread());
        new Thread(task).run();
        log.info("线程中获取到的返回信息  {} ",task.get());
}

线程池创建线程

其实是比较**推荐大家用线程池**的方式去创建线程的,好处如下

• 降低资源消耗

通过重复利用已创建的线程降低线程创建和销毁造成的消耗

• 提高响应速度

当任务到达时,任务可以不需要的等到线程创建就能立即执行

• 提高线程的可管理性

线程是稀缺资源,如果无限制的创建,不仅会消耗系统资源,还会降低系统的稳定性,使用线程池可以进行统一的分配,调优和监控

关于如何创建线程池,其实Java 已经提供了 Executors,

Java 通过 Executors 提供**四种线程池**,例如：

• newCachedThreadPool

创建一个可缓存线程池,如果线程池长度超过处理需要,
可灵活回收空闲线程,若无可回收,则新建线程

• newFixedThreadPool

创建一个定长线程池,可控制线程最大并发数,
超出的线程会在队列中等待

• newScheduledThreadPool

创建一个定长线程池,支持定时及周期性任务执行

• newSingleThreadExecutor

创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,
保证所有任务按照指定顺序(FIFO,LIFO,优先级)执行

不过,从**实际开发角度,直接使用Executors返回线程池会有一些问题,所以我们并不推荐以上的方式来创建线程池(阿里内部也是明确规定不允许采用这种方式的**)

原因如下:

• FixedThreadPool 和 SingleThreadExecutor : 允许请求的队列长度为 Integer.MAX_VALUE,可能堆积大量的请求,从而导致OOM

• CachedThreadPool 和 ScheduledThreadPool : 允许创建的线程数量为 Integer.MAX_VALUE ,可能会创建大量线程,从而导致OOM

避免使用Executors创建线程池主要是为了避免其中的默认实现,可以改用ThreadPoolExecutor构造方法指定参数

class Test {
public void main(String[] args){
  ExecutorService executorService = new ThreadPoolExecutor(5,10,10,TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(5));
  for (int i = 0; i < 20; i++) {
       executorService.execute(new Runnable() {
       @Override
       public void run() {
               log.info("线程  {}  开始",Thread.currentThread().getName());
         }});
       }
}
}

需要指定**核心线程池的大小、最大线程池的数量、保持存活的时间、等待队列容量的大小**;

在这种情况下一旦提交的线程数超过当前可用的线程数时就会抛出拒绝执行的异常

java.util.concurrent.RejectedExecutionException 

解决方式就是**尽量调大最大线程数**

除了自己定义的**ThreadPool**之外,还可以使用开源库 **apache guava**等,大家自行选择如何使用~

哪种创建线程的方式比较好?

关于这个问题,其实推荐的是

实现Runnable接口

因为**线程池可以有效的管理实现了Runnable接口的线程**,如果线程池满了,新的线程就会排队等候执行,直到线程池空闲出来为止.而如果线程是通过实现Thread子类实现的,这将会复杂一些.

有时我们要同时融合实现Runnable接口和Thread子类两种方式.例如,实现了Thread子类的实例可以执行多个实现了Runnable接口的线程.一个典型的应用就是线程池.

请关注我的订阅号