• 48、线程

     一、线程相关概念：

    1、程序（program）：

    是为完成特定任务、用某种语言编写的一组指令的集合，即我们写的代码。

    2、进程：
    （1）进程是指运行中的程序，比如我们使用QQ，就启动了一个进程，操作系统就会为该进程分配内存空间。当我们使用迅雷，又启动了一个进程，操作系统将为迅雷分配新的内存空间。
    （2）进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程：有它自身的产生、存在和消亡的过程.

    3、什么是线程：

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

    （2）一个进程可以拥有多个线程

    4、单线程：

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

    5、多线程：

    同一个时刻，可以执行多个线程，比如：一个qq进程，可以同时打开多个聊天窗口，一个迅雷进程，可以同时下载多个文件。

    6、并发：

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

    7、并行：（有同伴一起走）

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

    ·查看电脑CPU的方式：

    方式一：右击屏幕底下的长条形任务栏，打开“任务管理器”，“打开资源管理器” 

    方式二：右击“我的电脑”，选择“管理”，“设备管理器”，“处理器”

    方式三：用java代码查看

    1. package event_;
    2.  
    3. public class CpuNum {
    4.     public static void main(String[] args) {
    5.         Runtime runtime = Runtime.getRuntime();
    6.         //获取当前电脑的cpu数量/核心数
    7.         int cpuNums = runtime.availableProcessors();
    8.         System.out.println("当前有cpu个数：" + cpuNums);
    9.     }
    10. }
    11. //当前有cpu个数：8

    我的是4核8线程

    二、线程基本使用
    1、创建线程的两种方式
    （1）继承Thread类，重写run方法

    1. package threaduse;
    2.  
    3. public class Thread01 {
    4.     public static void main(String[] args) throws Exception{
    5.         //创建Cat对象，可以当做线程使用
    6.         Cat cat=new Cat();
    7.         cat.start();//启动线程
    8.  
    9.         //当main线程启动一个子线程Thread-0，主线程不会阻塞，会继续执行
    10.         //这时，主线程和子线程是交替执行
    11.         System.out.println("主线程继续执行"+Thread.currentThread().getName());
    12.         for(int i=0;i<10;i++){
    13.             System.out.println("主线程 i="+i);
    14.             //让主线程休眠
    15.             Thread.sleep(1000);
    16.         }
    17.     }
    18. }
    19.  
    20. //1、当一个类继承了Thread，该类就可以当做线程使用
    21. //2、要重写run方法，写上自己的业务逻辑
    22. //3、run方法是Thread类实现了Runnable接口用的
    23. /*  @Override
    24.     public void run() {
    25.         Runnable task = holder.task;
    26.         if (task != null) {
    27.             task.run();
    28.         }
    29.     }
    30.  */
    31. class Cat extends Thread{
    32.     int times=0;
    33.     public void run() {
    34.         //如果不加循环，代码执行一次就退出了
    35.         while(true){
    36.             //该线程每隔1秒，在控制台输出"喵喵，我是小猫咪"
    37.             System.out.println("喵喵，我是小猫咪"+(++times)+" 线程名："+Thread.currentThread().getName());
    38.             //让线程休眠1秒
    39.             try {
    40.                 Thread.sleep(1000);
    41.             } catch (InterruptedException e) {
    42.                 throw new RuntimeException(e);
    43.             }
    44.             if(times==10){
    45.                 break;
    46.             }
    47.         }
    48.     }
    49. }
    50. //主线程继续执行main
    51. //主线程 i=0
    52. //喵喵，我是小猫咪1 线程名：Thread-0
    53. //喵喵，我是小猫咪2 线程名：Thread-0
    54. //主线程 i=1
    55. //喵喵，我是小猫咪3 线程名：Thread-0
    56. //主线程 i=2
    57. //喵喵，我是小猫咪4 线程名：Thread-0
    58. //主线程 i=3
    59. //喵喵，我是小猫咪5 线程名：Thread-0
    60. //主线程 i=4
    61. //喵喵，我是小猫咪6 线程名：Thread-0
    62. //主线程 i=5
    63. //主线程 i=6
    64. //喵喵，我是小猫咪7 线程名：Thread-0
    65. //主线程 i=7
    66. //喵喵，我是小猫咪8 线程名：Thread-0
    67. //主线程 i=8
    68. //喵喵，我是小猫咪9 线程名：Thread-0
    69. //主线程 i=9
    70. //喵喵，我是小猫咪10 线程名：Thread-0
    1. 深入解析cat.start();方法        
    2.         //源码：
    3.         /*1、
    4.             void start(ThreadContainer container) {
    5.                 synchronized (this) {
    6.                     start0();
    7.                 }
    8.             }
    9.           2、
    10.           //start0()是酵方法，是JVM调用，底层是c/c++实现
    11.           //真正实现多线程的效果，是start0()，而不是run()
    12.               private native void start0();
    13.          */
    14.         cat.start();//启动线程--->最终会执行cat的run方法
    15.  
    16.         cat.run();//如果直接调用run()方法，这里的run()方法就是一个普通的方法，没有真正地启动一个线程
    17.         //等执行完这个run()方法后，才继续往下走，此时已经不再是多线程了
    18.         //在main里调用run()方法，输出的就是main的线程名，不是要启动的线程名
    19.         //输出：喵喵，我是小猫咪1 线程名：main

     补：主线程决定进程开启，最后结束的线程决定进程结束

     （2）实现Runinable接口，重写run方法 

     

    1. package threaduse;
    2.  
    3. public class Thread02 {
    4.     public static void main(String[] args) {
    5.         Dog dog=new Dog();
    6.         //dog.start();报错，这里不能调用start
    7.         //创建了Thread对象，把dog对象（实现Runnable），放入Thread
    8.         Thread thread = new Thread(dog);
    9.         thread.start();
    10.  
    11.         Tiger tiger = new Tiger();
    12.         ThreadProxy threadProxy = new ThreadProxy(tiger);
    13.         threadProxy.start();
    14.     }
    15. }
    16. class Animal{}
    17. class Tiger extends Animal implements Runnable{
    18.  
    19.     @Override
    20.     public void run() {
    21.         System.out.println("老虎嗷嗷叫...");
    22.     }
    23. }
    24.  
    25. //线程代理类，模拟了一个极简的Thread类
    26. class ThreadProxy implements Runnable{//
    27.     private Runnable target=null;//类型是Runnable
    28.     @Override
    29.     public void run() {
    30.         if (target != null) {
    31.             target.run();//动态绑定，运行类型是传进来的参数的类型
    32.         }
    33.     }
    34.  
    35.     public ThreadProxy(Runnable target) {
    36.         this.target = target;
    37.     }
    38.     public void start(){
    39.         start0();//这个方法才是真正实现多线程的方法
    40.     }
    41.     public void start0(){
    42.         run();
    43.     }
    44. }
    45. class Dog implements Runnable{
    46.     int count=0;
    47.     @Override
    48.     public void run() {
    49.         while(true){
    50.             System.out.println("小狗汪汪叫...hi"+(++count)+Thread.currentThread().getName());
    51.             try {
    52.                 Thread.sleep(1000);//休眠一秒
    53.             } catch (InterruptedException e) {
    54.                 e.printStackTrace();
    55.             }
    56.             if (count == 10) {
    57.                 break;
    58.             }
    59.         }
    60.     }
    61. }

    线程这样设计的意义，最根本的意义就在于解耦，权责分明：把创建线程交给Thread类，创建线程任务交给实现了Runnable接口的任意类

    这样做的好处：

    （1）解除类的单继承限制，更好地实现多线程；

    （2）解耦之前，线程任务改动需要修改run()方法，解耦后，只需要修改外部类，实现非侵入式的修改，提高代码的可扩展性，这是接口的主要好处

    （3）线程任务执行完后，不需要再次创建、销毁线程，只需要实现Runnable接口提交新的的线程任务即可，提高性能节省开销，后面的线程池设计主要体现这一点

    2、应用线程

    1. package threaduse;
    2.  
    3. import javax.swing.plaf.TableHeaderUI;
    4. @SuppressWarnings({"all"})
    5. public class Thread03 {
    6.     public static void main(String[] args) {
    7.         T1 t1 = new T1();
    8.         T2 t2 = new T2();
    9.         Thread thread1=new Thread(t1);
    10.         Thread thread2= new Thread(t2);
    11.         thread1.start();
    12.         thread2.start();
    13.     }
    14. }
    15. class T1 implements Runnable{
    16.     int count=0;
    17.     @Override
    18.     public void run() {
    19.         while (true) {
    20.             System.out.println("hello, world! "+(++count)+Thread.currentThread().getName());
    21.  
    22.             try {
    23.                 Thread.sleep(1000);
    24.             } catch (InterruptedException e) {
    25.                 e.printStackTrace();
    26.             }
    27.             if (count == 10) {
    28.                 break;
    29.             }
    30.         }
    31.     }
    32. }
    33. class T2 implements Runnable{
    34.     int count=0;
    35.     @Override
    36.     public void run() {
    37.         while (true) {
    38.             System.out.println("hi "+(++count)+Thread.currentThread().getName());
    39.             try {
    40.                 Thread.sleep(1000);
    41.             } catch (InterruptedException e) {
    42.                 e.printStackTrace();
    43.             }
    44.             if (count == 5) {
    45.                 break;
    46.             }
    47.         }
    48.     }
    49. }
    50. //hello, world! 1Thread-0
    51. //hi 1Thread-1
    52. //hello, world! 2Thread-0
    53. //hi 2Thread-1
    54. //hi 3Thread-1
    55. //hello, world! 3Thread-0
    56. //hello, world! 4Thread-0
    57. //hi 4Thread-1
    58. //hello, world! 5Thread-0
    59. //hi 5Thread-1
    60. //hello, world! 6Thread-0
    61. //hello, world! 7Thread-0
    62. //hello, world! 8Thread-0
    63. //hello, world! 9Thread-0
    64. //hello, world! 10Thread-0

    3、继承Thread和实现Runnable的区别：

    （1）从java的设计来看，通过继承Thread或实现Runnable接口来创建线程本质上没有区别，从jdk帮助文档我们可以看到Thread类本身就实现了Runnable接口，都是通过调用start()----->最终实现调用start0();

    （2）实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制，建议使用

    1.         T3 t3 = new T3("Hello");//一个对象
    2.         Thread thread01=new Thread(t3);
    3.         Thread thread02=new Thread(t3);
    4.         thread01.start();
    5.         thread02.start();
    6.         System.out.println("主线程完毕");

     4、

    1. //使用Thread
    2. package ticket;
    3.  
    4. public class SellTicket {
    5.     public static void main(String[] args) {
    6.         SellTicket01 sellTicket1 = new SellTicket01();
    7.         SellTicket01 sellTicket2 = new SellTicket01();
    8.         SellTicket01 sellTicket3 = new SellTicket01();
    9.  
    10.         //三个售票窗口
    11.         sellTicket1.start();
    12.         sellTicket2.start();
    13.         sellTicket3.start();
    14.     }
    15. }
    16. class SellTicket01 extends Thread{
    17.     private static int ticketNum=10;//让多个线程共享ticketNum
    18.     public void run(){
    19.         while(true){
    20.             if (ticketNum <= 0) {
    21.                 System.out.println("售票结束");
    22.                 break;
    23.             }
    24.             try {
    25.                 Thread.sleep(50);
    26.             } catch (Exception e) {
    27.                 e.printStackTrace();
    28.             }
    29.             System.out.println("窗口 "+Thread.currentThread().getName()+" 售出一张票"
    30.             +" 剩余票数="+(--ticketNum));
    31.         }
    32.     }
    33. }
    34. //窗口 Thread-1 售出一张票 剩余票数=9
    35. //窗口 Thread-0 售出一张票 剩余票数=7
    36. //窗口 Thread-2 售出一张票 剩余票数=8
    37. //窗口 Thread-2 售出一张票 剩余票数=6
    38. //窗口 Thread-0 售出一张票 剩余票数=4
    39. //窗口 Thread-1 售出一张票 剩余票数=5
    40. //窗口 Thread-2 售出一张票 剩余票数=3
    41. //窗口 Thread-1 售出一张票 剩余票数=2
    42. //窗口 Thread-0 售出一张票 剩余票数=1
    43. //窗口 Thread-1 售出一张票 剩余票数=0
    44. //窗口 Thread-2 售出一张票 剩余票数=0
    45. //售票结束
    46. //窗口 Thread-0 售出一张票 剩余票数=-1
    47. //售票结束
    48. //售票结束
    49.  
    50. //出现了超卖现象，因为最后的时候，三个线程同时进入到while循环，相差时间太短
    1. //使用Runnable
    2. package ticket;
    3.  
    4. public class SellTicket {
    5.     public static void main(String[] args) {
    6.         SellTicket02 sellTicket = new SellTicket02();
    7.         //三个售票窗口
    8.         new Thread(sellTicket).start();
    9.         new Thread(sellTicket).start();
    10.         new Thread(sellTicket).start();
    11.     }
    12. }
    13. //使用Thread
    14. class SellTicket02 implements Runnable{
    15.     private static int ticketNum=10;//让多个线程共享ticketNum
    16.     public void run(){
    17.         while(true){
    18.             if (ticketNum <= 0) {
    19.                 System.out.println("售票结束");
    20.                 break;
    21.             }
    22.             try {
    23.                 Thread.sleep(5000);
    24.             } catch (Exception e) {
    25.                 e.printStackTrace();
    26.             }
    27.             System.out.println("窗口 "+Thread.currentThread().getName()+" 售出一张票"
    28.             +" 剩余票数="+(--ticketNum));
    29.         }
    30.     }
    31. }
    32. //窗口 Thread-1 售出一张票 剩余票数=9
    33. //窗口 Thread-0 售出一张票 剩余票数=8
    34. //窗口 Thread-2 售出一张票 剩余票数=8
    35. //窗口 Thread-2 售出一张票 剩余票数=7
    36. //窗口 Thread-1 售出一张票 剩余票数=7
    37. //窗口 Thread-0 售出一张票 剩余票数=6
    38. //窗口 Thread-0 售出一张票 剩余票数=4
    39. //窗口 Thread-1 售出一张票 剩余票数=5
    40. //窗口 Thread-2 售出一张票 剩余票数=3
    41. //窗口 Thread-1 售出一张票 剩余票数=2
    42. //窗口 Thread-2 售出一张票 剩余票数=2
    43. //窗口 Thread-0 售出一张票 剩余票数=1
    44. //窗口 Thread-2 售出一张票 剩余票数=0
    45. //售票结束
    46. //窗口 Thread-1 售出一张票 剩余票数=-1
    47. //售票结束
    48. //窗口 Thread-0 售出一张票 剩余票数=0
    49. //售票结束
    50.  
    51. //出现了超卖现象，因为最后的时候，三个线程同时进入到while循环，相差时间太短

    出现了问题：票数超卖，多个线程同时进入循环，都检测到了最后的一个资源，所以都卖了出去，出现了超卖现象。

    5、线程终止：

    （1）基本说明：

    1）当线程完成任务后，会自动退出

    2）还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式

    （2）应用案例：

     6、线程常用方法：

     

    补：中断可以类比闹钟来理解

    1. //解释join:线程插队
    2. package threaduse;
    3.  
    4. public class ThreadMethod02 {
    5.     public static void main(String[] args) throws InterruptedException {
    6.         T3 t3 = new T3();
    7.         t3.start();
    8.         
    9.         for(int i=1;i<=20;i++){
    10.             Thread.sleep(1000);
    11.             System.out.println("主线程（小弟）吃了 "+i+" 包子");
    12.             if(i==5){
    13.                 System.out.println("主线程（小弟）让了子线程（老大）先吃");
    14.                 t3.join();//这里相当于让t2线程先执行完毕
    15.                 System.out.println("子线程（老大）吃完了，主线程（小弟）接着吃...");
    16.             }
    17.         }
    18.     }
    19. }
    20. class T3 extends Thread{
    21.     public void run(){
    22.         for(int i=1;i<=20;i++){
    23.             try {
    24.                 Thread.sleep(1000);
    25.             } catch (InterruptedException e) {
    26.                 e.printStackTrace();
    27.             }
    28.             System.out.println("子线程（老大）吃了 " +i+" 包子");
    29.         }
    30.     }
    31. }
    32. //主线程（小弟）吃了 1 包子
    33. //子线程（老大）吃了 1 包子
    34. //主线程（小弟）吃了 2 包子
    35. //子线程（老大）吃了 2 包子
    36. //子线程（老大）吃了 3 包子
    37. //主线程（小弟）吃了 3 包子
    38. //子线程（老大）吃了 4 包子
    39. //主线程（小弟）吃了 4 包子
    40. //子线程（老大）吃了 5 包子
    41. //主线程（小弟）吃了 5 包子
    42. //主线程（小弟）让了子线程（老大）先吃
    43. //子线程（老大）吃了 6 包子
    44. //子线程（老大）吃了 7 包子
    45. //子线程（老大）吃了 8 包子
    46. //子线程（老大）吃了 9 包子
    47. //子线程（老大）吃了 10 包子
    48. //子线程（老大）吃了 11 包子
    49. //子线程（老大）吃了 12 包子
    50. //子线程（老大）吃了 13 包子
    51. //子线程（老大）吃了 14 包子
    52. //子线程（老大）吃了 15 包子
    53. //子线程（老大）吃了 16 包子
    54. //子线程（老大）吃了 17 包子
    55. //子线程（老大）吃了 18 包子
    56. //子线程（老大）吃了 19 包子
    57. //子线程（老大）吃了 20 包子
    58. //子线程（老大）吃完了，主线程（小弟）接着吃...
    59. //主线程（小弟）吃了 6 包子
    60. //主线程（小弟）吃了 7 包子
    61. //主线程（小弟）吃了 8 包子
    62. //主线程（小弟）吃了 9 包子
    63. //主线程（小弟）吃了 10 包子
    64. //主线程（小弟）吃了 11 包子
    65. //主线程（小弟）吃了 12 包子
    66. //主线程（小弟）吃了 13 包子
    67. //主线程（小弟）吃了 14 包子
    68. //主线程（小弟）吃了 15 包子
    69. //主线程（小弟）吃了 16 包子
    70. //主线程（小弟）吃了 17 包子
    71. //主线程（小弟）吃了 18 包子
    72. //主线程（小弟）吃了 19 包子
    73. //主线程（小弟）吃了 20 包子
    1. //解释yeild：礼让，不一定成功
    2. package threaduse;
    3.  
    4. public class ThreadMethod02 {
    5.     public static void main(String[] args) throws InterruptedException {
    6.         T3 t3 = new T3();
    7.         t3.start();
    8.  
    9.         for(int i=1;i<=20;i++){
    10.             Thread.sleep(1000);
    11.             System.out.println("主线程（小弟）吃了 "+i+" 包子");
    12.             if(i==5){
    13.                 System.out.println("主线程（小弟）让了子线程（老大）先吃");
    14.                 Thread.yield();//礼让，不一定成功...
    15.                 System.out.println("子线程（老大）吃完了，主线程（小弟）接着吃...");
    16.             }
    17.         }
    18.     }
    19. }
    20. class T3 extends Thread{
    21.     public void run(){
    22.         for(int i=1;i<=20;i++){
    23.             try {
    24.                 Thread.sleep(1000);
    25.             } catch (InterruptedException e) {
    26.                 e.printStackTrace();
    27.             }
    28.             System.out.println("子线程（老大）吃了 " +i+" 包子");
    29.         }
    30.     }
    31. }
    32. //主线程（小弟）吃了 1 包子
    33. //子线程（老大）吃了 1 包子
    34. //子线程（老大）吃了 2 包子
    35. //主线程（小弟）吃了 2 包子
    36. //子线程（老大）吃了 3 包子
    37. //主线程（小弟）吃了 3 包子
    38. //子线程（老大）吃了 4 包子
    39. //主线程（小弟）吃了 4 包子
    40. //主线程（小弟）吃了 5 包子
    41. //主线程（小弟）让了子线程（老大）先吃
    42. //子线程（老大）吃了 5 包子
    43. //子线程（老大）吃完了，主线程（小弟）接着吃...
    44. //主线程（小弟）吃了 6 包子
    45. //子线程（老大）吃了 6 包子
    46. //子线程（老大）吃了 7 包子
    47. //主线程（小弟）吃了 7 包子
    48. //主线程（小弟）吃了 8 包子
    49. //子线程（老大）吃了 8 包子
    50. //子线程（老大）吃了 9 包子
    51. //主线程（小弟）吃了 9 包子
    52. //主线程（小弟）吃了 10 包子
    53. //子线程（老大）吃了 10 包子
    54. //主线程（小弟）吃了 11 包子
    55. //子线程（老大）吃了 11 包子
    56. //主线程（小弟）吃了 12 包子
    57. //子线程（老大）吃了 12 包子
    58. //主线程（小弟）吃了 13 包子
    59. //子线程（老大）吃了 13 包子
    60. //主线程（小弟）吃了 14 包子
    61. //子线程（老大）吃了 14 包子
    62. //主线程（小弟）吃了 15 包子
    63. //子线程（老大）吃了 15 包子
    64. //主线程（小弟）吃了 16 包子
    65. //子线程（老大）吃了 16 包子
    66. //主线程（小弟）吃了 17 包子
    67. //子线程（老大）吃了 17 包子
    68. //主线程（小弟）吃了 18 包子
    69. //子线程（老大）吃了 18 包子
    70. //主线程（小弟）吃了 19 包子
    71. //子线程（老大）吃了 19 包子
    72. //主线程（小弟）吃了 20 包子
    73. //子线程（老大）吃了 20 包子

    7、练习题：

     //我的代码

    1. package threaduse;
    2.  
    3. public class ThreadMethodExercise {
    4.     public static void main(String[] args) throws InterruptedException {
    5.         T4 t4 = new T4();
    6.         Thread thread = new Thread(t4);
    7.         for(int i=1;i<=10;i++){
    8.             System.out.println("hi "+i);
    9.             if (i == 5) {
    10.                 thread.start();
    11.                 thread.join();
    12.             }
    13.             Thread.sleep(1000);
    14.         }
    15.         System.out.println("主线程结束...");
    16.     }
    17. }
    18. class T4 implements Runnable{
    19.     public void run(){
    20.             for(int i=1;i<=10;i++){
    21.                 System.out.println("hello"+i);
    22.                 try {
    23.                     Thread.sleep(1000);
    24.                 } catch (InterruptedException e) {
    25.                     e.printStackTrace();
    26.                 }
    27.             }
    28.             System.out.println("子线程结束...");
    29.     }
    30. }
    31. //hi 1
    32. //hi 2
    33. //hi 3
    34. //hi 4
    35. //hi 5
    36. //hello1
    37. //hello2
    38. //hello3
    39. //hello4
    40. //hello5
    41. //hello6
    42. //hello7
    43. //hello8
    44. //hello9
    45. //hello10
    46. //子线程结束...
    47. //hi 6
    48. //hi 7
    49. //hi 8
    50. //hi 9
    51. //hi 10
    52. //主线程结束...

    8、用户线程和守护线程：

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

    （2）守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束

    （3）常见的守护线程：垃圾回收机制

    1. package threaduse;
    2.  
    3. public class ThreadMethod03 {
    4.     public static void main(String[] args) throws InterruptedException {
    5.         MyDaemonThread myDaemonThread = new MyDaemonThread();
    6.         //如果我们希望当main线程结束后，子线程自动结束
    7.         //只需将子线程设置守线程即可
    8.         myDaemonThread.setDaemon(true);
    9.         myDaemonThread.start();
    10.         for(int i=1;i<=10;i++){
    11.             System.out.println("宝强在辛苦地工作...");
    12.             Thread.sleep(1000);
    13.         }
    14.     }
    15. }
    16. class MyDaemonThread extends Thread{
    17.     public void run(){
    18.         for(;;){//无限循环
    19.             try {
    20.                 Thread.sleep(1000);
    21.             } catch (InterruptedException e) {
    22.                 e.printStackTrace();
    23.             }
    24.             System.out.println("马蓉和宋喆居心叵测聊天，哈哈哈~~~");
    25.         }
    26.     }
    27. }
    28. //宝强在辛苦地工作...
    29. //马蓉和宋喆居心叵测聊天，哈哈哈~~~
    30. //宝强在辛苦地工作...
    31. //宝强在辛苦地工作...
    32. //马蓉和宋喆居心叵测聊天，哈哈哈~~~
    33. //马蓉和宋喆居心叵测聊天，哈哈哈~~~
    34. //宝强在辛苦地工作...
    35. //宝强在辛苦地工作...
    36. //马蓉和宋喆居心叵测聊天，哈哈哈~~~
    37. //马蓉和宋喆居心叵测聊天，哈哈哈~~~
    38. //宝强在辛苦地工作...
    39. //马蓉和宋喆居心叵测聊天，哈哈哈~~~
    40. //宝强在辛苦地工作...
    41. //宝强在辛苦地工作...
    42. //马蓉和宋喆居心叵测聊天，哈哈哈~~~
    43. //马蓉和宋喆居心叵测聊天，哈哈哈~~~
    44. //宝强在辛苦地工作...
    45. //马蓉和宋喆居心叵测聊天，哈哈哈~~~
    46. //宝强在辛苦地工作...
    47. //马蓉和宋喆居心叵测聊天，哈哈哈~~~

    9、线程的生命周期

     

     ·如上为官方的文档，所以线程一共有6种状态

    1. package threaduse;
    2.  
    3. public class ThreadState {
    4.     public static void main(String[] args) throws InterruptedException {
    5.         T5 t5 = new T5();
    6.         System.out.println(t5.getName()+" 状态"+ t5.getState());
    7.         t5.start();
    8.         while (Thread.State.TERMINATED != t5.getState()) {
    9.             System.out.println(t5.getName()+" 状态"+ t5.getState());
    10.             Thread.sleep(500);
    11.         }
    12.         System.out.println(t5.getName()+" 状态"+ t5.getState());
    13.     }
    14. }
    15. class T5 extends Thread{
    16.     public void run(){
    17.         while (true) {
    18.             for(int i=0;i<10;i++){
    19.                 System.out.println("hi "+i);
    20.                 try {
    21.                     Thread.sleep(1000);
    22.                 } catch (InterruptedException e) {
    23.                     e.printStackTrace();
    24.                 }
    25.             }
    26.             break;
    27.         }
    28.  
    29.     }
    30. }
    31. //Thread-0 状态NEW
    32. //Thread-0 状态RUNNABLE
    33. //hi 0
    34. //Thread-0 状态TIMED_WAITING
    35. //hi 1
    36. //Thread-0 状态TIMED_WAITING
    37. //Thread-0 状态TIMED_WAITING
    38. //hi 2
    39. //Thread-0 状态TIMED_WAITING
    40. //Thread-0 状态TIMED_WAITING
    41. //hi 3
    42. //Thread-0 状态TIMED_WAITING
    43. //Thread-0 状态TIMED_WAITING
    44. //hi 4
    45. //Thread-0 状态TIMED_WAITING
    46. //Thread-0 状态TIMED_WAITING
    47. //hi 5
    48. //Thread-0 状态TIMED_WAITING
    49. //Thread-0 状态TIMED_WAITING
    50. //hi 6
    51. //Thread-0 状态TIMED_WAITING
    52. //Thread-0 状态TIMED_WAITING
    53. //hi 7
    54. //Thread-0 状态TIMED_WAITING
    55. //Thread-0 状态TIMED_WAITING
    56. //hi 8
    57. //Thread-0 状态TIMED_WAITING
    58. //Thread-0 状态TIMED_WAITING
    59. //hi 9
    60. //Thread-0 状态TIMED_WAITING
    61. //Thread-0 状态TIMED_WAITING
    62. //Thread-0 状态TERMINATED

    10、线程的同步：

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

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

    （3）

    （4）解决售票超卖问题：

    1. //使用Runnable
    2. package ticket;
    3.  
    4. public class SellTicket {
    5.     public static void main(String[] args) throws InterruptedException {
    6.         SellTicket02 sellTicket = new SellTicket02();
    7.         //三个售票窗口
    8.         new Thread(sellTicket).start();
    9.         new Thread(sellTicket).start();
    10.         new Thread(sellTicket).start();
    11.     }
    12. }
    13. //使用Thread
    14. class SellTicket02 implements Runnable{
    15.     private static int ticketNum=100;
    16.     private boolean loop=true;
    17.  
    18.     public boolean isLoop() {
    19.         return loop;
    20.     }
    21.  
    22.     public void setLoop(boolean loop) {
    23.         this.loop = loop;
    24.     }
    25.  
    26.     public synchronized void sell(){//同步方法，在同一时刻，只能有一个线程来执行sell方法
    27.         if (ticketNum <= 0) {
    28.             System.out.println("售票结束");
    29.             loop=false;
    30.             return;
    31.         }
    32.         try {
    33.             Thread.sleep(50);
    34.         } catch (Exception e) {
    35.             e.printStackTrace();
    36.         }
    37.         System.out.println("窗口 "+Thread.currentThread().getName()+" 售出一张票"
    38.                 +" 剩余票数="+(--ticketNum));
    39.     }
    40.  
    41.     public void run(){
    42.         while(loop){
    43.             sell();
    44.         }
    45.     }
    46. }
    47. //窗口 Thread-0 售出一张票 剩余票数=99
    48. //窗口 Thread-0 售出一张票 剩余票数=98
    49. //窗口 Thread-0 售出一张票 剩余票数=97
    50. //窗口 Thread-0 售出一张票 剩余票数=96
    51. //窗口 Thread-0 售出一张票 剩余票数=95
    52. //窗口 Thread-0 售出一张票 剩余票数=94
    53. //窗口 Thread-0 售出一张票 剩余票数=93
    54. //窗口 Thread-0 售出一张票 剩余票数=92
    55. //窗口 Thread-0 售出一张票 剩余票数=91
    56. //窗口 Thread-0 售出一张票 剩余票数=90
    57. //窗口 Thread-0 售出一张票 剩余票数=89
    58. //窗口 Thread-2 售出一张票 剩余票数=88
    59. //窗口 Thread-1 售出一张票 剩余票数=87
    60. //窗口 Thread-1 售出一张票 剩余票数=86
    61. //窗口 Thread-1 售出一张票 剩余票数=85
    62. //窗口 Thread-2 售出一张票 剩余票数=84
    63. //窗口 Thread-2 售出一张票 剩余票数=83
    64. //窗口 Thread-2 售出一张票 剩余票数=82
    65. //窗口 Thread-2 售出一张票 剩余票数=81
    66. //窗口 Thread-2 售出一张票 剩余票数=80
    67. //窗口 Thread-2 售出一张票 剩余票数=79
    68. //窗口 Thread-2 售出一张票 剩余票数=78
    69. //窗口 Thread-2 售出一张票 剩余票数=77
    70. //窗口 Thread-2 售出一张票 剩余票数=76
    71. //窗口 Thread-2 售出一张票 剩余票数=75
    72. //窗口 Thread-0 售出一张票 剩余票数=74
    73. //窗口 Thread-0 售出一张票 剩余票数=73
    74. //窗口 Thread-0 售出一张票 剩余票数=72
    75. //窗口 Thread-0 售出一张票 剩余票数=71
    76. //窗口 Thread-0 售出一张票 剩余票数=70
    77. //窗口 Thread-0 售出一张票 剩余票数=69
    78. //窗口 Thread-0 售出一张票 剩余票数=68
    79. //窗口 Thread-0 售出一张票 剩余票数=67
    80. //窗口 Thread-0 售出一张票 剩余票数=66
    81. //窗口 Thread-0 售出一张票 剩余票数=65
    82. //窗口 Thread-0 售出一张票 剩余票数=64
    83. //窗口 Thread-0 售出一张票 剩余票数=63
    84. //窗口 Thread-0 售出一张票 剩余票数=62
    85. //窗口 Thread-0 售出一张票 剩余票数=61
    86. //窗口 Thread-0 售出一张票 剩余票数=60
    87. //窗口 Thread-0 售出一张票 剩余票数=59
    88. //窗口 Thread-0 售出一张票 剩余票数=58
    89. //窗口 Thread-2 售出一张票 剩余票数=57
    90. //窗口 Thread-2 售出一张票 剩余票数=56
    91. //窗口 Thread-2 售出一张票 剩余票数=55
    92. //窗口 Thread-2 售出一张票 剩余票数=54
    93. //窗口 Thread-1 售出一张票 剩余票数=53
    94. //窗口 Thread-2 售出一张票 剩余票数=52
    95. //窗口 Thread-2 售出一张票 剩余票数=51
    96. //窗口 Thread-2 售出一张票 剩余票数=50
    97. //窗口 Thread-2 售出一张票 剩余票数=49
    98. //窗口 Thread-2 售出一张票 剩余票数=48
    99. //窗口 Thread-2 售出一张票 剩余票数=47
    100. //窗口 Thread-2 售出一张票 剩余票数=46
    101. //窗口 Thread-0 售出一张票 剩余票数=45
    102. //窗口 Thread-0 售出一张票 剩余票数=44
    103. //窗口 Thread-0 售出一张票 剩余票数=43
    104. //窗口 Thread-2 售出一张票 剩余票数=42
    105. //窗口 Thread-2 售出一张票 剩余票数=41
    106. //窗口 Thread-2 售出一张票 剩余票数=40
    107. //窗口 Thread-2 售出一张票 剩余票数=39
    108. //窗口 Thread-1 售出一张票 剩余票数=38
    109. //窗口 Thread-1 售出一张票 剩余票数=37
    110. //窗口 Thread-2 售出一张票 剩余票数=36
    111. //窗口 Thread-2 售出一张票 剩余票数=35
    112. //窗口 Thread-2 售出一张票 剩余票数=34
    113. //窗口 Thread-2 售出一张票 剩余票数=33
    114. //窗口 Thread-2 售出一张票 剩余票数=32
    115. //窗口 Thread-2 售出一张票 剩余票数=31
    116. //窗口 Thread-2 售出一张票 剩余票数=30
    117. //窗口 Thread-2 售出一张票 剩余票数=29
    118. //窗口 Thread-2 售出一张票 剩余票数=28
    119. //窗口 Thread-0 售出一张票 剩余票数=27
    120. //窗口 Thread-0 售出一张票 剩余票数=26
    121. //窗口 Thread-0 售出一张票 剩余票数=25
    122. //窗口 Thread-0 售出一张票 剩余票数=24
    123. //窗口 Thread-0 售出一张票 剩余票数=23
    124. //窗口 Thread-0 售出一张票 剩余票数=22
    125. //窗口 Thread-2 售出一张票 剩余票数=21
    126. //窗口 Thread-2 售出一张票 剩余票数=20
    127. //窗口 Thread-2 售出一张票 剩余票数=19
    128. //窗口 Thread-2 售出一张票 剩余票数=18
    129. //窗口 Thread-1 售出一张票 剩余票数=17
    130. //窗口 Thread-2 售出一张票 剩余票数=16
    131. //窗口 Thread-2 售出一张票 剩余票数=15
    132. //窗口 Thread-2 售出一张票 剩余票数=14
    133. //窗口 Thread-0 售出一张票 剩余票数=13
    134. //窗口 Thread-2 售出一张票 剩余票数=12
    135. //窗口 Thread-2 售出一张票 剩余票数=11
    136. //窗口 Thread-1 售出一张票 剩余票数=10
    137. //窗口 Thread-1 售出一张票 剩余票数=9
    138. //窗口 Thread-1 售出一张票 剩余票数=8
    139. //窗口 Thread-1 售出一张票 剩余票数=7
    140. //窗口 Thread-1 售出一张票 剩余票数=6
    141. //窗口 Thread-2 售出一张票 剩余票数=5
    142. //窗口 Thread-2 售出一张票 剩余票数=4
    143. //窗口 Thread-2 售出一张票 剩余票数=3
    144. //窗口 Thread-2 售出一张票 剩余票数=2
    145. //窗口 Thread-0 售出一张票 剩余票数=1
    146. //窗口 Thread-0 售出一张票 剩余票数=0
    147. //售票结束
    148. //售票结束
    149. //售票结束

    11、互斥锁：

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

    1. class SellTicket02 implements Runnable {
    2.     //...
    3.     //1、public synchronized void sell(){}就是一个同步方法
    4.     public synchronized void sell01() {//同步方法，在同一时刻，只能有一个线程来执行sell方法，靠抢夺得到
    5.         if (ticketNum <= 0) {
    6.             System.out.println("售票结束");
    7.             loop = false;
    8.             return;
    9.         }
    10.         try {
    11.             Thread.sleep(50);
    12.         } catch (Exception e) {
    13.             e.printStackTrace();
    14.         }
    15.         System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
    16.                 + " 剩余票数=" + (--ticketNum));
    17.     }
    18.  
    19.     //2、这里锁在this对象
    20.     public void sell02() {//同步方法，在同一时刻，只能有一个线程来执行sell方法，靠抢夺得到
    21.  
    22.         synchronized (this) {
    23.             if (ticketNum <= 0) {
    24.                 System.out.println("售票结束");
    25.                 loop = false;
    26.                 return;
    27.             }
    28.         }
    29.         try {
    30.             Thread.sleep(50);
    31.         } catch (Exception e) {
    32.             e.printStackTrace();
    33.         }
    34.         System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
    35.                 + " 剩余票数=" + (--ticketNum));
    36.     }
    37.  
    38.     //3、也可以在代码块上写synchronized，同步代码块
    39.     Object object=new Object();
    40.     public void sell03() {//同步方法，在同一时刻，只能有一个线程来执行sell方法，靠抢夺得到
    41.  
    42.         synchronized (object) {
    43.             if (ticketNum <= 0) {
    44.                 System.out.println("售票结束");
    45.                 loop = false;
    46.                 return;
    47.             }
    48.         }
    49.         try {
    50.             Thread.sleep(50);
    51.         } catch (Exception e) {
    52.             e.printStackTrace();
    53.         }
    54.         System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
    55.                 + " 剩余票数=" + (--ticketNum));
    56.     }
    57.  
    58.     //静态的同步方法的锁为当前类本身
    59.     //1、
    60.     public synchronized static void sell04() {}//锁是加在SellTicket02.class
    61.  
    62.     //2、
    63.     public static void sell05(){
    64.         synchronized(SellTicket02.class){
    65.             System.out.println("sell05");
    66.         }
    67.     }
    68.     //...
    69. }

    （2） 注意事项和细节
    1）同步方法如果没有使用static修饰：默认锁对象为this

    2）如果方法使用static修饰，默认锁对象：当前类.class

    3）实现的落地步骤：
      需要先分析上锁的代码
      选择同步代码块或同步方法
      要求多个线程的锁对象为同一个即可！

    12、线程的死锁

    （1）基本介绍：

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

    1. package threaduse;
    2.  
    3. public class DeadLock {
    4.     public static void main(String[] args) {
    5.         //模拟死锁现象
    6.         DeadLockDemo A = new DeadLockDemo(true);
    7.         A.setName("A线程");
    8.         DeadLockDemo B = new DeadLockDemo(false);
    9.         B.setName("B线程");
    10.         A.start();
    11.         B.start();
    12.     }
    13. }
    14. class DeadLockDemo extends Thread{
    15.     static Object o1=new Object();//保证多线程，共享一个对象，这里使用static
    16.     static Object o2=new Object();
    17.     boolean flag;
    18.  
    19.     public DeadLockDemo(boolean flag) {
    20.         this.flag = flag;
    21.     }
    22.     public void run(){
    23.         //下面业务逻辑分析：
    24.         //1、如果flag为T，线程A就会先得到/持有o1对象锁，然后尝试去获取o2对象锁
    25.         //2、如果线程A得不到o2对象锁，就会Blocked
    26.         //3、如果flag为T，线程B就会先得到/持有o1对象锁，然后尝试去获取o2对象锁
    27.         //4、如果线程B得不到o2对象锁，就会Blocked
    28.         if (flag) {
    29.             synchronized (o1){//对象互斥锁，下面就是同步代码
    30.                 System.out.println(Thread.currentThread().getName()+"进入1");
    31.                 synchronized (o2){//这里获得li对象的监视权
    32.                     System.out.println(Thread.currentThread().getName()+"进入2");
    33.                 }
    34.             }
    35.         }else{
    36.             synchronized (o2){//对象互斥锁，下面就是同步代码
    37.                 System.out.println(Thread.currentThread().getName()+"进入3");
    38.                 synchronized (o1){//这里获得li对象的监视权
    39.                     System.out.println(Thread.currentThread().getName()+"进入4");
    40.                 }
    41.             }
    42.         }
    43.         //我的理解：
    44.         //有线程走if，拿到了o1的锁，等待着o2的锁，没拿到就没法释放资源，但同时有线程走else，拿到了o2的锁，等待着o1的锁，所以它们永远不可能等到对方
    45.     }
    46. }
    47. //输出：（卡住了）
    48. //A线程进入1
    49. //B线程进入3

    13、释放锁：

    下面操作会释放锁：

    （1）当前线程的同步方法、同步代码块执行结束

    上厕所，完事出来

    （2）当前线程的同步代码块、同步方法中遇到break, return

    没有正常地完事，经理叫他修改bug，不得已出来

    （3）当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束

    没有正常地完事，发现忘带纸，不得已出来

    （4）当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁

    没有正常完事，觉得需要酝酿下，所以出来等会再进去

     下面操作不会释放锁：

    （1）线程执行同步代码块或同步方法时，程序调用Thread.sleep(), Thread.yield()方法暂停当前线程的执行，不会释放锁

    上厕所，太困了，在坑位上眯了一会

    （2）线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁

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

  • 相关阅读:
    重邮803计网概述
    javaEE -4（11000字详解多线程）
    java实例化的五种方式
    Qt多弹窗实现包括QDialog、QWidget、QMainWindow
    一个恢复CSI挂载信息的解决方法
    Centos7 Docker&Docker-Compose安装教程
    【C++笔记】第二十五篇 内建函数对象
    解决国标28181传输视频流导致设备内存消耗的问题
    蚁剑加密 WebShell 过杀软
    YOLOv8：官方项目训练
  • 原文地址：https://blog.csdn.net/weixin_72052233/article/details/128069475