java多线程基础

1. 概念

程序的并发和并行 ：

• 并发：指两个或多个事件在同一个时间段内发生
• 并行：指两个或多个事件在同一时刻发生（同时发生）。

在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单 CPU 系统中，每 一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分 时交替运行的时间是非常短的。

而在多个 CPU 系统中，则这些可以并发执行的程序便可以分配到多个处理器上（CPU），实现多任务并行执行， 即利用每个处理器来处理一个可以并发执行的程序，这样多个程序便可以同时执行。目前电脑市场上说的多核 CPU，便是多核处理器，核 越多，并行处理的程序越多，能大大的提高电脑运行的效率。

所以，单核处理器的计算机肯定是不能并行的处理的，只能是多个任务在单个CPU上并发运行。

同理,线程也是一样的，从宏观角度上理解多线程是并行运行的，但是从微观角度上分析却是串行运行的，即一个 线程一个线程的去运行，当系统只有一个CPU时，线程会以某种顺序执行多个线程，我们把这种情况称之为 线程调度。

线程与进程

• 进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多 个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创 建、运行到消亡的过程。
• 线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程 中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

2. 创建线程

Java使用 java.lang.Thread 类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是 完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。

创建线程共有两种方式，一种是继承Thread类方式，一种是实现Runnable接口方式。

1.继承Thread类：

 public class MyThread extends Thread { 
            //重写run方法，完成该线程执行的逻辑   
            @Override      
            public void run() {      
            for (int i = 0; i < 10; i++) {          
                System.out.println(getName()+"：正在执行！"+i);              
            }          
        }
 }          

public class Demo01 { 
    public static void main(String[] args) {      
        //创建自定义线程对象         
        MyThread mt = new MyThread();          
        //开启新线程          
        mt.start();                 
    }      
}

2.实现Runnable接口

 public class MyRunnable implements Runable { 
            //重写run方法
            @Override      
            public void run() {      
            for (int i = 0; i < 10; i++) {          
                System.out.println(getName()+"：正在执行！"+i);              
            }          
        }
 }  

public class Demo02 { 
    public static void main(String[] args) {      
        //创建自定义类对象  线程任务对象         
        MyRunnable mr = new MyRunnable(); 
       
        //创建线程对象         
        Thread t = new Thread(mr, "小强"); 
        //开启新线程          
        t.start();                 
    }      
}

实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是继承Thread类还是实现 Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的

实现Runnable接口比继承Thread类所具有的优势：

1. 适合多个相同的程序代码的线程去共享同一个资源。
2. 使用Thread则需要继承，而Runnable可以避免java中的单继承的局限性。
3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

3. 线程安全

如果有多个线程在同时运行，而这些线程可能会同时操作同一个变量，当程序每次运行时因为线程的调度，读写频繁导致该变量不同步，这就是线程不安全。若每个线程中对全局变量、静态变量只有读操作，而无写 操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，

java 中提供了同步机制 （synchronized） 来解决

同步代码块

synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。

synchronized(同步锁){
    需要同步操作的代码 
}

同步锁:
对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.

1. 锁对象 可以是任意类型。 (不建议使用String ，Integer Double等基本类型包装类，缓存问题)
2. 多个线程对象 要使用同一把锁。

同步方法：

public synchronized void method(){
    可能会产生线程安全问题的代码   
}

那么此时锁对象又是谁呢

对于非static方法,同步锁就是this。

对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。

Lock锁

java.util.concurrent.locks.Lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作, 同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。

4. 线程状态

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中， 有几种状态呢？在API中 java.lang.Thread.State 这个枚举中给出了六种线程状态：

线程状态	导致状态发生条件
NEW(新建)	线程刚被创建，但是并未启动。还没调用start方法。
Runnable(可 运行)	线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操 作系统处理器。
Blocked(锁阻 塞)	当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状 态；当该线程持有锁时，该线程将变成Runnable状态。
Waiting(无限 等待)	一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个 状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
Timed Waiting(计时 等待)	同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态 将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、 Object.wait。
Teminated(被 终止)	因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

下面是 线程生命周期的全过程

5. 线程池

我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题：

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低 系统的效率，因为频繁创建线程和销毁线程需要时间。

那么有没有一种办法使得线程可以复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务？
在Java中可以通过线程池来达到这样的效果

概念： 就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作， 无需反复创建线程而消耗过多资源。

运行概念图：

合理利用线程池能够带来三个好处：

1. 降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
2. 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
3. 提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内 存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。

使用：

Java里面线程池的顶级接口是 java.util.concurrent.Executor ，但是严格意义上讲 Executor 并不是一个线程 池，而只是一个执行线程的工具。真正的线程池接口是 java.util.concurrent.ExecutorService 。

要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优 的，因此在 java.util.concurrent.Executors 线程工厂类里面提供了一些静态工厂，生成一些常用的线程池。

常用方法：

public static ExecutorService newFixedThreadPool(int nThreads) ：返回线程池对象。(创建的是有界线 程池,也就是池中的线程个数可以指定最大数量)

获取到了一个线程池ExecutorService 对象，那么怎么使用呢，在这里定义了一个使用线程池对象的方法如下：

public Future<?> submit(Runnable task) :获取线程池中的某一个线程对象，并提交自定义的运行任务，并执行

但是在实际使用中建议手动创建线程池，可以更加明确线程池的运行状态，规避资源浪费

以 ThreadPoolExecutor为例

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

上面是 该线程池的 基本构造函数，下面介绍每个参数的含义

1.corePoolSize ：核心线程数。 当线程池创建完毕时，线程池中并没有任何的线程（可以调用prestartAllCoreThreads 或者prestartCoreThread 方法默认初始化），等待任务到来才创建线程去执行任务 ，而当线程池中的线程数达到 该数目后，新来的任务将会放到 缓存队列等待执行，也就是那个workQueue

2.maximumPoolSize ：最大线程数 ，线程池中的最大线程数。表示线程池中最多可以创建多少个线程 ，当核心线程数全部占满，并且 workQueue 队列也放不下 任务时，将会考虑创建额外的线程去执行任务，此时 如果 线程数小于maximumPoolSize 数时，将会创建 额外线程，否则将调用预先设定的策略来拒绝这个任务。

额外创建的任务又被称为“Idle Thread”空闲线程，如果这些线程空闲时间超过 最大存活时间（keepAliveTime ） 将会被回收

3.keepAliveTime ： 上面提到过，控制额外创建的线程的空闲时间，超时将会被回收

4.unit：

参数keepAliveTime的时间单位,枚举类型

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

5.workQueue ：

阻塞队列。若新增任务时，核心线程数已经被占满，会尝试将其添加到该队列当中，只要超过了 corePoolSize 就会把任务添加到该缓存队列，如果成功的话就会等待空闲线程去执行该任务，若添加失败(一般是队列已满)，就会根据当前线程池的状态决定如何处理该任务(根据maximumPoolSize 数决定是新增额外的线程 还是调用拒绝策略)。

常用队列：

ArrayBlockingQueue 　　　　　　//基于数组的先进先出队列，此队列创建时必须指定大小；
LinkedBlockingQueue　　　　　　//基于链表的先进先出队列，如果创建时没有指定此队列大小，则默认为Integer.MAX_VALUE；
synchronousQueue　　　　　　　　//它不会保存提交的任务，而是将直接新建一个线程来执行新来的任务。

6.threadFactory : 线程工厂，用来创建线程，可以自定义，对线程进行操作（起名字）的，当不指定时，内部会调用Executors.defaultThreadFactory()创建默认的线程工厂

7.handler ： 拒绝执行策略。 当缓存队列已满，又无法创建额外线程时，调用此策略

常用策略：

ThreadPoolExecutor.AbortPolicy:　　　　　　　　 // 丢弃任务并抛出RejectedExecutionException异常。
ThreadPoolExecutor.DiscardPolicy：　　　　　　　// 也是丢弃任务，但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy：　　  // 丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：　　　　  // 由调用线程处理该任务