Java--线程

最新推荐文章于 2024-09-21 10:38:43 发布
最新推荐文章于 2024-09-21 10:38:43 发布
阅读量105 收藏
点赞数 1
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45806995/article/details/105473727
版权

一、并发与并行

  • 并发：指两个或多个事件在同一时间段内发生。
  • 并行：指两个或多个事件在同一时刻发生（同时发生）。

Notice：
单核处理器的计算机肯定是不能并行的处理多个任务的，只能是多个任务在单个CPU上并发运行。同理，线程也是一样的，从宏观角度上理解线程是并行运行的，但是从微观角度上分析却是串行运行的，即一个线程一个线程的去运行，但、当系统只有一个CPU时，线程会以某种顺序执行多个线程，我们把这种情况称之为线程调度。

二、线程与进程

  • 进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
  • 线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

简而言之，一个程序运行后至少有一个线程，一个进程中可以包含多个线程。

多线程的好处：

  1. 效率高
  2. 多个线程之间互不影响

线程调度：

  • 分时调度：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间；
  • 抢占式调度：优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个（线程随机性），Java使用的为抢占式调度。

三、Thread类中有关线程的方法

构造方法：

  • public Thread()：分配一个新的线程对象。
  • public Thread(String name)：分配新的 Thread 对象。
  • public Thread(Runnable target):分配一个带有指定目标新的线程对象。
  • public Thread(Runnable target，String name):分配一个带有指定目标的线程对象并指定名字。

常用方法：

  • public String getName():获取当前线程名称。

  • public void start():导致此线程开始执行；Java虚拟机调用此线程的run方法。

  • public void run():此线程要执行的任务在此处定义代码。

  • public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停，毫秒数结束之后，线程继续执行。

  • public static Thread currentThread():返回对当前正在执行的线程对象的引用。

四、创建线程类

Java使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或是其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段程序执行的代码，Java使用线程执行体来表示这段程序流。

单线程程序：java程序中只有一个线程，执行从main方法开始，从上到下依次执行。

主线程：执行主(main)方法的线程。

JVM执行main方法，main方法会进入到栈内存，JVM会找操作系统开辟一条main方法通向CPU的执行路径，CPU就可以通过这个路径来执行main方法，而这个路径有一个名字，叫主线程。

1.创建线程的第一种方式：创建Tread类的子类。

Java中通过继承Thread类来创建并启动多线程的步骤如下：

  • 定义Tread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程需要完成的任务，因此把run方法称为线程执行体；
  • 创建Thread子类的实例，即创建了线程对象；
  • 调用线程对象的start方法来启动线程，执行run方法。

void start()使该线程开始执行；Java虚拟机调用该线程的run方法。
结果是两个线程并发的运行；当前线程(main线程)和另一个线程(创建的新线程，执行其run方法)。
多次启动一个线程使非法的。特别是当线程已经结束后，不能再重新启动。

获取线程的名称：

  • 使用Thread类种的方法getName()
    String getName()返回该线程的名称；
  • 可以先获取当前正在执行的线程，使用线程中的方法getName()获取线程名称
    start Thread currentThread()返回对当前正在执行的线程对象的引用。

设置线程名称：

  • 使用Thread类中的方法setName(名字)
    void setName(String name) 改变线程名称，使之与参数name相同。
  • 创建一个带参数的构造方法，参数传递线程的名称；调用父类的带参构造方法，将线程名称传递给父类，让父类(Thread)给线程起名
    Thread(String name)：分配新的 Thread 对象。

2.创建线程的第一种方式：实现Runnable接口
java.lang.Runnable接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。

实现步骤：
1.创建一个Runnable接口的实现类；
2.在实现类中重写Runnable接口的run方法，设置线程任务；
3.创建一个Runnable接口的实现类对象；
4.创建Thread类对象，构造方法中传递Runnable接口的实现类对象；
5.调用Thread类中的start方法，开启的新线程执行run方法。

public class RunnableImpl implements java.lang.Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}
public class Demo06Runnable {
    public static void main(String[] args) {
        RunnableImpl run = new RunnableImpl();

        Thread t = new Thread(run);
        t.start();

        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

实现Runnable接口比继承Thread类所具有的优势：

  1. 适合多个相同的程序代码的线程去共享同一个资源。
  2. 可以避免Java中的单继承的局限性。
  3. 增加了程序的健壮性，实现解耦操作（实现Runnable接口的方式，把设置线程任务和开启新线程进行分离），代码可以被多个线程共享，代码和线程独立。
    实现类中，重写了run方法，用来设置线程任务。
    创建Thread类对象，调用start方法：用来开启新线程。
  4. 线程池只能放入实现Runnable或Callable类线程，不能直接放入继承Thread的类。

扩充：在Java中，每次程序运行至少启动两个线程，一个使main线程，一个是垃圾收集线程。因为每当使用Java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM其实就是操作系统中启动一个进程。

五、匿名内部类的方式实现线程的创建

1.匿名内部类的作用：简化代码。
把子类继承父类、重写父类的方法、创建子类对象合一步完成
把实现类实现接口、重写接口中的方法、创建实现类对象合一步完成

2.匿名内部类的最终产物：子类/实现类对象，这个类没有名字

3.使用格式：

new 父类/接口() {
        重写父类/接口中的方法;
};

eg:

public class Demo07InnerClassThread {
    public static void main(String[] args) {
        new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName() + "-->" + i);
                }
            }
        }.start();

        //线程的接口Runnable
        Runnable r = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName() + "-->" + i);
                }
            }
        };
        new Thread(r).start();

        //简化接口的方式
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName() + "-->" + i);
                }
            }
        }).start();
    }
}

六、线程同步

当我们使用多线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。要解决多线程并发访问一个资源的安全性问题，Java中提供了同步机制（synchronized）来解决。

也就是说在某个线程修改共享资源时，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU资源，完成对应操作，保证了数据的同步性，解决了线程不安全的现象。

为了保证每个线程都能正常执行原子操作，Java引入了线程同步机制。
完成同步机制的三种方式：

1.同步代码块

同步代码块：synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。格式:

synchronized(锁对象) {
    可能出现线程安全问题的代码(访问了共享数据的代码)
}

同步锁（对象锁）：对象的同步锁只是一个概念，可以想象为在对象上标记了一个锁。

  1. 锁对象可以是任意类型
  2. 保证多个线程使用的对象是同一个

Notice：
在任何时候，最多允许一个线程拥有同步锁，谁拿到锁就进入代码块，其他的线程只能在外面等着（BLOCKED）。

同步保证了只能有一个线程在同步中执行共享数据，保证了安全，但程序频繁的判断锁、获取锁、释放锁，程序的效率会降低。

2.同步方法

同步方法：使用synchronized修饰的方法，就叫做同步方法，保证A线程执行该方法的时候，其他线程只能在方法外等着。

使用步骤：
1.把访问了共享数据的代码抽取出来，放到一个方法中
2.在方法上添加synchronized修饰符

格式：

修饰符 synchronized 返回值类型 方法名(参数列表) {
    可能出现线程安全问题的代码(访问了共享数据的代码)
}

同步方法也会把方法内部的代码锁住，只让一个线程执行。同步方法的锁对象就是实现类对象，也就是this。

同步锁是谁？
对于非static方法，同步锁就是this；
对于static方法，我们使用当前方法所在类的字节码对象（类名.class）。

3.锁机制

java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更为广泛的锁定操作，同步代码块/同步方法具有的功能Lock都有，除此之外更强大，更体现面向对象。
Lock锁也称同步锁，加锁与释放锁方法化了，如下：

  • public void lock():加同步锁。
  • public void unlock():释放同步锁。

七、线程状态

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态，在线程的生命周期中，有以下六种状态：

线程状态导致状态发生的条件
NEW（新建）线程刚被创建，但是并未启动。还没调用start方法。
Runnable（可运行）线程可以在Java虚拟机中云运行的状态，可能正在运行自己的代码，也可能没有，这取决于操作系统处理器。
Blocked（锁阻塞）当一个线程试图获取一个锁对象，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
Waiting（无限等待）一个线程等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后不是自动能唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
Timed Waiting（计时等待）同Waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Tread.sleep、Object.wait。
Teminated（被终止）因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

这几种状态的关系如下图：

在这里插入图片描述

阻塞状态：具有CPU的执行资格，等待CPU空闲时执行；
休眠状态：放弃COU的执行资格，CPU空闲，也不执行。

下面我们来研究一下线程从Runnable状态与非运行状态之间的转换问题。

1.Timed Waiting（计时等待）

Timed Waiting在API中的描述为：等待另一个线程来执行取决于指定等待时间的操作的线程处于这种状态。光看这句话，真的是一脸懵逼，我们通过一个案例来理解这一状态叭。

进入到TimedWaiting有两种方式：

  1. 使用sleep(long m)方法，在毫秒值结束之后，线程睡醒进入到Runnable/Blocked状态；
  2. 使用wait(long m)方法，wait方法如果在毫秒值结束之后，还没有被notify唤醒，就会自动醒来。

唤醒的方法：

  1. void notify():唤醒在此对象监视器上等待的单个线程。随即唤醒一个。
  2. void notifyAll():唤醒在此对象监视器上等待的所有线程。
/*
实现一个计算器，计数到100，在每个数字之间暂停一秒，每隔10个数字输出一个字符串。
*/
public class CounterThread extends Thread{
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 10 == 0) {
                System.out.println("---------" + i);
            }
            System.out.println(i);
            try {
            //使用sleep方法让程序睡眠一秒
                Thread.sleep(1000);
                System.out.println("      线程睡眠1秒");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        new CounterThread().start();
    }
}

public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停，毫秒数结束之后，线程继续执行。

在run方法中添加sleep语句，这样就强制当前正在执行的线程休眠（暂停执行），以“减慢线程”。
其实当我们调用了sleep方法后，当前执行的线程就进入到“休眠状态”，其实就是所谓的Timed Waiting（计时等待）。

Remember：

  1. 进入TIME_WAITING状态的一种常见情形时调用sleep方法，单独的线程也可以调用，不一定非要有协作关系。
  2. 为了让其他线程有机会执行，可以将Thread.sleep()的调用放在线程之内，这样才能保证该线程执行过程中会睡眠。
  3. sleep与锁无关，线程睡眠到期自动苏醒，并返回Runnable（可运行）状态。

Tip：
sleep()中指定的时间是线程不会运行的最短时间。因此，sleep()方法不能保证该线程到期后就开始立刻执行。

Timed Waiting线程状态图：
在这里插入图片描述

2.BLOCKED（锁阻塞）

BLOCKED在API中的描述为：受阻塞并等待某个监视器锁的线程处于这种状态。 比如：线程A与线程B代码中使用同一锁，如果线程A获取到锁，线程A进入到Runnable状态，那么线程B就进入到Blocked锁阻塞状态。除此之外Waiting以及Timed Waiting状态也会在某种情况下进入阻塞状态。

Blocked的线程状态图：

在这里插入图片描述

3.Waiting（无限等待）

Waiting状态在API中的描述为：无限期地等待另一个线程来执行某一特定操作的线程处于这种状态。
我们通过一个代码来学习一下：

/*
等待唤醒案例：线程之间的通信
创建一个顾客线程（消费者）：告知老板要的包子的种类和数量，调用wait方法，放弃CPU的执行，进入到WAITING状态
创建一个老板线程（生产者）：花了5秒做包子，做好包子后，调用notify，唤醒顾客吃包子

Notice：
顾客和老板线程必须使用同步代码块包裹起来，保证等待和唤醒只能有一个在执行
同步使用的锁对象必须保证唯一
只有锁对象才能调用wait和notify方法

Object类中的方法：
 void wait()：在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。
 void notify()：唤醒在此对象监视器上等待的单个线程。会继续执行wait方法之后的代码
 */
public class DemoWaitNotify {
    public static void main(String[] args) {
        //创建锁对象，保证唯一
        Object obj = new Object();

        //创建一个顾客线程,使用匿名内部类
        new Thread() {
            @Override
            public void run() {
                //一直等着买包子
                while (true) {
                    //保证等待和唤醒只能有一个在执行,需要使用同步技术
                    synchronized (obj) {
                        System.out.println("告知老板要的包子的种类和数量");
                        //调用wait方法，放弃CPU的执行，进入到WAITING状态
                        try {
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //唤醒之后执行的代码
                        System.out.println("包子已经做好了，我要开动了！");
                        System.out.println("==========================");
                    }
                }
            }
        }.start();

        //创建一个老板线程
        new Thread() {
            @Override
            public void run() {
                //一直做包子
                while (true) {
                    try {
                        sleep(5000);//花五秒做包子
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (obj) {
                        System.out.println("老板5秒钟之后做好包子，告知顾客可以吃了");
                        //做好包子后，调用notify，唤醒顾客吃包子
                        obj.notify();
                    }
                }
            }
        }.start();
    }
}

八、等待唤醒机制

1.线程间的通信

概念：多个线程在处理同一个资源，但是处理的动作（线程的任务）却不同。
比如：线程A用来生产包子，线程B用来吃包子，包子可以理解为同一资源，线程A与线程B处理的动作，一个是生产，一个是消费，那么线程A与线程B之间就存在线程通信问题。

为什么要处理线程间通信：
多个线程并发执行时，在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行，那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数据。

如何保证线程间通信有效利用资源：
多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。就是多个线程在操作同一份数据时，避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源。而这种手段即——等待线程唤醒。

2.等待线程唤醒机制

什么是等待线程唤醒机制
这是多个线程间的一种协作机制。谈到线程我们经常想到的使线程间的竞争（race），比如去争夺锁，但这并不是故事的全部，线程间也会有协作机制。就像人和人之间既有竞争又有合作。

就是在一个线程进行了规定操作之后，就进入等待状态（wait（）），等待其他线程执行完他们的指定代码过后，再将其唤醒（notify（））；在有多个线程等待时，如果需要，可以使用notifyAll（）来唤醒所有的等待线程。
wait/notify就是线程间的一种协作机制。

等待唤醒中的方法：
等待唤醒机制就是用于解决线程间通信问题的，使用到的3个方法含义如下：

  1. wait：线程不再活动，不再参与调度，进入wait set中，因此不会浪费CPU资源，也不会去竞争锁了，这时的线程状态即是WAITING。它还要等着别的线程执行一个特别的动作，也就是“通知（notify）”在这个对象上等待的线程从wait set中释放出来，重新进入到调度队列（ready queue）中
  2. notify：则选取所通知对象的wait set中的一个线程释放；例如，餐馆有空座位后，等候就餐最久的顾客最先入座。
  3. notifyAll：则释放所通知对象的wait set上的全部线程。

Notice：
哪怕只通知一个等待的线程，被告知线程也不能立即恢复执行，因为它中断的地方是在同步块内，而此刻它已经不持有锁，所以它需要再次尝试去获取锁（很可能面临其他线程的竞争），成功后才能在当初调用wait方法之后的地方恢复执行。

总结：
1.如果能获取锁，线程就从WAITING状态变成RUNNABLE状态；
2.否则，从wait set出来，又进入entry set，线程就从WAITING状态又变成BLOCKED状态。

调用wait和notify方法需要注意的细节：

  1. wait 方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
  2. wait方法与notify方法是属于Object类的方法。因为：锁对象可以是任意对象，而任意对象的所属类都继承了Object类的。
  3. wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这两个方法。
十三曦
关注
专栏目录
6-1 jmu-Java-07多线程-Thread (20分)
sddfnsff的博客
05-26 6034
编写MyThread类继承自Thread。创建MyThread类对象时可指定循环次数n。 功能：输出从0到n-1的整数。 并在最后使用System.out.println(Thread.currentThread().getName()+" "+isAlive())打印标识信息 裁判测试程序： import java.util.Scanner; /这里放置你的答案，即MyThread类的代码/ public class Main { public static void main(String[] args
6-2 jmu-Java-07多线程-交替执行 (25分)
sddfnsff的博客
06-04 3828
有一连串任务，需要两个线程交替执行。线程1执行完任务1后，线程2才能执行任务2，接下来线程1执行任务1，如此交替执行下去。直到所有任务执行完毕。 定义Repo类代表任务仓库，使用字符串代表任务。该类拥有： 构造函数: /将传递进来的字符串以空格分隔分解为多个不同的任务，并存储起来。如"1 2 3 4 5 6"被分解成6个任务1,2,3,4,5,6/ public Repo(String items) { } 方法： int getSize(); //返回Repo包含的任务数量。注意：完成任务的时候，需要将
VBB、VCC、VDD、VEE、VPP 、VSS 的解释
热门推荐
云淡风轻的博客
10-16 2万+
电路设计以及PCB制作中，经常碰见电源符号：VCC、 VDD、VEE、VSS，他们具有什么样的关系那? 　　一、解释 　　VCC：C=circuit 表示电路的意思, 即接入电路的电压 　　VDD：D=device 表示器件的意思, 即器件内部的工作电压; 　　VSS：S=series 表示公共连接的意思，通常指电路公共接地端电压 　　二、说明 　　1、对于数字电路来说，VCC是电路的供电电压,V
013jmu-Java-07多线程-PrintTask
ihopeyousuccess的博客
11-30 4745
编写PrintTask类实现Runnable接口。 功能：输出从0到n-1的整数(n在创建PrintTask对象的时候指定)。并在最后使用System.out.println(Thread.currentThread().getName());输出标识信息。 裁判测试程序： import java.util.Scanner; /这里放置你的答案，即PrintTask类的代码/ public class Main { public static void main(String[] args) { Scann
java---线程安全详解
m0_58196614的博客
08-10 4407
线程安全是指某个方法或某段代码，在多线程中能够正确的执行，不会出现数据不一致或数据污染的情况，我们把这样的程序称之为线程安全的，反之则为非线程安全的。
6-6 jmu-Java-07多线程-同步访问 (10 分)
m0_54524462的博客
12-02 3292
6-6 jmu-Java-07多线程-同步访问 (10 分) 现已有Account类，拥有 属性: private int balance 方法: 相应的getter方法。 要求为该类编写： void deposit(int money) //存钱，在余额的基础上加上money void withdraw(int money) //取钱，在余额的基础上减去money 注意： 取钱时如果balance<0的时候，会抛出异常。在多线程情况下，如只有一个存钱的线程，但是有多个取钱的线程，很可能会抛出异常。
jmu-Java-07多线程-Runnable与匿名类
qq_hua_xia的博客
10-27 1203
题目详情： 6-1 jmu-Java-07多线程-Runnable与匿名类 (10 分) 在Main方法中启动一个线程t1，该线程输出3行信息： 主线程名 线程t1的线程名 线程t1所实现的所有接口。提示：使用System.out.println(Arrays.toString(getClass().getInterfaces()));输出。 注：本题也可使用Lambda表达式实现。 裁判测试程序： public class Main { public static void
Java多线程-----定时器（Timer）及其实现
2302_79862386的博客
08-03 1873
Java多线程-----定时器（Timer）及其实现
java--线程池
别浪
04-21 1793
2 为什么要使用线程池 1创建线程问题 反复创建线程开销大 过多的线程会占用大多内存 2解决上面两个问题思路： 用少量线程-避免内存占用过多 让这部分线程都保持工作，且可以反复执行任务-避免生命周期的损耗 3线程池的好处 加快响应速度 合理利用CPU和内存 统一归管理资源 4线程池适合应用场景 服务器接收大量请求时，使用线程池 是非常合适的，他可以大大减少线程池的创建和销毁次数，提高服务器的工作效率 实际开发中，如果需要创建5个以上的线程，那么就可以使用线程池
观测线程状态-java
前后端分离，人不分离！
10-18 1109
线程状态，即线程生命周期。
Java-Thread-Affinity,将Java线程绑定到给定的内核.zip
09-25
Java线程亲和性（Thread Affinity）是一个高级并发编程概念，主要涉及到操作系统调度和硬件资源的优化。在多核处理器系统中，线程亲和性允许开发者指定某个线程应该运行在哪个特定的处理器核心上，从而提高性能、...
JAVA线程高级-线程按序交替执行
11-01
在Java编程中，多线程是并发编程的重要组成部分，它允许程序同时执行多个任务，从而提高了系统的效率和响应性。然而，在某些场景下，我们可能需要控制线程的执行顺序，确保它们按照特定的顺序交替运行，这在并发编程...
Java-并发-Java线程中断与停止线程详解
12-22
  Java 中的线程中断是一种线程间的协作模式，通过设置线程的中断标志并不能直接终止该线程的执行，而是被中断的线程根据中断状态自行处理。即“线程中断”并不是字面意思——线程真的中断了，而是设置了中断标志...
Java企业面试题3
m0_74972727的博客
09-15 909
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
Arthas sysenv（查看JVM的环境变量）
最新发布
刘大猫
09-21 254
Arthas sysenv（查看JVM的环境变量）
JDK17新增语法特性
2201_76124988的博客
09-20 531
从springboot3.0开始，已经不支持JDK8，转变为JDK17参考资料：官方博客。
faiss安装 （CPU版本）
CSDN_WHB的博客
09-20 186
faiss版本 faiss-v1.7.4。
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
weixin_43860634的博客
09-14 944
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
面试突击-多线程和IO专题(至尊典藏版)
人生若只初相见@的博客
09-18 1615
金九银十多线程和IO大厂面试专题
Java基础：进程与线程详解-多线程并发实践
进程和线程是计算机操作系统中的两个核心概念，对于Java程序员而言，理解和掌握它们是基础中的基石。本文将深入解析这两个概念，并通过实际的Java编程示例来说明它们的应用。 **进程**： 进程是操作系统中一个正在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值