• Java---线程详解（并发并行，Thread类，Runnable接口，同步机制，线程死锁......）

    目录

    一、概念

    1、进程

    2、线程

    （1）单线程

    （2）多线程

    （3）并发

    （4）并行

    二、线程基本使用

    1、创建线程的两种方式

     （1）继承Thread类

    （2）实现Runnable接口

    （3）继承Thread和实现Runnable接口的区别

    2、多线程执行

    售票系统------>

    3、线程常用方法

    （1）第一组 

    （2）第二组 

    （3）用户线程和守护线程

    三、线程终止

    四、线程的生命周期

    五、线程同步机制

    1、同步概念

    2、同步实现synchronized

    （1）同步代码块

    （2）方法声明

    售票系统修正

    3、互斥锁

     4、线程死锁

     5、释放锁

    （1）以下操作会释放锁

    （2）以下操作不会释放锁

    一、概念

    1、进程

    进程是指运行中的程序，比如我们使用QQ，就启动了一个进程，操作系统就会为该进程分配内存空间。当我们使用迅雷，又启动了一个进程，操作系统将为迅雷分配新的内存空间。

    进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程：有它自身的产生、存在和消亡的过程。

    2、线程

    线程由进程创建的，是进程的一个实体

    一个进程可以拥有多个线程

    （1）单线程

    同一个时刻，只允许执行一个线程

    （2）多线程

    同一个时刻，可以执行多个线程

    （3）并发

    同一个时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简单的说，单核cpu实现的多任务就是并发。

    （4）并行

    同一个时刻，多个任务同时执行。多核cpu可以实现并行。

    二、线程基本使用

    1、创建线程的两种方式

    • 继承Thread类，重写run方法
    • 实现Runnable接口，重写run方法
       

     

     （1）继承Thread类

    案例1：请编写程序，开启一个线程，该线程每隔1秒。在控制台输出“瞄瞄,我是小猫咪"，

    对上题改进：当输出80次瞄瞄，我是小猫咪，结束该线程。

    想要看到线程，可以使用JConsole监控线程执行情况。 

    注意看注释哦！------>

    关于其中用来开启线程的start方法：何不直接用run方法？

    注意：run方法只是一个普通的方法，它不会启动一个新的线程，只是方法被调用而已，要把这个run方法执行完毕才能往下执行，并非多线程；需要start开启一个线程。

    1. public class Thread01 {
    2.     public static void main(String[] args){
    3.         // 创建一个Cat对象，可以当做线程使用
    4.         Cat cat = new Cat();
    5.         cat.start(); // 启动线程
    6.         // 当main线程启动一个子线程后，主线程不会阻塞，会继续执行
    7.         // 这时主线程和子线程交替执行
    8.         System.out.print("主线程继续执行"+Thread.currentThread().getName()+"\n");
    9.         for(int i = 0; i < 10 ; i++){
    10.             System.out.print("主线程 i = "+i+"\n");
    11.             // 让主线程休眠
    12.             try{
    13.                 Thread.sleep(1000);
    14.             }
    15.             catch (InterruptedException e){
    16.                 e.printStackTrace();
    17.             }
    18.         }
    19.     }
    20. }
    21.  
    22. // 1、Thread类中的run方法是它实现了Runnable接口中的run
    23. // 2、当一个类继承了Thread类，该类就可以当作线程使用
    24. // 3、我们会重写run方法，写上自己的业务代码
    25. class Cat extends Thread{
    26.     public void run(){
    27.         int count = 0;
    28.         while(count != 80){
    29.             count ++;
    30.             // 该线程每隔1秒。在控制台输出"瞄瞄,我是小猫咪"，
    31.             System.out.print("瞄瞄,我是小猫咪"+count+"\n");
    32.             // 让该线程休眠一秒
    33.             try{
    34.                 sleep(1000); // 1000ms
    35.             }
    36.             catch (InterruptedException e){
    37.                 e.printStackTrace();
    38.             }
    39.         }
    40.     }
    41. }

     JConsole------>

    先开始运行程序，然后在控制台中输入JConsole，连接当前进程，之后可在线程中查看相关情况。

    （2）实现Runnable接口

    案例2：请编写程序，该程序可以每隔1秒。在控制台输出“hi!”,当输出10次后，自动退出。请使用实现Runnable接口的方式实现。

    1. public class Thread02 {
    2.     public static void main(String[] args){
    3.         Dog dog = new Dog();
    4.         Thread thread = new Thread(dog); // Dog类实现了Runnable接口
    5.         thread.start();
    6.     }
    7. }
    8.  
    9. class Dog implements Runnable{
    10.     public void run(){
    11.         int count = 0;
    12.         while(count != 10){
    13.             count ++;
    14.             System.out.print("hi"+"\n");
    15.             try{
    16.                 Thread.sleep(1000); // 1000ms
    17.             }
    18.             catch (InterruptedException e){
    19.                 e.printStackTrace();
    20.             }
    21.         }
    22.     }
    23. }

    （3）继承Thread和实现Runnable接口的区别

    • 从java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本质上没有区别，从jdk帮助文档我们可以看到Thread类本身就实现了Runnable接口      start()->start0()
    • 实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制

    2、多线程执行

    案例3：请编写一个程序，创建两个线程，一个线程每隔1秒输出“hello,world!”，输出10次，退出，一个线程每隔1秒输出“hi!”，输出5次退出。

    1. public class Thread03 {
    2.     public static void main(String[] args){
    3.         T1 t1 = new T1();
    4.         T2 t2 = new T2();
    5.         Thread thread1 = new Thread(t1);
    6.         Thread thread2 = new Thread(t2);
    7.         thread1.start();
    8.         thread2.start();
    9.     }
    10. }
    11.  
    12. class T1 implements Runnable{
    13.     public void run(){
    14.         int count = 0;
    15.         while(count != 10){
    16.             count++;
    17.             System.out.println("Hello,world!"+count);
    18.             try{
    19.                 Thread.sleep(1000);
    20.             }
    21.             catch(InterruptedException e){
    22.                 e.printStackTrace();
    23.             }
    24.         }
    25.     }
    26. }
    27.  
    28. class T2 implements Runnable{
    29.     public void run(){
    30.         int count = 0;
    31.         while(count != 5){
    32.             count++;
    33.             System.out.println("hi!"+count);
    34.             try{
    35.                 Thread.sleep(1000);
    36.             }
    37.             catch(InterruptedException e){
    38.                 e.printStackTrace();
    39.             }
    40.         }
    41.     }
    42. }

    售票系统------>

    模拟编程三个售票系统同时售票共100张

    1. public class SellTicket {
    2.     public static void main(String[] args){
    3.         SellTicketUse use1 = new SellTicketUse();
    4.         SellTicketUse use2 = new SellTicketUse();
    5.         SellTicketUse use3 = new SellTicketUse();
    6.         use1.start();
    7.         use2.start();
    8.         use3.start();
    9.     }
    10. }
    11.  
    12. class SellTicketUse extends Thread{
    13.     private static int num = 100;
    14.     public void run(){
    15.         while(true){
    16.             if(num <= 0) {
    17.                 System.out.println("票已售完！");
    18.                 break;
    19.             }
    20.             try{
    21.                 sleep(50); // 模拟售票所需时间
    22.             }
    23.             catch (InterruptedException e){
    24.                 e.printStackTrace();
    25.             }
    26.             num--;
    27.             System.out.println("窗口"+currentThread().getName()+"售出一张票，剩余票数"+num+"张");
    28.         }
    29.     }
    30. }

     

    出现负票数，以上代码得到的结果引出了多线程执行在实际事件中引发的问题：多个线程同时运行会致使共享的数据出现被穿插操作的现象，即上一个线程的买票操作还没有执行时，下一个线程就开始判断共享数据的大小。 

    此问题稍后会有解决办法。

    3、线程常用方法

    （1）第一组 

    注意事项------>

    • start 底层会创建新的线程,调用run,run 就是一个简单的方法调用，不会启动新线程
    • 线程优先级的范围
    • interrupt，中断线程，但并没有真正的结束线程。所以一般用于中断正在休眠线程。
    • sleep：线程的静态方法，使当前线程休眠
    • 中断不是终止，InterruptedException是捕获到一个中断异常

    （2）第二组 

    yield：线程的礼让。让出cpu，让其他线程执行，但礼让的时间不确定,所以也不一定礼让成功（根据资源是否紧张决定，资源紧张时更容易成功）

    join：线程的插队。插队的线程一旦插队成功，则肯定先执行完插入的线程所有的任务

     

    案例：创建一个子线程，每隔1s输出hello，输出20次，主线程每隔1秒，输出hi，输出20次。要求：两个线程同时执行，当主线程输出5次后，就让子线程运行完毕，主线程再继续。

    1. public class ThreadMethod02 {
    2.     public static void main(String[] args){
    3.         TUse t2 = new TUse();
    4.         t2.start();
    5.  
    6.         for(int i = 1; i <= 20; i++) {
    7.             try {
    8.                 Thread.sleep(1000);
    9.             } catch (InterruptedException e) {
    10.                 e.printStackTrace();
    11.             }
    12.             System.out.println("主线程(小弟) 吃了 " + i  + " 包子");
    13.             if(i == 5) {
    14.                 System.out.println("主线程(小弟) 让 子线程(老大) 先吃");
    15.                 //join, 线程插队
    16.                 //t2.join();// 这里相当于让t2 线程先执行完毕
    17.                 Thread.yield();//礼让，不一定成功..
    18.                 System.out.println("线程(老大) 吃完了 主线程(小弟) 接着吃..");
    19.             }
    20.  
    21.         }
    22.     }
    23. }
    24.  
    25. class TUse extends Thread {
    26.     public void run() {
    27.         for (int i = 1; i <= 20; i++) {
    28.             try {
    29.                 Thread.sleep(1000);//休眠1秒
    30.             } catch (InterruptedException e) {
    31.                 e.printStackTrace();
    32.             }
    33.             System.out.println("子线程(老大) 吃了 " + i +  " 包子");
    34.         }
    35.     }
    36. }
    37.

    （3）用户线程和守护线程

    用户线程：也叫工作线程，当线程的任务执行完或通知方式结束

    守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束，常见的守护线程，垃圾回收机制

    如何将一个线程设置成守护线程------>

    1. public class ThreadMethod03 {
    2.     public static void main(String[] args){
    3.         MyDaemonThread myDaemonThread = new MyDaemonThread();
    4.         //如果我们希望当main线程结束后，子线程自动结束,
    5.         //只需将子线程设为守护线程即可
    6.         myDaemonThread.setDaemon(true); // 设置方法
    7.         myDaemonThread.start();
    8.  
    9.         for( int i = 1; i <= 10; i++) {//main线程
    10.             System.out.println("嘿嘿嘿");
    11.             try {
    12.                 Thread.sleep(1000);
    13.             } catch (InterruptedException e) {
    14.                 e.printStackTrace();
    15.             }
    16.         }
    17.     }
    18. }
    19.  
    20. class MyDaemonThread extends Thread {
    21.     public void run() {
    22.         while (true){//无限循环
    23.             try {
    24.                 Thread.sleep(1000);//休眠1000毫秒
    25.             } catch (InterruptedException e) {
    26.                 e.printStackTrace();
    27.             }
    28.             System.out.println("哈哈哈");
    29.         }
    30.     }
    31. }
    32.

    三、线程终止

    • 当线程完成任务后，会自动退出。
    • 还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式。
       

    需求：启动一个线程t，要求在main线程中去停止线程t，请编程实现。（通知方式）

    1. public class ThreadExit {
    2.     public static void main(String[] args){
    3.         T t = new T();
    4.         t.start();
    5.         // 50s后终止该线程
    6.         try {
    7.             Thread.sleep(2000);
    8.         }
    9.         catch (InterruptedException e){
    10.             e.printStackTrace();
    11.         }
    12.         t.change(false);
    13.     }
    14. }
    15.  
    16. class T extends Thread{
    17.     private boolean flag = true;
    18.     private int count = 0;
    19.     public void run(){
    20.         while(flag){
    21.             count ++;
    22.             System.out.print("hi"+count+"\n");
    23.             try{
    24.                 Thread.sleep(1000); // 1000ms
    25.             }
    26.             catch (InterruptedException e){
    27.                 e.printStackTrace();
    28.             }
    29.             if(count == 10){
    30.                 break;
    31.             }
    32.         }
    33.     }
    34.     public void change(boolean flag){
    35.         this.flag = flag;
    36.     }
    37. }

    四、线程的生命周期

    官方文档说法------>6个状态

    关于一些教科书上7个状态的说法------>Runnable可运行状态分成了准备状态和正在运行的状态 

     

     可用代码观察到其中一些状态------>

    1. public class ThreadMethodExercise {
    2.     public static void main(String[] args) throws InterruptedException {
    3.         Thread t3 = new Thread(new T3());//创建子线程
    4.         for (int i = 1; i <= 10; i++) {
    5.             System.out.println("hi " + i);
    6.             if(i == 5) {//说明主线程输出了5次 hi
    7.                 t3.start();//启动子线程 输出 hello...
    8.                 t3.join();//立即将t3子线程，插入到main线程，让t3先执行
    9.             }
    10.             Thread.sleep(1000);//输出一次 hi, 让main线程也休眠1s
    11.         }
    12.     }
    13. }
    14.  
    15. class T3 implements Runnable {
    16.     private int count = 0;
    17.     public void run() {
    18.         while (true) {
    19.             System.out.println("hello " + (++count));
    20.             try {
    21.                 Thread.sleep(1000);
    22.             } catch (InterruptedException e) {
    23.                 e.printStackTrace();
    24.             }
    25.             if (count == 10) {
    26.                 break;
    27.             }
    28.         }
    29.     }
    30. }

    五、线程同步机制

    1、同步概念

    在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何同一时刻，最多有一个线程访问，以保证数据的完整性。

    也可以这样理解：线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作。

    2、同步实现synchronized

    （1）同步代码块

    1. synchronized(对象){ // 得到对象的锁，才能操作同步代码
    2.  // 需要被同步的代码;
    3. }

    （2）方法声明

    synchronized还可以放在方法声明中，表示整个方法为同步方法

    1. public synchronized void m (String name){
    2.  //需要被同步的代码
    3. }

    售票系统修正

    1. public class SellTicket {
    2.     public static void main(String[] args) {
    3.         SellTicket03 sellTicket03 = new SellTicket03();
    4.         new Thread(sellTicket03).start();//第1个线程-窗口
    5.         new Thread(sellTicket03).start();//第2个线程-窗口
    6.         new Thread(sellTicket03).start();//第3个线程-窗口
    7.  
    8.     }
    9. }
    10.  
    11.  
    12. //实现接口方式, 使用synchronized实现线程同步
    13. class SellTicket03 implements Runnable {
    14.     private int ticketNum = 100;//让多个线程共享 ticketNum
    15.     private boolean loop = true;//控制run方法变量
    16.     Object object = new Object();
    17.     //同步方法（静态的）的锁为当前类本身
    18.     //1. public synchronized static void m1() {} 锁是加在 SellTicket03.class
    19.     //2. 如果在静态方法中，实现一个同步代码块.
    20.     /*
    21.         synchronized (SellTicket03.class) {
    22.             System.out.println("m2");
    23.         }
    24.      */
    25.     public synchronized static void m1() {
    26.  
    27.     }
    28.     public static  void m2() {
    29.         synchronized (SellTicket03.class) {
    30.             System.out.println("m2");
    31.         }
    32.     }
    33.     //1. public synchronized void sell() {} 就是一个同步方法
    34.     //2. 此时锁在this对象
    35.     //3. 也可以在代码块上写 synchronize ,同步代码块, 互斥锁还是在this对象
    36.     public /*synchronized*/ void sell() { //同步方法, 在同一时刻， 只能有一个线程来执行sell方法
    37.  
    38.         synchronized (/*this*/ object) {
    39.             if (ticketNum <= 0) {
    40.                 System.out.println("售票结束...");
    41.                 loop = false;
    42.                 return;
    43.             }
    44.  
    45.             //休眠50毫秒, 模拟
    46.             try {
    47.                 Thread.sleep(50);
    48.             } catch (InterruptedException e) {
    49.                 e.printStackTrace();
    50.             }
    51.  
    52.             System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
    53.                     + " 剩余票数=" + (--ticketNum));//1 - 0 - -1  - -2
    54.         }
    55.     }
    56.  
    57.     @Override
    58.     public void run() {
    59.         while (loop) {
    60.  
    61.             sell();//sell方法是一共同步方法
    62.         }
    63.     }
    64. }
    65.  
    66. //使用Thread方式
    67. // new SellTicket01().start()
    68. // new SellTicket01().start();
    69. class SellTicket01 extends Thread {
    70.  
    71.     private static int ticketNum = 100;//让多个线程共享 ticketNum
    72.  
    73. //    public void m1() {
    74. //        synchronized (this) {
    75. //            System.out.println("hello");
    76. //        }
    77. //    }
    78.  
    79.     public void run() {
    80.  
    81.  
    82.         while (true) {
    83.  
    84.             if (ticketNum <= 0) {
    85.                 System.out.println("售票结束...");
    86.                 break;
    87.             }
    88.  
    89.             //休眠50毫秒, 模拟
    90.             try {
    91.                 Thread.sleep(50);
    92.             } catch (InterruptedException e) {
    93.                 e.printStackTrace();
    94.             }
    95.  
    96.             System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
    97.                     + " 剩余票数=" + (--ticketNum));
    98.  
    99.         }
    100.     }
    101. }
    102.  
    103.  
    104. //实现接口方式
    105. class SellTicket02 implements Runnable {
    106.     private int ticketNum = 100;//让多个线程共享 ticketNum
    107.  
    108.     public void run() {
    109.         while (true) {
    110.  
    111.             if (ticketNum <= 0) {
    112.                 System.out.println("售票结束...");
    113.                 break;
    114.             }
    115.  
    116.             //休眠50毫秒, 模拟
    117.             try {
    118.                 Thread.sleep(50);
    119.             } catch (InterruptedException e) {
    120.                 e.printStackTrace();
    121.             }
    122.  
    123.             System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
    124.                     + " 剩余票数=" + (--ticketNum));//1 - 0 - -1  - -2
    125.  
    126.         }
    127.     }
    128. }

    3、互斥锁

    • Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。
    • 每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。
    • 关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问。
    • 同步的局限性：导致程序的执行效率要降低。
    • 同步方法（非静态的）的锁可以是this（当前对象），也可以是其他对象（要求是同一个对象）
    • 同步方法（静态的）的锁为当前类本身。（静态方法无对象）
       

    实现步骤：

    • 需要先分析上锁的代码
    • 选择同步代码块或同步方法
    • 要求多个线程的锁对象为同一个（好好理解一下），如果是不同的对象，那么意味着它们的锁也是不同的锁，那么它们根本没有争夺锁进入运行状态这一说法了（锁了个寂寞对吧）

     4、线程死锁

     多个线程都占用了对方的锁资源，但不肯相让，导致了死锁，在编程是一定要避免死锁的发生。

    模拟线程死锁------>

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

     5、释放锁

    （1）以下操作会释放锁

    • 当前线程的同步方法、同步代码块执行结束。          案例：上厕所，完事出来
    • 当前线程在同步代码块、同步方法中遇到break、return。           案例：没有正常的完事，经理叫他修改bug，不得已出来
    • 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束                    案例：没有正常的完事，发现忘带纸,不得已出来
    • 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。           案例：没有正常完事,觉得需要酝酿下，所以出来等会再进去
       

    （2）以下操作不会释放锁

    • 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁。            案例：上厕所，太困了，在坑位上眯了一会
    • 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁。

    提示：应尽量避免使用suspend()和resume()来控制线程，方法不再推荐使用

    --------------------------------------------------------线程结束-------------------------------------------------------------

  • 相关阅读:
    主打国产算力 广州市通用人工智能公共算力中心项目签约
    pdf压缩文件怎么压缩最小？
    Mysql优化器-mysql详解（六）
    DataLoader
    java 多线程乐观锁与悲观锁
    [附源码]计算机毕业设计JAVA大学生评奖评优系统
    Angular项目简单使用拦截器 httpClient 请求响应处理
    gcc 新旧版本ldd的显示动态库的不同
    「学习笔记」tarjan 求最近公共祖先
    postman出现Required request part ‘file‘ is not present
  • 原文地址：https://blog.csdn.net/qq_61768389/article/details/128092986