Java多线程编程详解(看这篇就足够了)

Java多线程编程详解(看这篇就足够了)-mikechen

多线程能够提升程序性能，也属于高薪必能核心技术栈，本篇会全面详解Java多线程。@mikechen

主要包含如下几点：

基本概念

很多人都对其中的一些概念不够明确，如同步、并发等等，让我们先建立一个数据字典，以免产生误会。

进程

在操作系统中运行的程序就是进程，比如你的QQ、播放器、游戏、IDE等等

线程

Java多线程编程详解(看这篇就足够了)-mikechen

一个进程可以有多个线程，如视频中同时听声音，看图像，看弹幕，等等。

多线程

多线程：多个线程并发执行。

同步

Java中的同步指的是通过人为的控制和调度，保证共享资源的多线程访问成为线程安全，来保证结果的准确。

比如：synchronized关键字,在保证结果准确的同时，提高性能，线程安全的优先级高于性能。

并行

Java多线程编程详解(看这篇就足够了)-mikechen
多个cpu实例或者多台机器同时执行一段处理逻辑，是真正的同时。

并发

Java多线程编程详解(看这篇就足够了)-mikechen

通过cpu调度算法，让用户看上去同时执行，实际上从cpu操作层面不是真正的同时。

并发往往在场景中有公用的资源，那么针对这个公用的资源往往产生瓶颈，我们会用TPS或者QPS来反应这个系统的处理能力。

 

线程的生命周期

Java多线程编程详解(看这篇就足够了)-mikechen

在线程的生命周期中，它要经过新建(New)、就绪（Runnable）、运行（Running）、阻塞(Blocked)和死亡(Dead)5种状态

  • 新建状态：当程序使用new关键字创建了一个线程之后，该线程就处于新建状态，此时仅由JVM为其分配内存，并初始化其成员变量的值
  • 就绪状态：当线程对象调用了start()方法之后，该线程处于就绪状态。Java虚拟机会为其创建方法调用栈和程序计数器，等待调度运行
  • 运行状态：如果处于就绪状态的线程获得了CPU，开始执行run()方法的线程执行体，则该线程处于运行状态
  • 阻塞状态：当处于运行状态的线程失去所占用资源之后，便进入阻塞状态
  • 死亡状态：线程在run()方法执行结束后进入死亡状态。此外，如果线程执行了interrupt()或stop()方法，那么它也会以异常退出的方式进入死亡状态。

 

线程状态的控制

Java多线程编程详解(看这篇就足够了)-mikechen
可以对照上面的线程状态流转图来看具体的方法，这样更清楚具体作用：

1.start()

启动当前线程, 调用当前线程的run()方法

2.run()

通常需要重写Thread类中的此方法, 将创建的线程要执行的操作声明在此方法中

3.yield()

释放当前CPU的执行权

4.join()

在线程a中调用线程b的join(), 此时线程a进入阻塞状态, 知道线程b完全执行完以后, 线程a才结束阻塞状态

5.sleep(long militime)

让线程睡眠指定的毫秒数，在指定时间内，线程是阻塞状态

6.wait()

一旦执行此方法，当前线程就会进入阻塞，一旦执行wait()会释放同步监视器。

7.sleep()和wait()的异同

相同点：两个方法一旦执行，都可以让线程进入阻塞状态。

不同点：

1) 两个方法声明的位置不同：Thread类中声明sleep(),Object类中声明wait()

2) 调用要求不同：sleep()可以在任何需要的场景下调用。wait()必须在同步代码块中调用。

2) 关于是否释放同步监视器：如果两个方法都使用在同步代码块呵呵同步方法中，sleep不会释放锁，wait会释放锁。

8.notify()

一旦执行此方法，将会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先度最高的。

9.notifyAll()

一旦执行此方法，就会唤醒所有被wait的线程 。

10.LockSupport

LockSupport.park()和LockSupport.unpark()实现线程的阻塞和唤醒的。

 

多线程的5种创建方式

1.继承Thread类

  1. package com.mikechen.java.multithread;
  2.  
  3.  
  4.  
  5. /**
  6. * 多线程创建：继承Thread
  7. *
  8. * @author mikechen
  9. */
  10. class MyThread extends Thread {
  11.  
  12.     private int i = 0;
  13.  
  14.  
  15.     @Override
  16.     public void run() {
  17.         for (i = 0; i < 10; i++) {
  18.             System.out.println(Thread.currentThread().getName() + " " + i);
  19.         }
  20.     }
  21.  
  22.  
  23.     public static void main(String[] args) {
  24.         MyThread myThread=new MyThread();
  25.         myThread.start();
  26.     }
  27.  
  28.  
  29. }

2.实现Runnable接口

  1. package com.mikechen.java.multithread;
  2.  
  3.  
  4. /**
  5. * 多线程创建：实现Runnable接口
  6. *
  7. * @author mikechen
  8. */
  9. public class MyRunnable implements Runnable {
  10.     private int i = 0;
  11.  
  12.     @Override
  13.     public void run() {
  14.         for (i = 0; i < 10; i++) {
  15.             System.out.println(Thread.currentThread().getName() + " " + i);
  16.         }
  17.     }
  18.  
  19.  
  20.     public static void main(String[] args) {
  21.         Runnable myRunnable = new MyRunnable(); // 创建一个Runnable实现类的对象
  22.         Thread thread = new Thread(myRunnable); // 将myRunnable作为Thread target创建新的线程
  23.         thread.start();
  24.     }
  25. }

3.线程池创建

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

  1. package com.mikechen.java.multithread;
  2.  
  3.  
  4. import java.util.concurrent.Executor;
  5. import java.util.concurrent.Executors;
  6.  
  7.  
  8.  
  9. /**
  10. * 多线程创建：线程池
  11. *
  12. * @author mikechen
  13. */
  14. public class MyThreadPool {
  15.  
  16.  
  17.         public static void main(String[] args) {
  18.             //创建带有5个线程的线程池
  19.             //返回的实际上是ExecutorService,而ExecutorService是Executor的子接口
  20.             Executor threadPool = Executors.newFixedThreadPool(5);
  21.             for(int i = 0 ;i < 10 ; i++) {
  22.                 threadPool.execute(new Runnable() {
  23.                     public void run() {
  24.                         System.out.println(Thread.currentThread().getName()+" is running");
  25.                     }
  26.                 });
  27.             }
  28.  
  29.  
  30.  
  31.         }
  32.  
  33.  
  34.  
  35.  
  36. }

核心参数

  1. public ThreadPoolExecutor(
  2.     int corePoolSize,
  3.     int maximumPoolSize,
  4.     long keepAliveTime,
  5.     TimeUnit unit,
  6.     BlockingQueue<Runnable> workQueue,
  7.     ThreadFactory threadFactory,
  8.     RejectedExecutionHandler handler
  9. )
  10. {
  11.     ....
  12. }

Java多线程编程详解(看这篇就足够了)-mikechen

线程池任务执行流程

Java多线程编程详解(看这篇就足够了)-mikechen

从上图可以看出，提交任务之后，首先会尝试着交给核心线程池中的线程来执行，但是必定核心线程池中的线程数有限，所以必须要由任务队列来做一个缓存，先将任务放队列中缓存，然后等待线程去执行。

最后，由于任务太多，队列也满了，这个时候线程池中剩下的线程就会启动来帮助核心线程池执行任务。

如果还是没有办法正常处理新到的任务，则线程池只能将新提交的任务交给饱和策略来处理了。

4.匿名内部类

适用于创建启动线程次数较少的环境，书写更加简便

  1. package com.mikechen.java.multithread;
  2.  
  3.  
  4.  
  5. /**
  6. * 多线程创建：匿名内部类
  7. *
  8. * @author mikechen
  9. */
  10. public class MyThreadAnonymous {
  11.  
  12.  
  13.  
  14.  
  15.         public static void main(String[] args) {
  16.             //方式1：相当于继承了Thread类，作为子类重写run()实现
  17.             new Thread() {
  18.                 public void run() {
  19.                     System.out.println("匿名内部类创建线程方式1...");
  20.                 };
  21.             }.start();
  22.  
  23.  
  24.  
  25.             //方式2:实现Runnable,Runnable作为匿名内部类
  26.             new Thread(new Runnable() {
  27.                 public void run() {
  28.                     System.out.println("匿名内部类创建线程方式2...");
  29.                 }
  30.             } ).start();
  31.         }
  32.  
  33.  
  34.  
  35. }

 

5.Lambda表达式创建

  1. package com.mikechen.java.multithread;
  2.  
  3.  
  4.  
  5. /**
  6. * 多线程创建：lambda表达式
  7. *
  8. * @author mikechen
  9. */
  10. public class MyThreadLambda {
  11.     public static void main(String[] args) {
  12.         //匿名内部类创建多线程
  13.         new Thread(){
  14.             @Override
  15.             public void run() {
  16.                 System.out.println(Thread.currentThread().getName()+"mikchen的互联网架构创建新线程1");
  17.             }
  18.         }.start();
  19.  
  20.  
  21.  
  22.  
  23.         //使用Lambda表达式，实现多线程
  24.         new Thread(()->{
  25.             System.out.println(Thread.currentThread().getName()+"mikchen的互联网架构创建新线程2");
  26.         }).start();
  27.  
  28.  
  29.  
  30.         //优化Lambda
  31.         new Thread(()-> System.out.println(Thread.currentThread().getName()+"mikchen的互联网架构创建新线程3")).start();
  32.  
  33.  
  34.  
  35.     }
  36. }

 

线程的同步

线程的同步是为了防止多个线程访问一个数据对象时，对数据造成的破坏，线程的同步是保证多线程安全访问竞争资源的一种手段。

1.普通同步方法

锁是当前实例对象 ，进入同步代码前要获得当前实例的锁。

  1. /**
  2. * 用在普通方法
  3. */
  4. private synchronized void synchronizedMethod() {
  5. System.out.println("--synchronizedMethod start--");
  6. try {
  7. Thread.sleep(2000);
  8. } catch (InterruptedException e) {
  9. e.printStackTrace();
  10. }
  11. System.out.println("--synchronizedMethod end--");
  12. }

2.静态同步方法

锁是当前类的class对象 ，进入同步代码前要获得当前类对象的锁。

  1. /**
  2. * 用在静态方法
  3. */
  4. private synchronized static void synchronizedStaticMethod() {
  5. System.out.println("synchronizedStaticMethod start");
  6. try {
  7. Thread.sleep(2000);
  8. } catch (InterruptedException e) {
  9. e.printStackTrace();
  10. }
  11. System.out.println("synchronizedStaticMethod end");
  12. }

3.同步方法块

锁是括号里面的对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。

  1. /**
  2. * 用在类
  3. */
  4. private void synchronizedClass() {
  5. synchronized (SynchronizedTest.class) {
  6. System.out.println("synchronizedClass start");
  7. try {
  8. Thread.sleep(2000);
  9. } catch (InterruptedException e) {
  10. e.printStackTrace();
  11. }
  12. System.out.println("synchronizedClass end");
  13. }
  14. }

4.synchronized底层实现

synchronized的底层实现是完全依赖JVM虚拟机的,所以谈synchronized的底层实现，就不得不谈数据在JVM内存的存储：Java对象头，以及Monitor对象监视器。

1.Java对象头

在JVM虚拟机中，对象在内存中的存储布局，可以分为三个区域:

  • 对象头(Header)
  • 实例数据(Instance Data)
  • 对齐填充(Padding)

Java对象头主要包括两部分数据：

Java多线程编程详解(看这篇就足够了)-mikechen

1)类型指针（Klass Pointer）

是对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例;

2)标记字段(Mark Word)

用于存储对象自身的运行时数据，如哈希码（HashCode）、GC分代年龄、锁状态标志、线程持有的锁、偏向线程 ID、偏向时间戳等等,它是实现轻量级锁和偏向锁的关键.

所以，很明显synchronized使用的锁对象是存储在Java对象头里的标记字段里。

2.Monitor

monitor描述为对象监视器,可以类比为一个特殊的房间，这个房间中有一些被保护的数据，monitor保证每次只能有一个线程能进入这个房间进行访问被保护的数据，进入房间即为持有monitor，退出房间即为释放monitor。

下图是synchronized同步代码块反编译后的截图，可以很清楚的看见monitor的调用。

Java多线程编程详解(看这篇就足够了)-mikechen

使用syncrhoized加锁的同步代码块在字节码引擎中执行时，主要就是通过锁对象的monitor的取用(monitorenter)与释放(monitorexit)来实现的。

 

多线程引入问题

多线程的优点很明显，但是多线程的缺点也同样明显，线程的使用（滥用）会给系统带来上下文切换的额外负担,并且线程间的共享变量可能造成死锁的出现。

1.线程安全问题

1)原子性

在并发编程中很多的操作都不是原子操作，比如：

  1. i++;   // 操作2
  2. i = j; // 操作3
  3. i = i + 1; // 操作4

在单线程环境中这3个操作都不会出现问题，但是在多线程环境中，如果不通过加锁操作，往往很可能会出现意料之外的值。

在java中可以通过synchronized或者ReentrantLock来保证原子性。

 

2)可见性

可见性：指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即得到这个修改的值。

Java多线程编程详解(看这篇就足够了)-mikechen

如上图所示，每个线程都有自己的工作内存，工作内存和主存间要通过store和load进行交互。

为了解决多线程的可见性问题，java提供了volatile关键字，当一个共享变量被volatile修饰时，他会保证修改的值会立即更新到主存，当有其他线程需要读取时，他会去主存中读取新值，而普通共享变量不能保证其可见性，因为变量被修改后刷回到主存的时间是不确定的。

2.线程死锁

线程死锁是指由于两个或者多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行。

当线程互相持有对方所需要的资源时，会互相等待对方释放资源，如果线程都不主动释放所占有的资源，将产生死锁，如图所示：

Java多线程编程详解(看这篇就足够了)-mikechen

举一个例子：

  1. public void add(int m) {
  2.     synchronized(lockA) { // 获得lockA的锁
  3.         this.value += m;
  4.         synchronized(lockB) { // 获得lockB的锁
  5.             this.another += m;
  6.         } // 释放lockB的锁
  7.     } // 释放lockA的锁
  8. }
  9.  
  10. public void dec(int m) {
  11.     synchronized(lockB) { // 获得lockB的锁
  12.         this.another -= m;
  13.         synchronized(lockA) { // 获得lockA的锁
  14.             this.value -= m;
  15.         } // 释放lockA的锁
  16.     } // 释放lockB的锁
  17. }

两个线程各自持有不同的锁，然后各自试图获取对方手里的锁，造成了双方无限等待下去，这就是死锁。

3.上下文切换

多线程并发一定会快吗？其实不一定，因为多线程有线程创建和线程上下文切换的开销。

Java多线程编程详解(看这篇就足够了)-mikechen
CPU是很宝贵的资源，速度也非常快，为了保证均衡，通常会给不同的线程分配时间片，当CPU从一个线程切换到另外一个线程的时候，CPU需要保存当前线程的本地数据，程序指针等状态，并加载下一个要执行的线程的本地数据，程序指针等，这个切换称之为上下文切换。

一般减少上下文切换的方法有：无锁并发编程，CAS算法，使用协程等方式。

多线程用好了可以成倍的增加效率，用不好可能比单线程还慢。

 

相关推荐

Java进阶架构师系列专题

2025最全大厂Java面试解析

阿里Java面试真题最全总结

手把手带大型项目实战落地

评论交流
    说说你的看法
欢迎您，新朋友，感谢参与互动！
确定

请输入验证码

请输入图片中的验证码
点击发送按钮获取验证码

取消
×
×
￥undefined
请打开手机使用微信扫码支付
「」
×

....支付确认中....

「」
×
支付金额

￥

undefined
×
积分支付
您当前的积分为0

检测到您未绑定微信账户，请先绑定微信

立刻绑定

打开微信扫一扫

微信长按二维码

关注「mikechen公众号」安全快捷登录

×

下载海报：

点击下载
返回顶部