• 有没有一种可能，我可以学好Java的多线程——知识点汇总

    一、前言

    这篇文章是介绍Java基础知识——多线程的，读完这篇文章，各位小伙伴们可以收获哪些呢？

    • 程序、进程、线程三者的区别
    • 创建线程的四种方式
    • 线程的常用方法
    • 线程的死锁、释放锁
    • 线程的同步原理、生命周期等等

    废话不多说，干货满满，赶快来看看吧~

    二、基本概念

    什么是程序？

    • 程序是为完成特定任务、用某种语言编写的一组指令的集合。大白话来讲，就是我们写的代码

    什么是进程？

    • 进程是程序的一次执行过程，或是正在运行的一个程序。例如运行中的QQ、微信，运行中的MP3播放器等等，有它自身的产生、存在和消亡的过程

    什么是线程？

    • 线程是由进程创建的，是进程的一个实体，一个进程可以拥有多个线程，也可以有单个线程

    三、创建线程

    1、方式一

    继承 Thread类 ，看代码：

    1. public class Thread_one {
    2.     public static void main(String[] args) throws InterruptedException {
    3.         Person person = new Person();
    4.         person.start();
    5.         //当启动线程时，子线程和主线程会交替执行
    6.         //主线程结束，子线程不一定结束
    7.         //person.run()就是一个普通的方法，没有真正的启动一个线程
    8.         for (int i = 0; i < 20; i++) {
    9.             System.out.println("main线程执行");
    10.             Thread.sleep(1000);
    11.         }
    12.     }
    13. }
    14. class Person extends Thread {
    15.     @Override
    16.     public void run() {
    17.         int times = 0;
    18.         while (true) {
    19.             try {
    20.                 System.out.println("大家好，我是卷心菜~"
    21.                         + (++times)
    22.                         + "号" + "线程名是——"
    23.                         + Thread.currentThread().getName());
    24.                 Thread.sleep(2000);
    25.                 if (times == 50) break;
    26.             } catch (InterruptedException e) {
    27.                 e.printStackTrace();
    28.             }
    29.         }
    30.     }
    31. }

    该代码的功能是：启动一个子线程，在控制台打印50次 “大家好，我是卷心菜” ，主线程在控制台打印 “main线程执行” ，运行的部分结果如下：

    我们来重点剖析一下这种创建方式，因为后面三种方式本质上区别不大。

    当我们 Person类 继承 Thread类 以后，就要重写 run() ，方法体内写上自己需要的代码逻辑。语句 Thread.sleep(2000); 意思是，每打印一句话在控制台后，子线程就要“休息”2秒，在这“休息”的时间，主线程就开始执行自己的语句；同样，在主线程“休息”的时间，子线程也开始执行自己的语句。

    总之，子线程和主线程会交替执行，多次运行可以发现，主线程结束，子线程不一定结束。这里需要特别注意。

    爱思考的小伙伴们可能就要问了：我们在Person类中重写了run()，但是怎么使用线程的时候，调用的是start()，那run()谁来执行的呢？别着急，让我们进去源码看一看。

    我们从源码中可以发现，start()调用了start0()，而start0()是一个本地方法，由JVM调用，只是我们看不到而已。

    2、方式二

    方式一明白了，再看看第二种方式，代码如下：

    1. public class Thread_two {
    2.     public static void main(String[] args) {
    3.         Animal animal = new Animal();
    4.         Thread thread = new Thread(animal);
    5.         thread.start();
    6.     }
    7. }
    8. class Animal implements Runnable {
    9.     int times = 0;
    10.     @Override
    11.     public void run() {
    12.         while (true) {
    13.             System.out.println("大家好，我是Tomcat~");
    14.             try {
    15.                 Thread.sleep(2000);
    16.                 ++times;
    17.                 if (times == 10) break;
    18.             } catch (InterruptedException e) {
    19.                 e.printStackTrace();
    20.             }
    21.         }
    22.     }
    23. }

    此代码逻辑也很好理解，这里就不过多讲述了。我们来分析一下：为什么要使用类实现接口的方式来创建线程？

    学过基础的小伙伴们都知道，我们Java是单继承的。因此，在某些情况下一个类可能已经继承了某个类，这时再用继承Thread类方法来创建线程就不可以了，所以我们有了Runnable接口。

    3、方式三

    再来看看方式三，代码如下：

    1. public class Thread_six {
    2.     public static void main(String[] args) throws Exception {
    3.         D d = new D();
    4.         FutureTask futureTask = new FutureTask(d);
    5.         Thread thread = new Thread(futureTask);
    6.         thread.start();
    7.         Object o = futureTask.get();
    8.         System.out.println(o);
    9.     }
    10. }
    11. class D implements Callable {
    12.     @Override
    13.     public Object call() throws Exception {
    14.         int sum = 0;
    15.         for (int i = 0; i < 5; i++) {
    16.             System.out.println(i + 1);
    17.             sum += i;
    18.         }
    19.         return sum;
    20.     }
    21. }

    来看看运行结果：

    与 Runnable类 相比，类 Callable 功能更强大些，具体有如下优点：

    • 相比run()方法，可以有返回值
    • 方法可以抛出异常
    • 支持泛型的返回值
    • 需要借助FutureTask类，比如获取返回结果

    4、方式四

    最后来看看第四种方式，使用线程池，也是最推荐使用的方式，代码如下：

    1. public class Thread_seven {
    2.     public static void main(String[] args) {
    3.         ExecutorService service =
    4.                 Executors.newFixedThreadPool(10);
    5. //        service 可以理解为池子
    6.         service.execute(new F()); //适用于Runnable
    7. //        service.submit();  //适用于Callable
    8.         service.shutdown();//关闭线程池
    9.     }
    10. }
    11. class F implements Runnable {
    12.     @Override
    13.     public void run() {
    14.         for (int i = 0; i < 5; i++) {
    15.             System.out.println(i + 1);
    16.             try {
    17.                 Thread.sleep(1000);
    18.             } catch (InterruptedException e) {
    19.                 e.printStackTrace();
    20.             }
    21.         }
    22.     }
    23. }

    运行结果没有任何问题：

    四、常用方法

    1、第一组

    • public Thread(Runnable target)：返回对当前正在执行的线程对象的引用
    • public synchronized void start()：开启线程
    • public final synchronized void setName(String name)：设置线程名
    • public final void setPriority(int newPriority)：设置线程的优先级别
    • public static native void sleep(long millis)：设置线程的睡眠时间
    • public void interrupt()：中断线程，但并没有结束线程，一般用于中断正在休眠的线程

    这么多的方法，用代码实践一下：

    1. public class Thread_five {
    2.     public static void main(String[] args) {
    3.         A a = new A();
    4.         Thread thread = new Thread(a);
    5.         thread.setName("棒棒糖线程");
    6.         thread.setPriority(Thread.MIN_PRIORITY);
    7.         thread.start();
    8.         thread.interrupt();
    9.         for (int i = 0; i < 20; i++) {
    10.             System.out.println("主线程开始行动");
    11.             try {
    12.                 Thread.sleep(10000);
    13.             } catch (InterruptedException e) {
    14.                 e.printStackTrace();
    15.             }
    16.         }
    17.     }
    18. }
    19. class A implements Runnable {
    20.     @Override
    21.     public void run() {
    22.         while (true) {
    23.             try {
    24.                 for (int i = 0; i < 10; i++) {
    25.                     System.out.println("我要吃" + (i + 1) +
    26.                             "棵棒棒糖，所处的线程是："
    27.                             + Thread.currentThread().getName());
    28.                 }
    29.                 System.out.println("吃多了，要消化20秒");
    30.                 Thread.sleep(20000);
    31.             } catch (InterruptedException e) {
    32.                 e.printStackTrace();
    33.             }
    34.         }
    35.     }
    36. }

    带大家看一下线程的优先级：

    MAX_PRIORITY：10 
MIN _PRIORITY：1
NORM_PRIORITY：5

    截取一部分运行结果：

    解析一下：由于把子线程的优先级设置为最低，主线程拿到了优先执行的语句，输出 "主线程开始行动" ，然后在主线程睡眠时间时，子线程开始执行，当执行完：吃多了，要消化20秒时，本应该等待20秒，但是interrupt()打断了子线程，所以就会出现上图的情况。

    如果把语句 thread.interrupt(); 删去，就会出现下图的结果：

    2、第二组

    • public final void join()：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止
    • public static native void yield()：暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程

    直接上代码演示：

    1. public class Thread_one {
    2.     public static void main(String[] args) throws InterruptedException {
    3.         T t = new T();
    4.         Thread thread = new Thread(t);
    5.         thread.start();
    6.         for (int i = 0; i < 15; i++) {
    7.             Thread.sleep(100);
    8.             System.out.println("主线程吃了" + (i+ 1) + "颗棒棒糖");
    9.             if (i == 4) {
    10.                 System.out.println("让子线程先吃吧");
    11.                 thread.join();
    12. //                thread.yield();
    13.                 System.out.println("子线程吃完了，该我了");
    14.             }
    15.         }
    16.     }
    17. }
    18. class T implements Runnable{
    19.     @Override
    20.     public void run() {
    21.         for (int i = 0; i < 10; i++) {
    22.             try {
    23.                 Thread.sleep(1000);
    24.             } catch (InterruptedException e) {
    25.                 e.printStackTrace();
    26.             }
    27.             System.out.println("子线程吃了" + (i + 1) + "颗棒棒糖");
    28.         }
    29.     }
    30. }

    运行结果：

    由代码和运行结果图可以看出：因为语句 thread.join(); 的出现，导致主线程必须等到子线程结束后才能继续执行自己的代码，这就是 join() 的作用。

    五、守护线程

    Java中的线程分为两类：一种是守护线程，一种是用户线程。 它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。

    守护线程是用来服务用户线程的，通过在start()方法前调用 thread.setDaemon(true) 可以把一个用户线程变成一个守护线程。

    下面用代码演示一下：

    1. public class Thread_two {
    2.     public static void main(String[] args) throws InterruptedException {
    3.         A a = new A();
    4.         Thread thread = new Thread(a);
    5.         //下面的方法要在start方法使用前使用，目的是当我们希望main方法结束后，子线程也可以结束；即把子线程设为守护线性
    6.         thread.setDaemon(true);
    7.         thread.start();
    8.         for (int i = 0; i < 10; i++) {
    9.             Thread.sleep(100);
    10.             System.out.println("我在疯狂打游戏~");
    11.         }
    12.     }
    13. }
    14. class A  implements Runnable{
    15.     @Override
    16.     public void run() {
    17.         while (true) {
    18.             try {
    19.                 Thread.sleep(1000);
    20.                 System.out.println("室友们在努力内卷学习~");
    21.             } catch (InterruptedException e) {
    22.                 e.printStackTrace();
    23.             }
    24.         }
    25.     }
    26. }

    即当语句 我在疯狂打游戏 结束之后，守护线程的执行语句 室友们在努力内卷学习 就结束了，不在执行。

    六、生命周期

    要想实现多线程，必须在主线程中创建新的线程对象。我们可以使用Thread类 及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五 种状态：

    • 新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建 状态
    • 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已 具备了运行的条件，只是没分配到CPU资源
    • 运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线 程的操作和功能
    • 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中 止自己的执行，进入阻塞状态
    • 死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

      代码演示一下：
    1. public class Thread_three {
    2.     public static void main(String[] args) throws InterruptedException {
    3.         B b = new B();
    4.         Thread thread = new Thread(b);
    5.         System.out.println(thread.getName() + "状态为" + thread.getState());
    6.         thread.start();
    7.         //只要子线程状态不是终止状态，就继续查看子线程的状态
    8.         while (Thread.State.TERMINATED != thread.getState()) {
    9.             System.out.println(thread.getName() + "状态" + thread.getState());
    10.             Thread.sleep(500);
    11.         }
    12.         System.out.println(thread.getName() + "状态" + thread.getState());
    13.     }
    14. }
    15. class B implements Runnable {
    16.     @Override
    17.     public void run() {
    18.         while (true) {
    19.             for (int i = 0; i < 5; i++) {
    20.                 try {
    21.                     Thread.sleep(1000);
    22.                     System.out.println("我说了" + (i + 1) + "次Hi");
    23.                 } catch (InterruptedException e) {
    24.                     e.printStackTrace();
    25.                 }
    26.             }
    27.             break;
    28.         }
    29.     }
    30. }

    运行结果：

    七、线程的同步

    下面案例都以模仿卖票入手，解决卖超的情形

    1、方式一

    • 同步方法
    1. public class Thread_four {
    2.     public static void main(String[] args) {
    3.         Ticket ticket = new Ticket();
    4.         Thread thread1 = new Thread(ticket);
    5.         Thread thread2 = new Thread(ticket);
    6.         thread1.start();
    7.         thread2.start();
    8.     }
    9. }
    10. class Ticket implements Runnable{
    11.  
    12.     private int tickets = 30;
    13.     @Override
    14.     public synchronized void run() {
    15.         while (true) {
    16.             try {
    17.                 if (tickets <= 0) {
    18.                     System.out.println("票没了，售票结束！");
    19.                     break;
    20.                 }
    21.                 System.out.println("窗口" + Thread.currentThread().getName()
    22.                         + "出售了一张票，还剩下"
    23.                         + --tickets + "张票");
    24.                 Thread.sleep(100);
    25.             } catch (InterruptedException e) {
    26.                 e.printStackTrace();
    27.             }
    28.         }
    29.     }
    30. }

    运行结果：

    2、方式二

    • 同步代码块
    1. class Ticket implements Runnable {
    2.     private int tickets = 30;
    3.     @Override
    4.     public void run() {
    5.         synchronized (this) {
    6.             while (true) {
    7.                 try {
    8.                     if (tickets <= 0) {
    9.                         System.out.println("票没了，售票结束！");
    10.                         break;
    11.                     }
    12.                     System.out.println("窗口" + Thread.currentThread().getName()
    13.                             + "出售了一张票，还剩下"
    14.                             + --tickets + "张票");
    15.                     Thread.sleep(100);
    16.                 } catch (InterruptedException e) {
    17.                     e.printStackTrace();
    18.                 }
    19.             }
    20.         }
    21.     }
    22. }

    八、锁

    1、死锁

    1. public class Thread_five {
    2.     public static void main(String[] args) {
    3.         DeadLock deadLock1 = new DeadLock(true);
    4.         DeadLock deadLock2 = new DeadLock(false);
    5.  
    6.         Thread thread1 = new Thread(deadLock1);
    7.         Thread thread2 = new Thread(deadLock2);
    8.         thread1.start();
    9.         thread2.start();
    10.     }
    11. }
    12.  
    13. class DeadLock implements Runnable {
    14.     static Object o1 = new Object();// 保证多线程，共享一个对象,这里使用 static
    15.     static Object o2 = new Object();
    16.     boolean flag;
    17.     public DeadLock(boolean flag) {
    18.         this.flag = flag;
    19.     }
    20.     @Override
    21.     public void run() {
    22.         //下面业务逻辑的分析 //1. 如果 flag 为 T, 线程 A 就会先得到/持有 o1 对象锁, 然后尝试去获取 o2 对象锁
    23.         // 2. 如果线程 A 得不到 o2 对象锁，就会 Blocked
    24.         // 3. 如果 flag 为 F, 线程 B 就会先得到/持有 o2 对象锁, 然后尝试去获取 o1 对象锁
    25.         // 4. 如果线程 B 得不到 o1 对象锁，就会 Blocked
    26.         if (flag) {
    27.             synchronized (o1) {//对象互斥锁, 下面就是同步代码
    28.                 System.out.println(Thread.currentThread().getName() + " 进入 1");
    29.                 synchronized (o2) { // 这里获得 li 对象的监视权
    30.                     System.out.println(Thread.currentThread().getName() + " 进入 2");
    31.                 }
    32.             }
    33.         } else {
    34.             synchronized (o2) {
    35.                 System.out.println(Thread.currentThread().getName() + " 进入 3");
    36.                 synchronized (o1) { // 这里获得 li 对象的监视权
    37.                     System.out.println(Thread.currentThread().getName() + " 进入 4");
    38.                 }
    39.             }
    40.         }
    41.     }
    42. }

    运行结果：

    2、释放锁

    因为不好演示，所以就介绍一下释放锁的各种情况：

    • 当前线程的同步方法、同步代码块执行结束
    • 当前线程在同步代码块、同步方法中遇到break、return
    • 当前线程在同步代码块、同步方法中出现了未处理的ERROR、Exception，导致异常结束

    最后再介绍不会释放锁的情况：

    • 线程执行同步代码块或同步方法时，程序调用sleep()、yield()暂停当前线程的执行，不会释放锁
    • 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程也不会释放锁

    总结

    乐莫乐兮新相知，很高兴各位小伙伴可以坚持看完这篇文章。 一起加油，一起进步！

  • 相关阅读:
    公共关系学试题与参考答案
    go设计模式——适配器模式 2
    windows下部署nginx+PHP环境，连接SQL Server
    【自然语言处理】【向量表示】PairSupCon：用于句子表示的成对监督对比学习
    国标EHOME视频平台EasyCVR视频融合平台助力地下停车场安全
    【Day_14 0510】▲手套
    c语言练习41：深入理解字符串函数strlen strcpy strcat
    多用户对应多租户解决方案
    第八章 Linux文件系统权限
    代码随想录算法训练营第23期day60|84.柱状图中最大的矩形
  • 原文地址：https://blog.csdn.net/Park33/article/details/126067973