[Java]多线程学习笔记

最新推荐文章于 2024-05-17 13:43:01 发布

好奇的小黑

最新推荐文章于 2024-05-17 13:43:01 发布

阅读量127

点赞数 1

分类专栏：语言学习笔记文章标签： java

本文链接：https://blog.csdn.net/baiyidujiangwert/article/details/120662893

版权

语言学习笔记专栏收录该内容

4 篇文章 0 订阅

订阅专栏

为什么要有多线程？

程序在执行过程中，由于存储介质IO和CPU的计算速度不匹配，导致顺序执行的情况下，CPU会等待IO执行完毕，造成CPU的大量浪费。

因此引入多线程，当程序发生IO时，释放CPU资源，供其他程序使用，利用率更高。

多线程的核心知识点：

线程的概念
线程有哪些状态
线程操作
线程池
锁，synchronized和volatile关键字
JUC包

线程的概念

线程是程序执行的一个路径，每一个线程都有自己的局部变量表、程序计数器（指向正在执行的指令指针）以及各自的生命周期，现代操作系统中一般不止一个线程在运行，当启动了一个Java虚拟机（JVM）时，从操作系统开始就会创建一个新的进程（JVM进程），JVM进程中将会派生或者创建很多线程。

——《Java高并发编程详解：多线程与架构设计》

线程的状态

生命周期，有的状态：

创建(New)：在JVM中申请线程内存；
阻塞(Blocked)：被中断，释放CPU的占用；
运行(Running)：线程执行中；
可执行(Runable)：等待状态，轮训CPU资源；
销毁(Terminated)：执行Stop()操作，回收线程内存；

线程各状态转换示意图：

执行Start()操作才会创建线程，只创建对象不会创建线程，线程才能进入Runable状态，才真正地在JVM进程中创建了一个线程；
由Running切换到Runnable状态：可以调用yield()，主动放弃CPU执行权；
RUNNABLE的线程只能意外终止或者进入RUNNING状态。

线程操作

创建线程

Java 提供了三种创建线程的方法：

通过实现 Runnable 接口；
通过继承 Thread 类本身；
通过 Callable 和 Future 创建线程。

class RunnableTest extends Thread {} // 继承类的方法
class RunnableTest implements Runnable {}  // 实现接口的方法
//都需要实现run()函数；

创建线程的三种方式的对比

采用实现 Runnable、Callable 接口的方式创建多线程时，线程类只是实现了 Runnable 接口或 Callable 接口，还可以继承其他类。
使用继承 Thread 类的方式创建多线程时，编写简单，如果需要访问当前线程，则无需使用 Thread.currentThread() 方法，直接使用 this 即可获得当前线程。

总结看：继承Thread的线程封装较完整，可调整性不高；实现接口的方法更加灵活。

常用函数

stop()：销毁线程；
yield()：表示当前线程放弃CPU的资源占用，Running切换到Runnable状态；
sleep()：阻塞线程；
join()：设定当达到什么情况时，线程阻塞；
interrupt()：线程中断；

public void interrupt()
public static boolean interrupted()
public boolean isInterrupted()

wait(),join(),sleep()方法会导致线程进入阻塞状态，interrupt()用于打断阻塞状态。

由于线程的interrupt标识很有可能被擦除，或者逻辑单元中不会调用任何可中断方法，所以使用volatile修饰的开关flag关闭线程也是一种常用的做法。

notify()：唤醒单个正在执行该对象wait方法的线程，需要和wait()配对使用。

wait()和sleep()方法的区别：

sleep()是Thread类的特有方法
wait()和notify()是Object都有的方法
线程在同步方法中执行sleep方法时，并不会释放monitor的锁，而wait方法则会释放monitor的锁。

线程的属性

线程名称：getName()
线程ID：getID()，在JVM中的唯一编号
线程优先级：getPriority() [一般不用]
是否是守护线程：main()函数就是一个守护线程，当所有线程均非守护线程时候，JVM关停进程。
获取当前线程：currentThread()

线程池

解决的问题：

加载JVM时，初始创建一批线程，使用时候直接调取，使用完毕之后放回线程池，不做回收动作，待再次直接调用。

优势是不用再频繁创建回收线程，本质还是空间换时间。

核心概念

核心线程数：加载JVM时初始创建的线程数；

临时线程池：线程结束，就地销毁；

线程队列：核心线程池不够用时，线程放置在队列中，配合拒绝策略使用；

拒绝策略：线程队列满了之后，做的操作，一种是忽略请求，还有是抛异常等策略；

线程工厂：给出一批线程“模板”，可以直接复制生成线程，不需要自行定义线程。

init:初始化线程队列大小
core：常规状态下保留的核心线程数
max：线程池可以容纳的最大线程数，也可以设置为不限容量的队列，但是会造成OOM

使用方法

创建线程池

参数：

corePool ：核心线程池
maximumPool：线程池
BlockQueue：队列
RejectedExecutionHandler：拒绝策略
线程存活时间：非核心线程，空闲超过一定时间进行销毁。

ExecutorService threadPool = new ThreadPoolExecutor(
                5,   // 核心线程数
                10,   // 最大线程数
                0L, TimeUnit.MILLISECONDS,   // 线程存活时间
                new LinkedBlockingQueue<Runnable>());   // 线程队列类型

Executors 是线程池工厂类，集成多种不同的线程池类型，可以使用Executors直接创建不同类型的线程池。

调用线程池

threadPool.execute(new ThreadDemo(String.valueOf(i)));
// 调取Runable类

关闭线程池

shutdown()：不接受新的线程，池子里的执行完毕就关闭线程池
shutdownNow()：立即中断池中的所有线程，并关闭线程池。

threadPool.shutdown();

执行流程

线程池申请流程：

判断核心线程池是否已满，如果不是，则创建线程执行任务；
如果核心线程池满了，判断队列是否满了，如果队列没满，将任务放在队列中；
如果队列满了，则判断线程池是否已满，如果没满，创建线程执行任务
如果线程池也满了，则按照拒绝策略对任务进行处理

Demo

public static void threadPoolDemo(){
    // 定义线程池
    ExecutorService threadPool = new ThreadPoolExecutor(
                5,   // 核心线程数
                10,   // 最大线程数
                0L, TimeUnit.MILLISECONDS,   // 线程存活时间
                new LinkedBlockingQueue<Runnable>());   // 线程队列类型，Linked类型没有个数限制，但是有OOM风险

    for(int i = 0;i < 20 ; i++){
        threadPool.execute(new ThreadDemo(String.valueOf(i)));
    }

    // 关闭线程池
    threadPool.shutdown();
}

锁

主要是解决数据不一致问题：幻读幻写。

锁提供了两种主要特性：互斥（mutual exclusion）和可见性（visibility）。

关键字：volatile

解决的问题

由于JVM的内存模型，线程操作的数据均为缓存Cache中的值，并不会实时修改内存中的变量值。volatile修饰的变量，可以同步变更内存中的值。

所以volatile并不是“锁”，而是一种同步机制。

Java的内存模型（Java Memory Mode，JMM）中定义了线程和主内存之间的抽象关系如下图：

线程之间变量共享

volatile关键字只能修饰类变量和实例变量，对于方法参数、局部变量以及实例常量，类常量都不能进行修饰。

Demo：

public class Test {
    public volatile int inc = 0;
     
    public void increase() {
        inc++;
    }
     
    public static void main(String[] args) {
        final Test test = new Test();
        for(int i=0;i<10;i++){
            new Thread(){
                public void run() {
                    for(int j=0;j<1000;j++)
                        // volatile修饰之后，每次累加的都是内存中的值，各个线程读取到的一样。
                        test.increase();
                };
            }.start();
        }
         
        while(Thread.activeCount()>1)  //保证前面的线程都执行完
            Thread.yield();
        System.out.println(test.inc);
    }
}

使用volatile关键字的场景：状态标记量

volatile boolean inited = false;
//线程1:
context = loadContext();  
inited = true;            
 
//线程2:
while(!inited ){
sleep()
}
doSomethingwithconfig(context);

关键字：synchronized

JDK官网对synchronized的解释：synchronized关键字可以实现一个简单的策略来防止线程干扰和内存一致性错误，如果一个对象对多个线程是可见的，那么对该对象的所有读或者写都将通过同步的方式来进行。

是一种互斥锁
可以同步方法，也可以同步代码块，不能同步变量。
修饰class类

Demo：线程安全的单例模式

class Singleton{
    // 需要volatile关键字的原因是，在并发情况下，如果没有volatile关键字，new TestInstance()会出问题
    private volatile static Singleton object = null;
    private Singleton(){
        System.out.println("正在创建对象…………");
        // 禁止new对象
    }
    public static Singleton getInstance(){
        if (object == null){
            // 懒汉式单例模式，调用时候才创建
            synchronized(Singleton.class){
                if(object == null){
                    // 双重锁，只在创建对象时对线程加锁
                    object = new Singleton();
                }
            }
        }
        return object;
    }
    public void show(){
        System.out.println("当前对象已经创建完毕：" + this.object);
    }
}


public static void main(String[] args) {
    Singleton.getInstance().show();
    Singleton.getInstance().show();
}
//正在创建对象…………
//当前对象已经创建完毕：com.learning.java.multithread.Singleton@7f31245a
//当前对象已经创建完毕：com.learning.java.multithread.Singleton@7f31245a

JMM“三性”问题

并发编程有三个至关重要的特性，分别是原子性、有序性和可见性。

原子性：动作是统一整体，要成功都成功，要失败都失败。参照数据库写操作。

可见性：当一个线程对共享变量进行了修改，那么另外的线程可以立即看到修改后的最新值；

有序性：是指程序代码在执行过程中的先后顺序，由于Java在编译器以及运行期的优化，导致了代码的执行顺序未必就是开发者编写代码时的顺序。

单线程模式下问题不大，多线程模型的有序性是最大的挑战。

volatile关键字不保证数据的原子性，由synchronized关键字保证。

JMM中怎么保障三个特性：

Java内存模型（JMM）只保证了基本读取和赋值的原子性操作，其他的均不保证，如果想要使得某些代码片段具备原子性，需要使用关键字synchronized，或者JUC中的lock。
volatile关键字不具备保证原子性的语义。
Java使用volatile关键字，保障可见性

对于共享资源的读操作会直接在主内存中进行（当然也会缓存到工作内存中，当其他线程对该共享资源进行了修改，则会导致当前线程在工作内存中的共享资源失效，所以必须从主内存中再次获取），对于共享资源的写操作当然是先要修改工作内存，但是修改结束后会立刻将其刷新到主内存中。

如果没有volatile关键字修饰，变量会优先存储在线程的本地内存中，不定期的刷新到主内存中。
所以synchronize和volatile的适用场景不一样，作用也不一样，synchronize类似于加锁，保障某一段代码一个时期只有一个线程使用，从而保障顺序性，释放锁之前，也会把变量的修改刷新到主内存；volatile是内存同步的机制，修饰的变量，变更时实时同步。
Java多线程环境下的有序性，使用三种方式来保障：
- 使用volatile关键字来保证有序性。
- 使用synchronized关键字来保证有序性。
- 使用显式锁Lock来保证有序性。
volatile关键字具有保证顺序性的语义。

锁的类型

乐观锁
悲观锁
cas （compare and swap) 比较并交换[无锁]
独占锁、共享锁；可重入的独占锁ReentrantLock、共享锁实现原理
公平锁和非公平锁

重点：学会排除死锁。

JUC包

工具包：java.util.concurrent，主要提供一系列线程安全的工具。由以下四部分组成：

Interface

典型的有Executor

Executor是一个简单的标准化接口，用于定义自定义类线程子系统，包括线程池、异步I/O和轻量级任务框架。根据使用的具体Executor类的不同，任务可以在新创建的线程、现有的任务执行线程或调用execute的线程中执行，并可以顺序执行或并发执行。

Class

典型的如：ConcurrentLinkedQueue

ConcurrentLinkedQueue类提供了一个高效的可伸缩线程安全的非阻塞FIFO队列。

ThreadPoolExecutor

提供线程池工厂类。

Enum

只有一个枚举类型：TimeUnit

TimeUnit主要用于通知基于时间的方法如何解释给定的时间参数。

枚举内容包括：

DAYS、HOURS、SECONDS等。

Exception

例如：RejectedExecutionException等

使用场景，线程池已满，拒绝接受新线程时，可以抛出JUC中定义的异常。

常见问题

进程&线程区别

线程：一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

进程：一个进程包括由操作系统分配的内存空间，包含一个或多个线程。一个线程不能独立的存在，它必须是进程的一部分。一个进程一直运行，直到所有的非守护线程都结束运行后才能结束。

进程和线程是一对多的关系，一个进程是一个资源单位。独占一个存储区域，同一进程中的线程共享该存储区域。

并行与并发：

并行：多个cpu实例或者多台机器同时执行一段处理逻辑，是真正的同时。（Hadoop架构）
并发：通过cpu调度算法，让用户看上去同时执行，实际上从cpu操作层面不是真正的同时。并发往往在场景中有公用的资源，那么针对这个公用的资源往往产生瓶颈，我们会用TPS或者QPS来反应这个系统的处理能力。（Java多线程）

生产者消费者模式

Linux线程相关指令

# 计算系统中有几颗CPU
frilab@ubuntu:~$ cat /proc/cpuinfo |grep "physical id" | sort -u |wc -l
4
# 计算每颗CPU中有几颗核心
frilab@ubuntu:~$ cat /proc/cpuinfo |grep "cpu cores" |sort -u
# cpu cores : 6
# 计算系统中有多少个CPU线程
frilab@ubuntu:~$ cat /proc/cpuinfo |grep "processor" |wc -l
# 48
# 根据以上的3个参数，可以推算出，系统共有4颗CPU，每颗CPU有6个核心，每个CPU核心为双线程，总计有48个线程。

内存分析工具

常用内存分析工具：jstack、jconsole、jvisualvm[JDK自带，bin路径下]

jvisualvm图例如下：

参考文档

好奇的小黑

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
[Java]多线程学习笔记

为什么要有多线程？程序在执行过程中，由于存储介质IO和CPU的计算速度不匹配，导致顺序执行的情况下，CPU会等待IO执行完毕，造成CPU的大量浪费。因此引入多线程，当程序发生IO时，释放CPU资源，供其他程序使用，利用率更高。多线程的核心知识点：线程的概念线程有哪些状态线程操作线程池锁，synchronized和volatile关键字JUC包线程的概念线程是程序执行的一个路径，每一个线程都有自己的局部变量表、程序计数器（指向正在执行的指令指针）以及各自的生命周期，现代操作系统
复制链接

扫一扫