Java多线程基础详解-优快云博客

java中，线程以轻量级进程的方式实现，也就具有进程的特征

并发：一个CPU以时间片轮转调度的方式，依次执行多个进程
并行：多个CPU在一个时间点，同时执行多个线程

线程到底是就绪态，还是运行态，是操作系统调度决定，程序是不知道的

java中常说的并发编程，其实包含多线程的并发，也有多线程的并行

2）为什么会有线程？

并发编程成为刚需
虽然多进程也可以并发实现，但线程比进程更加轻量

3）进程和线程的区别

进程包含线程，每个进程至少包含一个线程
进程是系统分配资源的最小单位，线程是系统调度的最小单位
进程状态的改变耗费更多时间，线程的效率更高
进程占用独立的虚拟地址空间，同一个进程内的线程可以共享这个进程的内存。一个进程要访问另一个数据，需要使用通信的方式（代价大），同一个进程的线程可以直接使用共享变量。一个进程挂掉，不会影响其他进程，一个进程中的线程挂掉，可能会影响整个进程挂掉

4）JAVA的线程和操作系统线程的关系

Java中的线程，是以轻量级进程来实现的JAVA，标准库里的Thread类可以视为是对操作系统提供api进行进一步的抽象和封装

>创建线程

①new Thread（此时还没有创建系统中的线程）

public class 继承Thread类 {
    public static void main(String[] args) {
        //1.静态内部类，和普通类没有啥区别
        Thread t = new MyThread();
        //调用start方法，才会真正的创建操作系统中的线程，并申请系统调度执行
        t.start();
        
        //2.匿名内部类：new出来的其实是一个没有类名的匿名类（继承了Thread）
        Thread t2 = new Thread(){
            @Override
            public void run() {
                System.out.println("匿名内部类 run");
            }
        };
        t2.start();
    }

    private static class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("这里是线程运行的代码");
        }
    }
}

②实现Runnable接口

public class Runnable接口 {
    public static void main(String[] args) {
        //1.先创建一个Runnable对象，传入Thread的构造方法
        Thread t = new Thread(new MyRunnable());
        t.start();

        //2.Runnable也可以使用匿名内部类的写法
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Runnable匿名内部类 run");
            }
        });
        t2.start();

        //3.Runnable lambda的写法
        Thread t3 = new Thread(() -> {
            System.out.println("Runnable匿名内部类 run");
        });
        t3.start();//t3
    }

    //Runnable接口，表示定义线程的任务对象（Thread才是线程本身）
    private static class MyRunnable implements Runnable{
        @Override
        public void run() {//线程要执行的任务代码
            System.out.println("my runnable run");
        }
    }
}

创建线程的方式：

1.继承Thread，重写run

2.实现Runnable接口，重写run

3.实现Callable接口（后面讲述）

>多线程的优势

（1）多线程可以并行的执行，提高计算机执行效率。在计算机中提高程序的执行效率有三种方法：一、是增加计算机的CPU个数。二、是为一个程序启动多个进程。三、是在程序中使用多线程。因为CPU的昂贵，所以第一种不好。又因为每一个进程都是在独立的内存空间中运行，并且内存不共享，数据不共享，所以启动多进程会消耗大量系统资源，第二种不好。第三种继承了他们的优点，弥补了他们的缺点，并且多线程可以模拟多块CPU的运行方式，因此多线程是提高程序执行效率的最廉价方式。

（2）充分利用CPU资源。因为我们的电脑都是只有一个CPU，所以充分利用CPU资源显得尤为重要。当执行单线程程序时，在程序发生阻塞的时候CPU可能处于空闲状态，这样就造成了计算机资源的浪费。而当使用多线程的时候可以在一个线程发生阻塞并且CPU处于空闲的时候，可以运行其他线程，这样CPU很难有空闲的时候了，因此CPU资源就得到了充分利用。

（3）简化编程模式。如果使用多线程的话，让每一个线程处理一个单独的任务，可以只针对这个单独的任务进行编程，这样有利于开发人员对程序的理解。就是把一个大的东西分成一个一个的小东西进行处理。

二：Thread类及常见方法

Thread 类是 JVM 用来管理线程的一个类，换句话说，每个线程都有一个唯一的 Thread 对象与之关联。

利用JDK的命令：jconsole可以查看java进程的信息

>常见api

Thread有静态方法，实例方法

activeCount():返回当前线程处于活跃状态的线程数（线程创建以后，销毁之前都是活跃状态）
run()：定义线程需要执行的任务代码
start():创建系统线程，并申请系统调度
getName:返回线程的名称。可以通过new Thread时传入线程名称
sleep:让当前线程休眠millis(毫秒)。【操作系统内还有一个阻塞队列，线程休眠/阻塞，就是进入阻塞队列，等恢复（就是休眠），再拿出来执行】
yield()：当前线x程让步（从运行态转为就绪态）类似排队买票，轮到我买就是运行态，排队就是就绪态，yield就是轮到我发现钱不够取钱从头排.
isAlive()：线程引用对象是否是活跃状态
（了解）getPriority()，setPriority(int newPriority)：返回或设置某个线程的优先级，系统调度时优先级只是一个指标，所以一般不使用这个作为哪个线程先执行的方式。多个线程是并发并行执行，如果让某个线程先执行，一般不使用设置优先级的方式，而使用join、线程通信的方式。
setDaemon()isDaemon() 设置某个线程为守护线程。true=守护线程，false=设置为非守护线程，不调用=false。java进程存在非守护进程

>中断一个线程

目前常见的有以下两种方式：

1. 通过共享的标记来进行沟通。使用自定义的变量来作为标志位. 需要给标志位上加 volatile 关键字(这个关键字的功能后面介绍).

2. 调用 interrupt() 方法来通知

isInterrupted()：返回线程内置的中断标志位，调用以后就会重置标志位。（一般来说，获取中断标志位，无脑的使用isInterrupted()就行）
interrupt()：表示中断这个动作

如果线程处在休眠/等待状态，让线程中断，是以该线程对象抛出异常的方式来中断

中断一个线程到底要不要中断，只由程序自己的逻辑决定

判断中断标志位，如果休眠/等待，抛异常进入catch语句，并重置中断标志位

相当于捕获异常后的逻辑，决定是否中断

thread 收到通知的方式有两种：

1. 如果线程因为调用 wait/join/sleep 等方法而阻塞挂起，则以 InterruptedException 异常的形式通知，清除中断标志当出现 InterruptedException 的时候, 要不要结束线程取决于 catch 中代码的写法. 可以选择忽略这个异常, 也可以跳出循环结束线程.

2. 否则，只是内部的一个中断标志被设置，thread 可以通过

Thread.interrupted() 判断当前线程的中断标志被设置，清除中断标志 Thread.currentThread().isInterrupted() 判断指定线程的中断标志被设置，不清除中断标志

这种方式通知收到的更及时，即使线程正在 sleep 也可以马上收到。

>等待一个线程-join()

有时，我们需要等待一个线程完成它的工作后，才能进行自己的下一步工作。

join()：线程对象t.join()，当前线程加入t线程，当前线程在这行代码等待，等t线程执行完，再执行后面的代码。线程之间是并发并行执行，如果想满足线程间的执行顺序，具体是等某个线程执行完，再执行另一个线程，可以使用join
join(long millis)：一般来说，一直等待某个线程执行完，是不太科学是，一般是使用超时等待（最多等xxx毫秒）

三：线程的状态

NEW：安排了工作，还未开始行动

Runnable：可工作的，又可以分成正在工作中的和即将开始工作

Blocked 、Waiting、Timed_Waiting：这几个都表示排队等着其它事情

Terminated：工作完成了

四：线程安全（重点）

对于多个线程操作同一个共享数据（堆里的对象，方法区中的数据，如静态变量）

（1）如果都是读操作：没有赋值操作，只是获取值——没有安全问题

（2）如果一个读，一个写 / 多个写 ——就会存在线程安全问题

>产生线程安全的原因

原子性：表示一组操作是不可拆分的最小执行单位。某个线程对共享变量的多次操作，中间存在并发并行执行其他线程的对同一个共享变量操作，就不具有原子性。
可见性：多个线程之间，使用自己的工作内存（CPU寄存器）来操作，互相之间是不可及时被看见的，不能及时同步
顺序性：jvm执行字节码指令，cpu执行机器码指令，都可能对多行指令重排序优化执行效率。

记录个小概念~

>如何解决线程不安全的问题

涉及多个线程操作共享变量

（1）对某一段代码使用synchronized关键字）

synchronized 会起到互斥效果, 某个线程执行到某个对象的 synchronized 中时, 其他线程如果也执行到同一个对象 synchronized 就会阻塞等待。

进入 synchronized 修饰的代码块, 相当于加锁；退出 synchronized 修饰的代码块, 相当于解锁

synchronized底层原理：

基于对象头加锁的方式，一个对象，在一个时间，只能有一个线程获取到该对象的锁。（对象有对象头这块区域，其中有一个状态的字段，标识是否加锁）

jvm基于对象头加锁：monitor lock监视器锁，本质上会使用到操作系统mutex lock锁来实现

可以粗略理解成, 每个对象在内存中存储的时候, 都存有一块内存表示当前的 "锁定" 状态(类似于厕所的 "有人/无人").

注意：synchronized加锁，是对象头加锁，不是对对象加锁！！！

synchronnized作用：

前提：多个线程申请同一个对象

1）互斥：同一个时间，只能有一个线程执行同步代码

2）刷新主存：所以 synchronized 也能保证内存可见性

3）可重入性：同一个线程可以多次申请成功同一个锁

语法：

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

synchronized(对象）{

....需要同步的代码

}

//锁当前对象：
public class SynchronizedDemo {
    public void method() {
        synchronized (this) {
            
       }
   }
}
//锁类对象
public class SynchronizedDemo {
    public void method() {
        synchronized (SynchronizedDemo.class) {
       }
   }
}

② 同步方法：使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。

public synchronized void method(){

可能会产生线程安全的代码

}

//1) 直接修饰普通方法:
public class SynchronizedDemo {
    public synchronized void methond() {
   }
}

//2) 修饰静态方法
public class SynchronizedDemo {
    public synchronized static void method() {
   }
}

（2）解决线程安全问题第二种方式：使用volatile 关键字

语法：修饰一个变量的

作用：保证内存可见性，有序性

注意：不保证原子性，所以即使使用volatile修饰n，也是线程不安全的

使用场景：

①读操作：读操作本身是原子性的，所以使用volatile这行语句就是线程安全

②写操作：赋值操作是一个常量值，也可以保证线程安全

（3）解决线程安全问题第三种方式：Lock（是java api提供的一个锁）

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

Lock锁也称同步锁，加锁与释放锁方法化了，如下：

public void lock() :加同步锁。

public void unlock() :释放同步锁。

（后面讲解）

五：关于多线程需要考虑、设计模式

①提高效率——多线程作用就是充分利用cpu资源，提高任务的执行效率

②线程安全——多线程程序的底线

实际设计多线程代码：在满足多线程安全的前提下，尽可能的提高任务效率

Soooooooo如何设计呢——>常见的设计方式

（1）加锁细粒化：加锁的代码行少一点，让部分代码可以并发并行的执行

（2）考虑线程安全问题：没有共享变量操作的代码，没有多线程安全问题，共享变量的读，使用volatile就行

啥是设计模式?

设计模式好比象棋中的 "棋谱". 红方当头炮, 黑方马来跳. 针对红方的一些走法, 黑方应招的时候有一些固定的套路. 按照套路来走局势就不会吃亏. 软件开发中也有很多常见的 "问题场景". 针对这些问题场景, 大佬们总结出了一些固定的套路. 按照这个套路来实现代码, 也不会吃亏.

>单例模式

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

单例模式能保证某个类在程序中只存在唯一一份实例, 而不会创建出多个实例.

某个类的对象，只创建一个对象，所有使用的地方，都使用同一个对象。

典型的：DataSource （数据库连接池，对一个数据库而言，只需要一个数据库连接池）

① 饿汉模式

静态变量=new对象（类加载的同时, 创建实例）

多线程也满足线程安全

class Singleton {
    private static Singleton instance = new Singleton();
    private Singleton() {}
    public static Singleton getInstance() {
        return instance;
   }
}

② 懒汉模式--单线程版

（只能在单线程使用，多线程存在线程安全问题）

静态变量 = null 获取对象的方法中，if(静态方法 = null）静态变量 = new 对象

类加载的时候不创建实例. 第一次使用的时候才创建实例.

lass Singleton {
    private static Singleton instance = null;
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
       }
        return instance;
   }
}

③懒汉式--多线程版

多线程版，加上 synchronized 可以改善这里的线程安全问题，但效率低

//synchronized修饰方法：
public class 单例模式_懒汉式_多线程效率低 {
    private static 单例模式_懒汉式_多线程效率低 instance = null;
    public synchronized static 单例模式_懒汉式_多线程效率低 getInstance(){
        if(instance == null) instance = new 单例模式_懒汉式_多线程效率低();
        return instance;
    }
}


这样写，满足线程安全；为什么说，这样写效率低？
     1.在instance=null的时候，如果有多个线程调用getInstance，需要保证线程安全（一个线程写，其他线程读）
     2.在instance已经赋值给一个创建好的对象以后，再有多个线程调用getInstance（多个线程读）
考虑优化：第1个情况，加锁，第2个情况，使用volatile就可以了


//双重校验锁：
volatile修饰，synchronized加锁，前后使用if判断

public class 单例模式_懒汉式_双重校验锁 {
  private static volatile 单例模式_懒汉式_双重校验锁 instance = null;
  public static 单例模式_懒汉式_双重校验锁 getInstance(){
        if(instance == null) {
            synchronized (单例模式_懒汉式_双重校验锁.class) {
                if(instance == null) {
                    instance = new 单例模式_懒汉式_双重校验锁();
                }
            }
        }
        return instance;
    }
}

volatile的原理：volatile保证可见性，有序性，在java层面看，volatile是无锁操作

Object中有三个方法：必须使用在synchronized同步代码块/同步方法中：哪个对象加锁，就使用哪个对象wait,notify，notifyAll

wait()方法：释放当前线程的锁，并把线程放在等待队列中进行等待，满足一定条件时被唤醒，重新尝试获取这个锁

notify ()方法：是唤醒等待的线程。使它们重新获取该对象的对象锁。在notify()方法后，当前线程不会马上释放该对象锁，要等到执行notify()方法的线程将程序执行完，也就是退出同步代码块synchronized 之后才会释放对象锁。

notifyAll()方法：使用notifyAll方法可以一次唤醒所有的等待线程。

wait 和 sleep 的对比：

1. wait 需要搭配 synchronized 使用. sleep 不需要.

2. wait 是 Object 的方法，sleep 是 Thread 的静态方法.

六：阻塞式队列

1）是一个线程安全的队列结构（先进先出）

2）特性（造成阻塞情况）：

当队列满的时候, 继续入队列就会阻塞, 直到有其他线程从队列中取走元素

当队列空的时候, 继续出队列也会阻塞, 直到有其他线程往队列中插入元素.

3）一般用于做任务的解耦和消峰

解耦：生产和消费不需要一处代码完成生产和消费的代码完全解耦

消峰：生产速度大于消费速度，把任务对象放在队列中，等消息慢慢执行

4）标准库中的阻塞队列

在 Java 标准库中内置了阻塞队列. 如果我们需要在一些程序中使用阻塞队列, 直接使用标准库中的即可.

BlockingQueue 是一个接口. 真正实现的类是 LinkedBlockingQueue.

BlockingQueue<String> queue = new LinkedBlockingQueue<>();
// 入队列
queue.put("abc");
// 出队列. 如果没有 put 直接 take, 就会阻塞. 
String elem = queue.take();

七：线程池

1）为什么要学线程池

之前学过的常量池，数据库连接池，包括这里的线程池，都是属于共享/缓存资源，使用时直接从池里拿。池化，顾名思义，就是将资源统一在一起管理的一种思想。

线程池解决的核心问题就是资源管理问题。减少线程创建和销毁的开销。

2）线程池的核心参数

Java中的线程池核心实现类是ThreadPoolExecutor，ThreadPoolExecutor实现的顶层接口是Executor，顶层接口Executor提供了一种思想：将任务提交和任务执行进行解耦。用户无需关注如何创建线程，如何调度线程来执行任务，用户只需提供Runnable对象，将任务的运行逻辑提交到执行器(Executor)中，由Executor框架完成线程的调配和任务的执行部分。ThreadPoolExecutor，主要构造方法：

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)

corePoolSize：核心线程数。正式员工，招聘后不能解雇。

当提交一个任务到线程池时，线程池会创建一个线程来执行任务，即使有其他空闲线程可以处理任务也会创新线程，等到工作的线程数大于核心线程数时就不会在创建了。如果调用了线程池的prestartAllCoreThreads方法，线程池会提前把核心线程都创造好，并启动

maximumPoolSize：最大线程数。所有员工：包括正式员工和临时工

如果队列满了，并且以创建的线程数小于最大线程数，则线程池会再创建新的线程执行任务。如果我们使用了无界队列，那么所有的任务会加入队列，这个参数就没有什么效果了

keepAliveTime：空闲时间。临时工空闲一段时间就解雇。

线程池的工作线程空闲后，保持存活的时间。如果没有任务处理了，有些线程会空闲，空闲的时间超过了这个值，会被回收掉。如果任务很多，并且每个任务的执行时间比较短，避免线程重复创建和回收，可以调大这个时间，提高线程的利用率。

unit：空闲时间单位。

keepAliveTIme的时间单位，可以选择的单位有天、小时、分钟、毫秒、微妙、千分之一毫秒和纳秒。类型是一个枚举java.util.concurrent.TimeUnit，这个枚举也经常使用，有兴趣的可以看一下其源码

workQueue：阻塞队列。仓库：存放任务

用于缓存待处理任务的阻塞队列，常见的有4种，后面有介绍

threadFactory：线程池中创建线程的工厂。

可以通过线程工厂给每个创建出来的线程设置更有意义的名字

handler：饱和策略。仓库满了，不能放任无，就需要拒绝。

当线程池无法处理新来的任务了，那么需要提供一种策略处理提交的新任务，默认有4种策略，文章后面会提到

public class Demo1 {
    static ThreadPoolExecutor executor = new ThreadPoolExecutor(3,
            5,
            10,
            TimeUnit.SECONDS,
            new ArrayBlockingQueue<Runnable>(10),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.AbortPolicy());
 
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            int j = i;
            String taskName = "任务" + j;
            executor.execute(() -> {
                //模拟任务内部处理耗时
                try {
                    TimeUnit.SECONDS.sleep(j);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + taskName + "处理完毕");
            });
        }
        //关闭线程池
        executor.shutdown();
    }
}