本文主要是介绍javaDay25，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

这里写目录标题

• 一、线程安全同步问题1
• • 1、问题一：
  • 2、问题二：
  • 3、问题三：
• 二、死锁
• • 1、定义：
  • 2、举例：
  • 3、代码
• 三、线程同步
• • 1、同步安全解法一：synchronized关键字
  • 2、synchronized改进
  • 3、解决同步安全问题第二种解法:加lock锁
  • 4、线程安全的类
  • 5、匿名内部类的形式创建线程对象
• 四、线程组
• • 1、线程组
• 五、线程池
• • 1、线程池
  • 2、如何使用代码实现线程池呢？
• 六、实现多线程的第三种方式
• 七、定时器
• • 1、Demo1
  • 2、Demo2

一、线程安全同步问题1

1、问题一：

分析：
  共享数据：同一个学生对象Student
  生产者：SetThread给学生对象的成员变量进行赋值操作
  消费者：GetThread获取学生对象的成员变量的值
  测试者：StudentDemo创建两个线程，一个设置值线程，一个获取值线程

问题：
  按照我们分析的步骤去写代码，运行后发现，每一次的结果都是null---0，这是必然的。
  原因：设置值的线程与获取值的线程的操作的不是同一个学生对象
  如何解决呢？
    目的：让设置值的线程与获取值的线程的操作的是同一个学生对象
    解决方式：在外界创建出一个学生对象，通过参数的形式让两个线程操作同一个对象

public class StudentDemo {
    public static void main(String[] args) {
        Student s = new Student();

        //创建自定义类对象
        SetThread setThread = new SetThread(s);
        GetThread getThread = new GetThread(s);

        //使用Thread类创建线程对象，将自定义对象作为参数传递
        Thread proThread = new Thread(setThread);
        Thread cusThread = new Thread(getThread);

        proThread.setPriority(1);
        cusThread.setPriority(10);

        //启动线程
        proThread.start();
        cusThread.start();
    }
}

public class SetThread implements Runnable{
    private Student s;

    SetThread(Student student){
        s = student;
    }

    @Override
    public void run() {
//        Student s = new Student();
        s.name = "王宇";
        s.age = 18;
    }
}

public class GetThread implements Runnable{
    private Student s;

    GetThread(Student student){
        s = student;
    }

    @Override
    public void run() {
//        Student s = new Student();
        System.out.println(s.name+"---"+s.age);
    }
}

public class Student {
    String name;
    int age;
}

2、问题二：

问题二：我们为了方便观察更好的结果来修改，于是我们加入了循环和判断，不同的判断给同一个学生对象赋不同的值
但是呢，我们在运行的时候出现新的问题
  1、同一条数据出现了多次
  2、姓名和年龄与代码中不匹配

原因：
  1、同一条数据出现了多次
    由于CPU小小的时间片就可以执行很多次
  2、姓名和年龄与代码中不匹配
    这是由于线程的执行具有随机性导致的

产生线程同步安全问题：
  1、是否存在多线程环境   是
  2、是否存在共享数据    是
  3、是否有很多条语句操作着共享数据    是

既然都满足，那就说明线程不安全

解决方案：
  1、关键字加锁
  2、Lock锁
注意事项：
  1、不同种类的线程对象都需要加锁
  2、不同种类的线程对象拥有的必须是同一把锁

public class StudentDemo {
    public static void main(String[] args) {
        Student s = new Student();
        Lock lock = new ReentrantLock();

        //创建自定义类对象
        SetThread setThread = new SetThread(s, lock);
        GetThread getThread = new GetThread(s, lock);

        //使用Thread类创建线程对象，将自定义对象作为参数传递
        Thread proThread = new Thread(setThread);
        Thread cusThread = new Thread(getThread);

        proThread.setPriority(1);
        cusThread.setPriority(10);

        //启动线程
        proThread.start();
        cusThread.start();
    }
}

import java.util.concurrent.locks.Lock;

public class SetThread implements Runnable{
    private Student s;
    private Lock lock;

    private int i = 0;

    public SetThread(Student student){
        s = student;
    }

    SetThread(Student student, Lock lock){
        s = student;
        this.lock = lock;
    }

    @Override
    public void run() {
//        Student s = new Student();
//        s.name = "王宇";
//        s.age = 18;
//        while(true){
//            synchronized(s){
//                if (i % 2 == 0){
//                    s.name = "王宇";
//                    s.age = 18;
//                }else{
//                    s.name = "张保桂";
//                    s.age = 19;
//                }
//                i++;
//            }
//        }
        while (true){
            lock.lock();
            if(i % 2 == 0){
                s.name = "王宇";
                s.age = 18;
            }else{
                s.name = "张保桂";
                s.age = 19;
            }
            i++;
            lock.unlock();
        }
    }
}

import java.util.concurrent.locks.Lock;

public class GetThread implements Runnable {
    private Student s;
    private Lock lock;

    public GetThread(Student student) {
        s = student;
    }

    GetThread(Student student, Lock lock) {
        s = student;
        this.lock = lock;
    }

    @Override
    public void run() {
//      Student s = new Student();
//        while (true){
//            synchronized(s){
//                System.out.println(s.name+"---"+s.age);
//            }
//        }
        while (true) {
            lock.lock();
            System.out.println(s.name + "---" + s.age);
            lock.unlock();
        }
    }
}

public class Student {
    String name;
    int age;
}

3、问题三：

问题3：我们虽然解决了线程安全的问题，但是观察结果后发现，同一条数据连续消费了很多次，而这样的问题叫做生产者
消费者的问题，使用Java提供的等待唤醒机制去解决。

如何添加等待唤醒机制呢？
  所需要调用的方法在Object类中，Object类中有三个方法需要我们学习

  void notify()
    唤醒正在等待对象监视器的单个线程
  void notifyAll()
    唤醒正在等待对象监视器的所有线程
  void wait()
    导致当前线程等待，直到另一个线程调用该对象的notify()方法或notifyAll()方法

    为什么这三个方法不定义在Thread类中呢？
      这些方法要想调用，必须通过锁对象调用，因为如果连锁对象都不一样了，就没必要等待唤醒了，直接执行逻辑代码
      而说到现在同步代码块的锁对象是任意对象，类型无法确定，所以这些方法都定义在Object类中，引Java所有的类都有一个共同父类Object

public class StudentDemo {
    public static void main(String[] args) {
        Student s = new Student();


        //创建自定义类对象
        SetThread setThread = new SetThread(s);
        GetThread getThread = new GetThread(s);

        //使用Thread类创建线程对象，将自定义对象作为参数传递
        Thread proThread = new Thread(setThread);
        Thread cusThread = new Thread(getThread);


        //启动线程
        proThread.start();
        cusThread.start();
    }
}

import java.util.concurrent.locks.Lock;

public class SetThread implements Runnable{
    private Student s;
    private Lock lock;

    private int i = 0;

    SetThread(Student student){
        s = student;
    }

    SetThread(Student student,Lock lock){
        s = student;
        this.lock = lock;
    }

    @Override
    public void run() {
//        Student s = new Student();
        s.name = "王宇";
        s.age = 18;
        while (true){
            synchronized(s){
                //判断学生对象有没有值
                //flag初始的值是false，表示没有值，如果是true表示生产者已经生产了值
                //有值对于生产者来说，等待消费者消费数据
                if (s.flag){
                    try {
                        s.wait();//阻塞，等待消费者消费数据，才能继续往下走
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
                if (i % 2 == 0){
                    s.name = "王宇";
                    s.age = 18;
                }else{
                    s.name = "张保桂";
                    s.age = 19;
                }
                i++;

                //生产者生产完数据后，将flag值改为true
                //通知消费者消费数据
                s.notify();
                s.flag = true;
            }
        }
//        while (true){
//            lock.lock();
//            //先看看数据有没有被消费
//            if (i % 2 == 0){
//                s.name = "王宇";
//                s.age = 18;
//            }else{
//                s.name = "张保桂";
//                s.age = 19;
//            }
//            //通知消费者来消费数据
//            i++;
//            lock.unlock();
//        }
    }
}

import java.util.concurrent.locks.Lock;

public class GetThread implements Runnable{
    private Student s;
    private Lock lock;

    GetThread(Student student){
        s = student;
    }

    GetThread(Student student,Lock lock){
        s = student;
        this.lock = lock;
    }

    @Override
    public void run() {
//        Student s = new Student();
        while (true){
            synchronized(s){
                //判断学生对象的成员变量是否有值
                //如果flag的值是true，表示可以进行取值，反之，等待生产者生产数据
                if (!s.flag){
                    try {
                        s.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(s.name+"---"+s.age);

                //消费者消费完数据后，通知生产者生产数据
                s.notify();
                s.flag = false;
            }
        }
//        while (true){
//            lock.lock();
//            //先看看数据有没有存在
//            System.out.println(s.name+"---"+s.age);
//            //通知生产者去生产数据
//            lock.unlock();
//        }
    }
}

public class Student {
    String name;
    int age;
    boolean flag;
}

二、死锁

1、定义：

死锁：
  指的是两个或者两个以上的线程在执行的过程中，因争夺资源产生的一种互相等待的现象

2、举例：

中国人和美国人吃饭的案例
  假设中国人吃饭的时候，必须要有两根筷子才能吃饭
  美国人吃饭的时候，必须要有一把刀和一把叉才能吃饭

  正常情况下：
    中国人：两根筷子
    美国人：一把刀，一把叉

  发生死锁的情况：
    中国人：一根筷子，一把刀
    美国人：一根筷子，一把叉

死锁的现象更容易出现在同步嵌套情况下，所以今后开发的时候，尽量避免同步嵌套

3、代码

public class DieLockDemo {
    public static void main(String[] args) {
        //创建两个线程对象
        DieLock d1 = new DieLock(true);
        DieLock d2 = new DieLock(false);

        //启动线程
        d1.start();
        d2.start();
    }
}

public class DieLock extends Thread{
    private boolean flag;

    public DieLock(boolean flag){
        this.flag = flag;
    }
    /**
     *   现象1：
     *     if lock1
     *     else lock2
     *
     *   现象2：
     *     else lock2
     *     if lock1
     */
    @Override
    public void run() {
        if (flag){
            synchronized(MyLock.lock1){
                System.out.println("if lock1");
                synchronized(MyLock.lock2){
                    System.out.println("if lock2");
                }
            }
        }else{
            synchronized(MyLock.lock2){
                System.out.println("else lock2");
                synchronized(MyLock.lock1){
                    System.out.println("else lock1");
                }
            }
        }
    }
}

三、线程同步

1、同步安全解法一：synchronized关键字

1、线程同步的好处

解决了多线程的安全问题

2、线程同步的弊端

加了一个同代码块后，就相当于加了一把锁，每次进入同步代码块的时候都会去判断一下
无形之中，降低了我们执行效率

3、代码

public class SellTicketDemo1 {
    public static void main(String[] args) {
        TicketWindow1 ticketWindow1 = new TicketWindow1();

        //使用Thread类创建多个线程对象
        Thread window1 = new Thread(ticketWindow1);
        Thread window2 = new Thread(ticketWindow1);
        Thread window3 = new Thread(ticketWindow1);

        //给线程起名字
        window1.setName("窗口1");
        window2.setName("窗口2");
        window3.setName("窗口3");

        //启动线程
        window1.start();
        window2.start();
        window3.start();
    }
}

public class TicketWindow1 implements Runnable{
    private int tickets = 100;

    private Object object = new Object();

    @Override
    public void run() {
        while(true){
            synchronized(object){
                if (tickets>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"正在出售第"+(tickets--)+"张票");
                }
            }
        }
    }
}

2、synchronized改进

1、同步代码块上的锁对象是什么呢？
  任意对象，但是需要注意的是，多个线程之间的锁对象要一样

2、同步方法呢？
  将synchronized关键字放在方法的定义上
  同步方法的锁对象是this

3、静态的同步代码块的锁对象是谁呢？
  class文件对象，是线程类的字节码文件对象，其他的字节码文件对象不行

public class SellTicketDemo2 {
    public static void main(String[] args) {
        TicketWindow2 ticketWindow1 = new TicketWindow2();

        //使用Thread类创建多个线程对象
        Thread window1 = new Thread(ticketWindow1);
        Thread window2 = new Thread(ticketWindow1);
        Thread window3 = new Thread(ticketWindow1);

        //给线程起名字
        window1.setName("窗口1");
        window2.setName("窗口1");
        window3.setName("窗口1");

        //启动线程
        window1.start();
        window2.start();
        window3.start();

//        Hashtable<String,String> stringStringHashtable = new Hashtable<>();
    }
}

public class TicketWindow2 implements Runnable{
//    private int tickets = 100;
    private static int tickets = 100;

    private Object object = new Object();
    private Demo demo = new Demo();

    int i = 0;

    @Override
    public void run() {
//        while(true){
//            synchronized(demo){
//                if(tickets>0){
//                    try {
//                        Thread.sleep(100);
//                    } catch (InterruptedException e) {
//                        e.printStackTrace();
//                    }
//                    System.out.println(Thread.currentThread().getName()+"正在出售第"+(tickets--)+"张票");
//                }
//            }
//        }
        while(true){
            if(i % 2 == 0){
                synchronized(TicketWindow2.class){
                    if (tickets > 0){
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+"正在出售第"+(tickets--)+"张票");
                    }
                }
            }else{
                sellTickets();
            }
            i++;
        }
    }
    //同步方法
//    public synchronized void sellTickets(){
//        if (tickets>0){
//            try {
//                Thread.sleep(100);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//            System.out.println(Thread.currentThread().getName()+"正在出售第"+(tickets--)+"张票");
//        }
//    }
    //静态同步方法
    public synchronized static void sellTickets(){
        if(tickets>0){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"正在出售第"+(tickets--)+"张票");
        }
    }
}
class Demo{

}

3、解决同步安全问题第二种解法:加lock锁

在此之前我们解决同步线程安全的时候，都是使用synchronized关键字，通过一顿分析后，将需要被包裹的代码给包起来，但是呢我们并没有
实际看到在哪里上了锁，又或是在哪里释放了锁，让其他线程获取到锁对象，执行线程。

Lock(接口)
  具体的子类：Class ReentrantLock
    lock()加锁
    unlock()释放锁

public class SellTicketDemo3 {
    public static void main(String[] args) {
        TicketWindow3 ticketWindow1 = new TicketWindow3();

        //使用Thread类创建多个线程对象
        Thread window1 = new Thread(ticketWindow1);
        Thread window2 = new Thread(ticketWindow1);
        Thread window3 = new Thread(ticketWindow1);

        //给线程起名字
        window1.setName("窗口1");
        window2.setName("窗口2");
        window3.setName("窗口3");

        //启动线程
        window1.start();
        window2.start();
        window3.start();

//        Hashtable<String,String> stringStringHashtable = new Hashtable<>();
    }
}

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class TicketWindow3 implements Runnable{
    private int tickets = 100;

    private Object object = new Object();
    //创建锁对象
    private Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true){
            lock.lock();
            if (tickets>0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"正在出售第"+(tickets--)+"张票");
            }
            lock.unlock();
        }
    }
}

4、线程安全的类

import java.util.*;

/*
    回忆下到目前为止，我们学习哪些线程安全的类

 */
public class ThreadDemo {
    public static void main(String[] args) {
        //StringBuffer
        StringBuffer sb = new StringBuffer();
        //Vector
        Vector<String> strings = new Vector<>();
        //Hashtable
        Hashtable<String,String> stringStringHashtable = new Hashtable<>();

        //虽然Vector这个类是线程安全的，但是今后我们也不用
        //Collections工具类将线程不安全的集合转成线程安全的
        ArrayList<String> strings1 = new ArrayList<>();
        List<String> strings2 = Collections.synchronizedList(strings1);
    }
}

5、匿名内部类的形式创建线程对象

/*
    匿名内部类的形式创建线程对象
 */
public class ThreadDemo2 {
    public static void main(String[] args) {
        //1、继承Thread类，重写run方法，start()启动线程
        new Thread("王宇"){
            @Override
            public void run() {
                for(int i = 1;i<=200;i++){
                    System.out.println(Thread.currentThread().getName()+":"+i);
                }
            }
        }.start();

        //2、实现Runnable接口，实现run方法
        new Thread(new Runnable(){
            @Override
            public void run() {
                for (int i =1;i <= 200;i++){
                    System.out.println(Thread.currentThread().getName()+":"+i);
                }
            }
        },"小虎").start();
    }
}

四、线程组

1、线程组

java中使用ThreadGroup来表示线程组，它可以对一批线程进行分类管理，Java允许程序直接对线程组进行控制

public class ThreadGroupDemo {
    public static void main(String[] args) {
        //创建自定义对象
        MyRunnable myRunnable = new MyRunnable();

        //通过Thread类创建的多个线程对象
        Thread t1 = new Thread(myRunnable, "王宇");
        Thread t2 = new Thread(myRunnable, "张保桂");

        //默认情况下，所有的线程都属于主线程组
        //public final ThreadGroup geThreadGroup();
        ThreadGroup tg1 =t1.getThreadGroup();
        System.out.println(tg1);
        ThreadGroup tg2 = t2.getThreadGroup();
        System.out.println(tg2);

        //如何获取线程组的名字
        //public final String getName()返回此线程组的名称
        String s1 = tg1.getName();
        String s2 = tg2.getName();
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s1.equals(s2));

        //需求：给线程分组
        //Thread(ThreadGroup group,Runnable target,String name)
        //分配一个新的Thread对象，使其具有target作为其运行对象，具有指定的name作为其名称，属于group引用的线程组
        //创建一个新的线程组
        //ThreadGroup(String name)
        //构造一个新的线程组
        ThreadGroup tg3 = new ThreadGroup("帅哥组");

        //创建线程对象并分组
        Thread t3 = new Thread(tg3, myRunnable, "李雨阳");
        Thread t4 = new Thread(tg3, myRunnable, "小虎");
        Thread t5 = new Thread(tg3, myRunnable, "刘志成");

        //获取到目前位置所有线程的名字以及所属线程组的名字
        System.out.println(t1.getName()+"属于线程组："+t1.getThreadGroup().getName());
        System.out.println(t2.getName()+"属于线程组："+t2.getThreadGroup().getName());
        System.out.println(t3.getName()+"属于线程组："+t3.getThreadGroup().getName());
        System.out.println(t4.getName()+"属于线程组："+t4.getThreadGroup().getName());
        System.out.println(t5.getName()+"属于线程组："+t5.getThreadGroup().getName());

        //java允许程序直接对线程组进行控制
        //需求：将一个组内的所有线程设置为守护线程
        //直接通过组名进行设置，组里面的线程都是属于守护线程
        tg3.setDaemon(true);
    }
}

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0;i<=200;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

五、线程池

1、线程池

程序启动一个新的线程成本是比较高的，因为它涉及到要与操作系统进行交互
而使用线程池可以很好的提高性能，尤其是当程序中要创建大量生存期很短的线程时，更应该考虑线程池
线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用
在JDk5之前，我们必须手动实现自己的线程池，从JDK5开始，Java内置支持线程池

2、如何使用代码实现线程池呢？

1、创建线程池对象，Executors工厂类下有很多获取线程池的静态方法
  newFixedThreadPool是其中的一种线程池
  public static ExecutorService newFixedThreadPool(int nThreads)
2、如何在线程池中放线程呢？（可以存放哪些线程呢？）
3、在线程池中的线程如何去运行呢？
4、我想结束线程的运行，可不可以手动结束呢？如果可以，怎么结束？

public class ThreadPoolDemo {
    public static void main(String[] args) {
        //创建线程池对象
        ExecutorService pool = Executors.newFixedThreadPool(2);

        //Future<?> submit(Runnable task)
        //提交一个可运行的任务执行，并返回一个表示该任务的未来
        //提交即运行
        MyRunnable myRunnable = new MyRunnable();
        pool.submit(myRunnable);//底层封装成了一个线程对象并启动执行
        pool.submit(myRunnable);
        //提交的线程数超过线程池的数量也会执行，只不过是当有空闲线程位置的时候再去执行
        pool.submit(myRunnable);

        //我想结束线程的运行，可不可以手动结束呢？如果可以，怎么结束？
        //void shutdown()
        //启动有序关闭，其中先前提交的任务将被执行，但不会接受任何新任务
        pool.shutdown();

        //RejectedExecutionException
        //线程池已经被关闭了，不能再继续提交任务
        pool.submit(myRunnable);
    }
}

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0;i<=200;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

六、实现多线程的第三种方式

自定义类实现Callable接口，实现call方法，该线程的启动必须与线程池结合，单独无法创建线程对象启动

<T> Future<T> submit(Callable<T> task)
提交值返回任务可以执行，并返回代表任务待处理结果的Future

public class ThreadPoolDemo2 {
    public static void main(String[] args) {
        //创建线程池对象
        ExecutorService pool = Executors.newFixedThreadPool(2);

        //创建自定义Callable对象
        MyCallable myCallable = new MyCallable();

        //提交到线程池中执行
        pool.submit(myCallable);

        //手动停止线程池
        pool.shutdown();
    }
}

import java.util.concurrent.Callable;

public class MyCallable implements Callable {
    @Override
    public Object call() throws Exception {
        Object o = new Object();

        for(int i = 1;i <= 200;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
        return o;
    }
}

七、定时器

1、Demo1

定时器是一个应用十分广泛的线程工具，可用于调度多个定时任务以后台线程的方式执行
在Java中，可以通过Timer和TimerTask类来实现定义调度的功能

如何实现创建定时器呢？
  Java提供了一个类给我们使用实现定时器：Timer

import java.util.Timer;
import java.util.TimerTask;

public class TimerDemo {
    public static void main(String[] args) {
        //创建定时器对象
        //Timer
        //创建一个新的计时器
        Timer timer = new Timer();

        //调度任务执行
        //void schedule(TimerTask task,long delay)
        //在指定的延迟之后安排指定的任务执行
        timer.schedule(new MyTask(timer),3000);

//        timer.cancel();
//        timer.schedule(new MyTask(timer),3000);//IllegalStateException
    }
}
class MyTask extends TimerTask {
    private Timer timer;
    public MyTask(Timer timer){
        this.timer = timer;
    }

    @Override
    public void run() {
        System.out.println("beng!!!!!爆炸了");
        timer.cancel();
    }
}

2、Demo2

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Timer;
import java.util.TimerTask;

public class TimerDemo2 {
    public static void main(String[] args) {
        //创建定时器对象
        Timer timer = new Timer();

        //void schedule(TimerTask task,long delay,long period)
        //在指定的延迟之后开始，重新执行，固定延迟执行的指定任务
        //3秒后执行任务，并且之后每隔两秒执行一次
        timer.schedule(new MyTask2(),3000,2000);
    }
}

class MyTask2 extends TimerTask {
    @Override
    public void run() {
        try {
            FileReader fr = new FileReader("ss.txt");
            BufferedReader br = new BufferedReader(fr);
            String s = br.readLine();
            System.out.println(s);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

这篇关于javaDay25的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！