• java中的多线程

    文章目录

    1.什么是进程？什么是线程？

    进程是一个应用程序（1个进程是一个软件）。
    线程是一个进程中的执行场景/执行单元。
    一个进程可以启动多个线程。

    在Dos命令窗口中输入:java HelloWorld 回车之后。
    会先启动JVM，而JV,就是一个进程。
    JVM再启动一个主线程调用main方法。
    同时再启动一个垃圾回收线程负责看护，回收垃圾。
    最起码，现在的java程序中至少有两个线程并发，
    一个是垃圾回收线程，一个是执行main方法的主线程。

    2.进程和线程是什么关系？

    进程可以看作是现实生活当中的公司。
    线程可以看作是公司当中的某个员工。
    京东: 进程
    刘强东: 京东的一个线程
    奶茶妹妹: 京东的一个线程

    注意：
    进程A和进程B:
    内存独立不共享。（京东和阿里巴巴资源不共享）
    线程A和线程B:
    堆内存和方法区内存共享。
    但是栈内存独立，一个线程一个栈。（10个进程有10个栈空间，互不干扰）

    java之所以有多线程机制，目的就是为了提高程序的处理效率。

    使用了多线程机制之后，main方法结束，有可能程序也不会结束。
    main方法结束只是主线程结束了，主栈空了，其他的栈（线程）可能还在压栈弹栈。

    3.单核CPU不能真正做到多线程并发！

    对于多核的CPU电脑来说，真正的多线程并发是没问题的。
    4核CPU表示同一个时间点上，可以真正的4个进程并发执行。

    单核的CPU表示只有一个大脑:
    不能够做到真正的多线程并发，但是可以做到给人一种"多线程并发"的感觉。
    对于单核的CPU来说，在某一个时间点上实际上只能处理一件事情，但是由于
    CPU的处理速度极快，多个线程之间频繁切换执行，给人的感觉是：多个事情同时在做。

    4.实现线程的两种方式

    1）第一种方式：

        编写一个类，直接继承java.lang.Thread，重写run方法。

    • 1
    //定线程类
public class MyThread extends Thread{
    public void run() {
        
   }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    //创建线程对象
MyThread t=new MyThread();
//启动线程。
t.start();

    • 1
    • 2
    • 3
    • 4

    实例:

    package com.jmpower.javase.thread;

/*
实现线程的第一种方式:
    编写一个类，直接继承java.lang.Thread，重写run方法。
    
    怎么创建线程对象呢？new就行了。
    怎么启动线程呢？调用线程对象的start()方法。
    
注意:
    亘古不变的道理:
        方法体当中的代码永远都是自上而下的顺序依次逐行执行的。
        
以下程序的输出结果有这样的特点:
    有先有后。
    有多有少
 */
public class ThreadTest01 {
    public static void main(String[] args) {
        //这里是main方法，这里的代码属于主线程，在主栈中进行。
        //新建一个分支线程对象。
        MyThread t=new MyThread();
        //启动线程
        //t.run();//不会启动线程，不会分配新的分支栈。（这种方式就是单线程。）
        //start()方法的作用是:启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码任务完成之后，瞬间就结束了。
        //这段代码的任务只是为了开启一个新的栈空间，只要新的栈空间开出来，start()方法就结束了。线程就启动成功了。
        //启动成功的线程会自动调用run方法，并且run方法在分支栈的栈底部(压栈)
        //run方法在分支栈的栈底部，main方法在主栈的栈底部。run和main是平级的。
        t.start();
        //这里的代码还是运行在主线程中的。
        for(int i=0;i<100;i++)
        {
            System.out.println("主线程--->"+i);
        }
    }
}
class MyThread extends Thread{
    @Override
    public void run() {
        //编写程序，这段程序运行在分支线程中（分支栈）
        for(int i=0;i<100;i++)
        {
            System.out.println("并发线程--->"+i);
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46

    2）第二种方式:

    	编译一个可运行的类，通过Thread类的构造方法，创建线程对象。

    • 1
    //定义一个可运行的类
public class MyRunnable implements Runnable{
    public void run() {
        
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    //创建线程对象
MyThread t=new MyThread(new MyRunnable());
//启动线程。
t.start();

    • 1
    • 2
    • 3
    • 4

    实例:

    package com.jmpower.javase.thread;

/*
实现线程的第二种方式:
    编写一个类实现java.lang.Runnable接口。
 */
public class ThreadTest02 {
    public static void main(String[] args) {
        //创建一个可运行的对象
        MyRunnable r=new MyRunnable();
        //将可运行的对象封装成一个线程对象
        Thread t=new Thread(r);
        //启动线程
        t.start();
        for(int i=0;i<100;i++)
        {
            System.out.println("主线程--->"+i);
        }
    }
}
//这并不是一个线程类，是一个可运行的类。它还不是一个线程。
class MyRunnable implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<100;i++)
        {
            System.out.println("并发线程--->"+i);
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    5.采用匿名内部类的方式实现线程

    package com.jmpower.javase.thread;

/*
采用匿名内部类的方式实现线程。
 */
public class ThreadTest03 {
    public static void main(String[] args) {
        //创建线程对象，采用匿名内部类方式。
        //这是通过一个没有名字的类，new出来的对象。new [匿名] implements Runnable
        Thread t=new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<100;i++)
                {
                    System.out.println("分支线程--->"+i);
                }
            }
        });

        //启动线程
        t.start();
        for(int i=0;i<100;i++)
        {
            System.out.println("主线程--->"+i);
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27

    6.关于线程对象的生命周期

    新建状态
    就绪状态
    运行状态
    阻塞状态
    死亡状态

    如图:
    在这里插入图片描述

    7.获取与修改线程对象的信息

    package com.jmpower.javase.thread;

/*
1.获取当前线程对象:
    Thread t=Thread.currentThread();
    返回值t就是当前线程。
    
2.获取线程对象的名字:
    String name=线程对象.getNmae();
    
3.修改线程对象的名字:
    线程对象.setName();
    
4.当线程没有设置名字的时候，默认的名字有什么规律？
    Thread-0
    Thread-1
    Thread-2
    Thread-3
    .....
 */
public class ThreadTest04 {
    public static void main(String[] args) {
        //currentThread就是当前线程对象
        //这个代码出现在main方法当中，所以当前线程就是主线程
        Thread currentThread=Thread.currentThread();
        System.out.println(currentThread.getName());// main

        //创建线程对象
        MyThread2 t=new MyThread2();
        System.out.println(t.getName());//Thread-0 默认名字
        //设计线程名字
        t.setName("t1");
        //获取线程名字
        System.out.println(t.getName());//t1

        MyThread2 t2=new MyThread2();
        System.out.println(t2.getName());//Thread-1 默认名字
        t2.setName("t2");
        System.out.println(t.getName());//t2

        //启动线程
        t.start();
        t2.start();
    }
}
class MyThread2 extends Thread{
    @Override
    public void run() {
        for(int i=0;i<100;i++)
        {
            //currentName就是当前线程对象，当前线程是谁呢？
            //当t1线程执行run方法，那么这个当前线程就是t1
            //当t2线程执行run方法，那么这个当前线程就是t2
            Thread currentThread=Thread.currentThread();
            System.out.println(currentThread.getName());
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58

    8.线程的sleep方法

    package com.jmpower.javase.thread;

/*
关于线程的sleep方法:
    static void String(long millis)
    1.静态方法:Thread.sleep();
    2.参数是毫秒
    3.作用:让当前线程进入睡眠，进入"堵塞状态"，放弃占有CPU时间片，让给其他线程使用。
        这行代码出现在A线程中，A线程就会进入睡眠。
        这行代码出现在B线程在，B线程就会进入睡眠。
    4.Thread.sleep()方法，可以做到这种效果:
        间隔特定的时间，去执行一段特定的代码，没隔多久执行一次。
 */
public class ThreadTest05 {
    public static void main(String[] args) {
        //当当前程序睡眠5s
        //当前程序是主线程！
        try {
            Thread.sleep(1000*5);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        //5s后执行这里的代码
        System.out.println("hello world!");
        
        for(int i=0;i<10;i++)
        {
            System.out.println(Thread.currentThread().getName()+"--->"+i);
            //睡眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38

    9.sleep的面试题

    package com.jmpower.javase.thread;

/*
关于Thread.sleep()方法的一个面试题
 */
public class ThreadTest06 {
    public static void main(String[] args) {
        //创建线程对象
        Thread t=new MyThread3();
        t.setName("t");
        t.start();

        //调用sleep方法
        try {
            //问题:这行代码会让线程t进入休眠状态吗？
            t.sleep(1000*5);  //在执行的时候还是会转换成:Thread.sleep(1000*5);
                                    //这行代码的作用是:让当前线程进入休眠，也就是说main线程进入休眠。
                                    //这样代码出现在main方法中，main线程睡眠。
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        //5s后会进行
        System.out.println("hello world");
    }
}
class MyThread3 extends Thread{
    @Override
    public void run() {
        for(int i=0;i<10000;i++)
        {
            System.out.println(Thread.currentThread().getName()+"--->"+i);
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

    10.终止线程的睡眠

    package com.jmpower.javase.thread;

/*
sleep睡眠太久了，如果希望半道上醒来，你应该怎么办？也就是说怎么叫醒一个正在休眠的程序？
    注意: 这个不是终端程序的执行，是终止程序的睡眠。
 */
public class ThreadTest07 {
    public static void main(String[] args) {
        Thread t=new Thread(new MyRunnable2());
        t.setName("t");
        t.start();

        //希望5s之后，t线程醒来（5s之后主线程手里的活干完了）
        try {
            Thread.sleep(1000*5);
        } catch (InterruptedException e) {
            //打印异常堆栈追踪信息
            e.printStackTrace();
        }

        //终端t线程的睡眠（这种终端睡眠的方式依靠了java的异常处理机制）
        t.interrupt();//干扰，一盆冷水过去了！
    }
}
class MyRunnable2 implements Runnable{

    //重点:run()当前的异常不能throws,只能try catch
    //因为run()方法在父类中没有抛出任何异常，子类不能比父类抛出更多的异常。
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"--->begin");
        try {
            //睡眠1年
            Thread.sleep(365*24*60*60*1000);
        } catch (InterruptedException e) {
            //打印异常堆栈追踪信息
            e.printStackTrace();
        }
        //1年之后才会执行这里
        System.out.println(Thread.currentThread().getName()+"--->end");

        //调用doOther
        //doOther();
    }

    //其他方法可以throw
    /*public void doOther() throws Exception{

    }*/

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51

    11.终止线程的执行

    package com.jmpower.javase.thread;

/*
怎么合理的种植一个线程的执行。这种方式是很常用的。
 */
public class ThreadTest08 {
    public static void main(String[] args) {
        MyRunnable3 r=new MyRunnable3();
        Thread t=new Thread(r);
        t.setName("t");
        t.start();

        try {
            Thread.sleep(1000*5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //终止进程
        //你想要什么时候终止t的执行，只需要把标记修改为false，就可以了。
        r.run=false;
    }
}
class MyRunnable3 implements Runnable{
    //打印一个布尔标记
    boolean run=true;
    @Override
    public void run() {
        for(int i=0;i<1000;i++)
        {
            if(run)
            {
                System.out.println(Thread.currentThread().getName()+"--->"+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            else{
                //return 就结束了，在结束之前还有什么没保存的。
                //在这里可以进行保存处理。
                //.....
                //终止当前线程
                return ;
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49

    12.线程调度

    1）线程调度模型

    抢占式调度模型：
    哪个线程的优先级比较高，抢到的CPU时间片的概率就高一些/多一些。
    java采用的就是抢占式调度模型。
    均分式调度模型：
    平均分配CPU时间片。每个线程占有的CPU时间片时间长度一样。

    2）java中提供了哪些方法是和线程调度有关系的呢？

    实例方法:
    void setPriority(int newPriority) 设置线程的优先级
    int getPriority() 获取线程优先级
    最低优先级: 1
    最高优先级: 10
    默认优先级: 5
    优先级比较高的获取的CPU时间片可能会多一些。（但也不完全是，大概率是多的。）
    测试:

    package com.jmpower.javase.thread;

public class ThreadTest09 {
  public static void main(String[] args) {
      Thread t=new MyThread5();
      t.setName("t");
      System.out.println(t.getPriority());// 5
      t.setPriority(1);
      System.out.println(t.getPriority());// 1
      t.start();

      for(int i=0;i<100;i++)
      {
          System.out.println(Thread.currentThread().getName()+"--->"+i);
      }
  }
}
class MyThread5 extends Thread{
  @Override
  public void run() {
      for(int i=0;i<100;i++)
      {
          System.out.println(Thread.currentThread().getName()+"--->"+i);
      }
  }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    静态方法:
    static void yield() 让位方法
    暂停当前正在执行的线程对象，并执行其他线程。
    yield()方法不是阻塞方法。让当前线程让位，让给其他线程使用。
    yield()方法的执行会让当前线程从"运行状态"回到"就绪状态"。
    注意: 在回到就绪之后，有可能还会再次抢到CPU时间片。
    测试:

    package com.jmpower.javase.thread;

public class ThreadTest10 {
  public static void main(String[] args) {
      Thread t=new MyThread6();
      t.setName("t");
      t.start();

      for(int i=1;i<=10000;i++)
      {
          System.out.println(Thread.currentThread().getName()+"--->"+i);
      }
  }
}
class MyThread6 extends Thread{
  @Override
  public void run() {
      for(int i=1;i<=10000;i++)
      {
          if(i%100==0) Thread.yield();//每100次，让位一次
          System.out.println(Thread.currentThread().getName()+"--->"+i);
      }
  }
}
/*
main--->9245
t--->7598
t--->7599
main--->9246
main--->9247
main--->9248
*/

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    实例方法:
    void join()
    合并线程

    class MyThread1 extends Thread{
     public void run() {
         MyThread10 t=new MyThread10()；
         t.join();//当前线程进入堵塞，t线程执行，直到t线程结束。当前线程才可以执行。
     }
}
class MyThread2 extends Thread{ 
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    测试:

    package com.jmpower.javase.thread;

public class ThreadTest11 {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+"--->begin");
        MyRunnable4 r=new MyRunnable4();
        Thread t=new Thread(r);
        t.setName("t");
        t.start();

        //合并线程
        try {
            t.join();//t合并到当前线程中，当前线程受阻，t线程执行直到结束。
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName()+"--->end");
    }
}
class MyRunnable4 implements Runnable{

    @Override
    public void run() {
        for(int i=0;i<100;i++)
        {

            System.out.println(Thread.currentThread().getName()+"--->"+i);
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31

    13.线程不安全的三个条件:

    条件1: 多线程并发
    条件2: 有共享数据
    条件3: 共享数据有修改的行为

    14.怎么解决线程安全问题？

    使用"线程同步机制"。（线程不能并发了，必须排队执行）
    线程同步就是线程排队了，线程排队了就会牺牲一部分效率，没办法，数据安全第一位，只有数据安全了，才能谈效率。数据不安全，没有效率的事。

    15.同步和异步的理解:

    异步就是并发，同步就是排队。

    异步编程模型:
	线程t1和线程t2，各自执行各自的，t1不管t2，t2不管t1，
	谁也不许要等谁，这种编程模型叫做: 异步编程模型。
	其实就是: 多线程并发（效率较高）

    • 1
    • 2
    • 3
    • 4
    同步编程模型:
	线程t1和线程t2，在线程t1执行的时候，必须等待t2线程执行
	结束，或者说在t2线程执行的时候，必须等待t1线程执行结束，
	两个线程之间发生了等待关系，这就是同步编程模型。
	（效率较低。线程排队执行。）

    • 1
    • 2
    • 3
    • 4
    • 5

    16.处理账户类的线程安全问题（含synchronized的理解）

    Account类(理解synchronized)

    package com.jmpower.javase.threadsafe;
/*
银行账户
    使用线程同步机制，解决线程安全问题。
 */
public class Account {
    //账号
    private String actno;
    //余额
    private double blance;

    Object obj=new Object();//实例变量。（Account对象是多线程共享的，Account对象中的实例变量obj也是共享的。）

    public Account(){

    }
    public Account(String actno, double blance) {
        this.actno = actno;
        this.blance = blance;
    }
    public String getActno() {
        return actno;
    }
    public void setActno(String actno) {
        this.actno = actno;
    }
    public double getBlance() {
        return blance;
    }
    public void setBlance(double blance) {
        this.blance = blance;
    }
    //取款的方法
    public void withdraw(double money){
        //以下这几行代码必须是线程排队的，不能并发。
        //一个线程把这里的代码全部执行结束之后，另一个线程才能进来。
        /*
        线程同步机制的语法:
            synchronized(){

            }
            synchronized后面小括号中传的这个"数据"是相当关键的。
            这个数据必须是多线程共享的数据。才能达到多线程排队。

            ()中写什么？
                那要看你想让哪些线程同步了！
                假设t1,t2,t3,t4,t5不需要排队。怎么办？
                你一定要在()中写一个t1,t2,t3共享的对象。而这个对象对于
                对象t4,t5来说不是共享的。

            这里共享对象是: 账户对象
            账户对象是共享的，那么this就是账户对象吧！
            不一定是this,这里只要是多线程共享的那么对象就行。

            在java语言中，任何一个对象都有"一把锁"，其实这把锁就是标记。（只是把它叫做锁。）
            100个对象，100把锁，1对象1把锁。

            以下代码的执行原理？
                1.假设t1和t2线程并发，开始执行以下代码的时候，肯定有一个先一个后。
                2.假设t1先执行了，遇到了synchronized，这个时候自动找"后面共享对象"的对象锁，
                找到之后，并占有这把锁，然后执行同步代码块中的程序，在程序执行过程中一直都是
                占有这把锁的。直到同步代码块代码结束，这把锁才会释放。
                3.假设t1已经占有这把锁，此时t2也遇到了synchronized关键词，也会去占有后面
                共享对象的这把锁，结果这把锁被t1占有了，t2只能在同步代码块外面等待t1的结束，
                直到t1把同步代码块执行结束了，t1会归还这把锁，此时t2终于等到这把锁，然后t2
                占有这把锁之后，进入同步代码块执行程序。

                这样就达到了线程排队执行。
                这里需要注意的是:这个共享对象一定要选好了。这个共享对象一定是你需要排队
                执行的这些线程对象所共享的。
         */
        //Object obj2=new Object();
        synchronized(this){   //线程安全
        //synchronized(obj){    线程安全
        //synchronized("abc"){  线程安全,"abc"在字符串常量池中，所以所有的线程都同步,这样不满足只要t1,t2,t3线程同步的要求
        //synchronized(null){   线程不安全,空指针异常
        //synchronized(obj2){   线程不安全,因为obj2不是共享对象。
            double before=this.getBlance();
            double after=before-money;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.setBlance(after);
        }

    }

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90

    AccountThread类

    package com.jmpower.javase.threadsafe;

public class AccountThread extends Thread{
    //两个线程必须共享同一个账户对象
    private Account act;

    //通过构造方法传递过来账户信息
    public AccountThread(Account act){
        this.act=act;
    }

    public void run() {
        //run方法的执行表示取款操作
        //假设取款5000
        double money=5000;
        //取款
        //多线程并发执行这个方法
        act.withdraw(5000);

        System.out.println(Thread.currentThread().getName()+"对"+act.getActno()+"取款"+money+"成功，余额还剩"+act.getBlance());
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    测试类

    package com.jmpower.javase.threadsafe;

public class Test {
    public static void main(String[] args) {
        //创建账户对象（只创建1个）
        Account act=new Account("act-001",10000);
        //创建两个线程
        Thread t1=new AccountThread(act);
        Thread t2=new AccountThread(act);
        /*Account act2=new Account("act-002",10000);
        Thread t3=new AccountThread(act2);*/
        //设置名字
        t1.setName("t1");
        t2.setName("t2");
        //启动线程对象
        t1.start();
        t2.start();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    17.java有三大变量？

    实例变量: 在堆中。
    静态变量: 在方法区。
    局部变量: 在栈中。
    以上三大变量中:
    局部变量永远都不会存在线程安全问题。
    因为局部变量永远不共享。（一个线程一个栈）
    局部变量在栈中。所以局部变量永远都不会共享。
    实例变量在堆中，堆只有1个。
    静态变量在方法区中，方法区只有1个。
    堆和方法区都是多线程共享的，所以可能存在线程安全问题。
    局部变量+常量：不会有线程安全问题。
    成员变量：可能会有线程安全问题。

    18.如何选择类？

    如果使用局部变量的话：
    建议使用：StringBuilder。
    因为局部变量不存在线程安全问题。选择StringBuilder。
    StringBuffer效率比较低。

    ArrayList是非线程安全的。
    Vector是线程安全的。
    HashMap HashSet是非线程安全的。
    Hashtable实线程安全的。

    19.synchronized的三种写法

    第一种：同步代码块

    灵活
synchronized(共享线程对象){
	同步代码块;
}

    • 1
    • 2
    • 3
    • 4
    synchronized(this){   //线程安全
     double before=this.getBlance();
     double after=before-money;
     try {
         Thread.sleep(1000);
     } catch (InterruptedException e) {
         e.printStackTrace();
     }
     this.setBlance(after);
 }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    第二种：在实例方法上使用synchronized

    表示共享对象一定是this
并且同步代码块是整个方法体。

    • 1
    • 2
    /*
    在实例方法上可以使用synchronized吗？可以的
        synchronized出现在实例方法上，一定锁的是this
        没得挑。只能是this，不能是其他的对象。
        所以这种方式不灵活。

        另外还有一个缺点：synchronized出现在实例方法上，
        表示整个方法体都需要同步，可能会无故扩大同步的范围，
        导致程序的执行效率降低。所以这种方式不常用。

        synchronized使用在实例方法上有什么优点？
            代码写的少了。节俭了。

        如果共享的对象就是this，并且需要同步的代码块是整个方法体。
        建议使用这种方式。
     */
    public synchronized void withdraw(double money){
        double before=this.getBlance();
        double after=before-money;
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.setBlance(after);
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    第三种：在静态方法上使用synchronized

    表示找类锁。
类锁永远只有一把。
就算创建了100个对象，那类锁也只有一把。

    对象锁：1个对象1把锁，100个对象100把锁。
    类锁：100个对象，也可能只是1把类锁。

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    20.synchronized面试题

    面试题1：

    package com.jmpower.javase.exam;

//面试题：doOther方法执行的时候需要等待doSome方法的结束吗？
//不需等待，因为doOther()方法没有synchronized
public class Exam01 {
    public static void main(String[] args) {
        MyClass mc=new MyClass();

        Thread t1=new MyThread(mc);
        Thread t2=new MyThread(mc);

        t1.setName("t1");
        t2.setName("t2");

        t1.start();
        try {
            Thread.sleep(1000);//这个睡眠的作用是：为了保证t1线程先执行。
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();
    }
}
class MyThread extends Thread{
    private MyClass mc;

    public MyThread(MyClass mc) {
        this.mc = mc;
    }

    @Override
    public void run() {
        if(Thread.currentThread().getName().equals("t1")){
            mc.doSome();
        }
        if(Thread.currentThread().getName().equals("t2")){
            mc.doOther();
        }
    }
}
class MyClass{
    public synchronized void doSome(){
        System.out.println("doSome begin");
        try {
            Thread.sleep(1000*10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("doSome end");
    }
    public void doOther(){
        System.out.println("doOher begin");
        System.out.println("doOther end");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55

    面试题2（在面试题1的基础上，将doOther修改为被synchronized修饰）

    //需要等待，因为实例方法都被synchronized修饰，共享线程对象是this，两个方法均需等待。
class MyClass{
    public synchronized void doSome(){
        System.out.println("doSome begin");
        try {
            Thread.sleep(1000*10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("doSome end");
    }
    public synchronized void doOther(){
        System.out.println("doOher begin");
        System.out.println("doOther end");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    面试题3（在面试题2的基础上，修改为两个线程两个MyClass对象）

    //不需等待，因为MyClass对象是两个，两把锁。
public static void main(String[] args) {
        MyClass mc1=new MyClass();
        MyClass mc2=new MyClass();

        Thread t1=new MyThread(mc1);
        Thread t2=new MyThread(mc2);

        t1.setName("t1");
        t2.setName("t2");

        t1.start();
        try {
            Thread.sleep(1000);//这个睡眠的作用是：为了保证t1线程先执行。
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    面试题4（在面试题3的基础上，将方法体改为被synchronized修饰的静态方法）

    //需要等待，synchronized出现在静态方法上是找类锁。同一个类只有一把锁。
class MyClass{
    public synchronized static void doSome(){
        System.out.println("doSome begin");
        try {
            Thread.sleep(1000*10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("doSome end");
    }
    public synchronized static void doOther(){
        System.out.println("doOher begin");
        System.out.println("doOther end");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    21.死锁的写法

    package com.jmpower.javase.threadsafe;

public class DeadLock {
    public static void main(String[] args) {
        Object o1=new Object();
        Object o2=new Object();

        //t1和t2两个线程共享o1,o2
        Thread t1=new MyThread1(o1,o2);
        Thread t2=new MyThread2(o1,o2);

        t1.start();
        t2.start();
    }
}
class MyThread1 extends Thread{
    Object o1;
    Object o2;
    public MyThread1(Object o1, Object o2) {
        this.o1 = o1;
        this.o2 = o2;
    }
    public void run() {
        synchronized (o1){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            synchronized (o2){

            }
        }
    }
}
class MyThread2 extends Thread{
    Object o1;
    Object o2;
    public MyThread2(Object o1, Object o2) {
        this.o1 = o1;
        this.o2 = o2;
    }
    public void run() {
        synchronized (o2){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            synchronized (o1){

            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55

    22.总结：在以后开发中怎么解决线程安全问题？

    第一种*方案：尽量使用局部变量代替"实例变量和静态变量"
    第二种方案：如果必须是实例变量，那么可以考虑创建多个对象，这样实例变量的内存就不共享了。（一个线程对应一个对象，100个线程对应100个对象，对象不共享，就没有数据安全问题了）
    第三种方案：如果不能使用局部变量，对象也不能创建多个，这个时候就只能选择synchronized了。线程同步机制。

    23.守护线程

    java语言中线程分为两大类：

    一类是：用户线程
一类是：守护线程（后台线程）	

    • 1
    • 2

    其中具有代表性的就是：垃圾回收机制（守护线程）

    守护线程的特点：

    一般守护线程是一个死循环，所有的用户线程只要结束。守护线程自动结束。

    • 1

    主线程main方法是一个用户线程。

    守护线程用在什么地方：

    如，每天00:00的时候系统自动备份。
    这个需要使用到定时器，并且我们可以将定时器设置会守护线程。
    一直在那里看着，每到00:00的时候就备份一次。所有的用户线程
    如果结束了，守护线程自动退出，没有必要进行数据备份了。

    package com.jmpower.javase.thread;
/*
守护线程
 */
public class ThreadTest12 {
    public static void main(String[] args) {
        Thread t=new BackupDateThread();
        t.setName("备份数据的线程");

        //启动线程之前，将线程设置为守护线程。
        t.setDaemon(true);

        t.start();

        //主线程：主线程是用户线程
        for(int i=0;i<10;i++)
        {
            System.out.println(Thread.currentThread().getName()+"---"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class BackupDateThread extends Thread{
    public void run() {
        int i=0;
        //即使是死循环，但由于该线程是守护者，当用户线程结束，守护线程自动终止。
        while(true)
        {
            System.out.println(Thread.currentThread().getName()+"--->"+(++i));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41

    24.定时器

    定时器的作用：

    间隔特定的时间，执行特定的程序。

    定时器的应用场景：

    每周要进行银行账户的总账操作。
    每天要进行数据的备份操作。

    如何实现定时器:

    可以使用sleep方法，睡眠，设置睡眠时间，每到这个时间点醒来执行任务。这种方式是最最原始的定时器。（比较low）
    在java的类库中已经写好了一个定时器：java.util.Timer，这个直接拿来用。不过，这种方式在目前的开发中也很少用，因为现在有很多高级框架都是支持定时任务的。
    在实际的开发中，目前使用较多的是Spring框架中提供的SpringTask框架，这个框架只要进行简单的配置，就可以完成定时器的任务。

    package com.jmpower.javase.timer;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

/*
使用定时器指定定时任务。
 */
public class TimerTest {
    public static void main(String[] args) throws ParseException {
        //创建定时器对象
        Timer timer=new Timer();

        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date firstTime=sdf.parse("2022-7-13 18:57:00");

        //指定定时任务
        //timer.schedule(定时任务，第一次执行时间，间隔多久执行一次);
        timer.schedule(new LogTimerTask(),firstTime, 1000*10);

    }
}
//编写一个定时任务类
//假设这是一个记录日志的定时任务
class LogTimerTask extends TimerTask{
    @Override
    public void run() {
        //编写你需要执行的任务就行了。
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date=new Date();
        String nowTime=sdf.format(date);
        System.out.println(nowTime+"完成一次备份");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37

    25.实现线程的第三种方式：

    FutureTask方式，实现Callable接口。
    这种方式的优点：可以获取到线程的执行结果。
    这种方式的缺点：效率比较低，在获取t线程执行结果的时候，当前线程受阻塞，效率较低。

    package com.jmpower.javase.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/*
实现线程的第三种方式:
  FutureTask方式，实现Callable接口。
  这种方式的优点：可以获取到线程的执行结果。
  这种方式的缺点：效率比较低，在获取t线程执行结果的时候，当前线程受阻塞，效率较低。
*/
public class ThreadTest13 {
  public static void main(String[] args) throws Exception{
      //第一步: 创建一个“未来任务类”对象。
      //参数非常重要，需要给一个Callable接口实现类对象。
      FutureTask task=new FutureTask(new Callable() {
          @Override
          public Object call() throws Exception {//call()方法就相当于run方法。只不过这个有返回值
              //线程执行一个任务，执行之后可能会有一个执行结果
              //模拟执行
              System.out.println("call method begin");
              Thread.sleep(1000*10);
              System.out.println("call method end");
              int a=100;
              int b=200;
              return a+b;//自动装箱（300结果变成Integer）
          }
      });

      //创建线程对象
      Thread t=new Thread(task);

      //启动线程
      t.start();

      //这里是main方法，这里在主线程中。
      //在主线程中，怎么获取线程的返回结果？
      //get()方法的执行会导致"当前线程阻塞"
      Object obj=task.get();
      System.out.println("线程执行结果:"+obj);

      //main方法这里的程序要想执行必须等待get()方法的结束
      //而get()方法可能需要很久，因为get()方法是为了拿另一个线程的执行结果。
      //另一个线程执行是需要时间的。
      System.out.println("hello world!");
  }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48

    25.关于Object类中的wait和notify方法（生产者和消费者模式）

    第一：wait和notify方法不是线程对象的方法，是java任何一个java对象都有的方法，因为这两个方式是Object类中自带的。
    wait方法和notify方法不是通过线程对象调用。
    不是这样： t.wait()，也不是这样的：t.notify()
    第二：wait()方法作用？
    Object o=new Object();
    o.wait();
    表示：
    让正在o对象上活动的线程进入等待状态，无期限等待。
    直到被唤醒为止。
    o.wait():方法的调用，会让"当前线程（正在o对象上活动的线程）"进入等待状态。
    第三：notify()方法作用？
    Object o=new Object();
    o.notify();
    表示：
    唤醒正在o对象上等待的线程。

    还有一个notifyAll()方法：
    这个方法是唤醒o对象上处于等待状态的所有线程。
    第四：
    wait和notify方法建立在synchronized线程同步的基础之上。
    o.wait()方法会让正在o对象上活动的当前线程进入等待状态，并且释放之前占有的o对象的锁。
    o.notify()方法只会通知，不会释放之前占有的对象的锁。

    模拟生产者和消费者模式

    package com.jmpower.javase.thread;

import java.util.ArrayList;
import java.util.List;
/*
1.使用wait方法和notify方法实现"生产者模式"
2.什么是"生产者和消费者模式"？
    生产线程负责生产，消费线程负责消费
    生产线程和消费线程要达到均衡。
    这是一种特殊的业务需求，在这种特殊的情况下需要使用wait方法和notify方法。
3.wait和notify方法不是线程对象的方法，是普通java对象都有的方法。
4.wait方法和notify方法建立在线程同步的基础上。因为多线程要同时操作一个仓库。有线程安全问题。
5.wait方法: o.wait()让正在o对象上活动的线程t进入等待状态，并且释放掉t线程之前占有的o对象的锁
6.notify方法: o.notify()让正在o对象上等待的线程唤醒，只是通知，不会释放o对象上之前占有的锁
7.模拟这样一个需求:
    仓库我们采用List集合。
    List集合中假设只能存储1个元素。
    如果List集合中元素个数是0，就表示仓库空了。
    保证List集合中永远都是最多存储1个元素。
    必须做到这种效果: 生产1个消费1个。
 */
public class ThreadTest14 {
    public static void main(String[] args) {
        //创建一个仓库对象，共享的。
        List list=new ArrayList();
        //创建两个线程对象
        //生产者线程
        Thread t1=new Thread(new Producer(list));
        //消费者线程
        Thread t2=new Thread(new Costumer(list));

        t1.setName("生产者线程");
        t2.setName("消费者线程");

        t1.start();
        t2.start();
    }
}
class Producer implements Runnable{
    //仓库
    private List list;

    public Producer(List list) {
        this.list = list;
    }
    @Override
    public void run() {
        //一直生产（使用死循环来模拟一直生产）
        while(true) {
            //对仓库对象list加锁
            synchronized (list){
                if(list.size()>0){//大于0，表示仓库中已经有一个元素了
                    try {
                        //当前线程进入等待状态，并且释放Producer之前占有的list集合的锁。
                        list.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
                //线程能执行到这里说明仓库是空的，可以生产
                Object obj=new Object();
                list.add(obj);
                System.out.println(Thread.currentThread().getName()+"--->"+obj);
                //唤醒消费者进行消费
                list.notify();
            }
        }
    }
}
class Costumer implements Runnable{
    //仓库
    private List list;

    public Costumer(List list) {
        this.list = list;
    }
    @Override
    public void run() {
        //一直消费
        while(true){
            synchronized (list){
                if(list.size()==0){
                    try {
                        //仓库空了，消费者线程进入等待，释放list集合的锁
                        list.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
                //程序能够执行到这里说明仓库中有数据，进行消费
                Object obj=list.remove(0);
                System.out.println(Thread.currentThread().getName()+"--->"+obj);
                //唤醒生产线程进行生产
                if(list.size()==0) list.notify();
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
  • 相关阅读:
    css列表
    Cesium渲染模块之Command
    SpringBoot教程(十六) SpringBoot集成swagger（全网最全）
    27.4 Java集合之Map学习
    Django 安装
    【iOS】JSONModel的基本使用
    ES6：const声明
    HazelEngine 学习记录 - Profiling
    Python实现直方图梯度提升分类模型(HistGradientBoostingClassifier算法)并基于网格搜索进行优化同时绘制PDP依赖图项目实战
    人工衍射透镜的设计与分析
  • 原文地址：https://blog.csdn.net/m0_66689823/article/details/125881878