JAVA 多线程编程

最新推荐文章于 2024-07-29 14:22:26 发布
最新推荐文章于 2024-07-29 14:22:26 发布
阅读量141 收藏 1
点赞数 4
分类专栏： JAVA基础 文章标签： 多线程 java
JWei_7
本文链接：https://blog.csdn.net/qq_54729417/article/details/118065043
版权

JAVA 多线程编程


Java 多线程编程
Java 给多线程编程提供了内置的支持。 一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。

这里定义和线程相关的另一个术语 - 进程：一个进程包括由操作系统分配的内存空间，包含一个或多个线程。一个线程不能独立的存在，它必须是进程的一部分。一个进程一直运行，直到所有的非守护线程都结束运行后才能结束。

多线程能满足程序员编写高效率的程序来达到充分利用 CPU 的目的。

一个线程的生命周期

线程是一个动态执行的过程，它也有一个从产生到死亡的过程。
如图：
在这里插入图片描述

- 新建状态:

使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。

- 就绪状态:

当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。

- 运行状态:

如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。

- 阻塞状态:

如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种：

等待阻塞：

运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。

同步阻塞：

线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。

其他阻塞：

通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。

死亡状态:

一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。

线程的优先级

每一个 Java 线程都有一个优先级，这样有助于操作系统确定线程的调度顺序。
打个比方就是 你在食堂打饭 要排队吧 不然 岂不是乱套 你要是先排队，有人插队 肯定会有很多人有意见

具有较高优先级的线程对程序更重要，并且应该在低优先级的线程之前分配处理器资源。但是，线程优先级不能保证线程执行的顺序，而且非常依赖于平台。

优先级取值范围

Java 线程优先级使用 1 ~ 10 的整数表示：

  • 最低优先级 1：Thread.MIN_PRIORITY
  • 最高优先级 10：Thread.MAX_PRIORITY
  • 普通优先级 5：Thread.NORM_PRIORITY

获取线程优先级

public static void main(String[] args) {
    System.out.println(Thread.currentThread().getPriority());//计算优先级
}

默认情况下，每一个线程都会分配一个优先级 NORM_PRIORITY（5）。
在这里插入图片描述

设置优先级

Java 使用 setPriority 方法设置线程优先级，方法签名

public final void setPriority(int newPriority)

示例：
在这里插入图片描述
注意：
newPriority 设置范围在 1-10，否则抛出 java.lang.IllegalArgumentException 异常
不多说 上图演示：

在这里插入图片描述

创建一个线程

Java 提供了三种创建线程的方法：

  • 通过实现 Runnable 接口；
  • 通过继承 Thread 类本身；
  • 通过 Callable 和 Future 创建线程；

通过实现 Runnable 接口来创建线程

创建一个线程，最简单的方法是创建一个实现 Runnable 接口的类。

为了实现 Runnable，一个类只需要执行一个方法调用 run()，声明如下：

public void run()

你可以重写该方法，重要的是理解的 run() 可以调用其他方法，使用其他类，并声明变量，就像主线程一样。

在创建一个实现 Runnable 接口的类之后，你可以在类中实例化一个线程对象。

Thread 定义了几个构造方法，下面的这个是我们经常使用的：

Thread(Runnable threadOb,String threadName);

这里，threadOb 是一个实现 Runnable 接口的类的实例，并且 threadName 指定新线程的名字。

新线程创建之后，你调用它的 start() 方法它才会运行。

void start();

样例：

class RunnableDemo implements Runnable {
    private Thread t;
    private String threadName;

    RunnableDemo( String name) {
        threadName = name;
        System.out.println("Creating " +  threadName );
    }

    public void run() {
        System.out.println("Running " +  threadName );
        try {
            for(int i = 4; i > 0; i--) {
                System.out.println("Thread: " + threadName + ", " + i);
                // 让线程睡眠一会
                Thread.sleep(50);
            }
        }catch (InterruptedException e) {
            System.out.println("Thread " +  threadName + " interrupted.");
        }
        System.out.println("Thread " +  threadName + " exiting.");
    }

    public void start () {
        System.out.println("Starting " +  threadName );
        if (t == null) {
            t = new Thread (this, threadName);
            t.start ();
        }
    }
}

public class test {
    public static void main(String[] args) {
        RunnableDemo R1 = new RunnableDemo( "Thread-1");
        R1.start();
        RunnableDemo R2 = new RunnableDemo( "Thread-2");
        R2.start();
    }
}

输出结果：

Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-2, 2
Thread: Thread-1, 2
Thread: Thread-2, 1
Thread: Thread-1, 1
Thread Thread-2 exiting.
Thread Thread-1 exiting.

通过继承Thread来创建线程

创建一个线程的第二种方法是创建一个新的类，该类继承 Thread 类，然后创建一个该类的实例。
继承类必须重写 run() 方法，该方法是新线程的入口点。它也必须调用 start() 方法才能执行。
该方法尽管被列为一种多线程实现方式，但是本质上也是实现了 Runnable 接口的一个实例。

class ThreadDemo extends Thread {
   private Thread t;
   private String threadName;
   
   ThreadDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // 让线程睡眠一会
            Thread.sleep(50);
         }
      }catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}
 
public class Test{
 
   public static void main(String args[]) {
      ThreadDemo T1 = new ThreadDemo( "Thread-1");
      T1.start();
      
      ThreadDemo T2 = new ThreadDemo( "Thread-2");
      T2.start();
   }   
}

结果：

Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.

Thread 方法
下表列出了Thread类的一些重要方法：

序号 方法描述

  • 1 public void start()

使该线程开始执行；Java 虚拟机调用该线程的 run 方法。

  • 2 public void run()

如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run
方法；否则，该方法不执行任何操作并返回。

  • 3 public final void setName(String name)

改变线程名称，使之与参数 name 相同。

  • 4 public final void setPriority(int priority)

更改线程的优先级。

  • 5 public final void setDaemon(boolean on)

将该线程标记为守护线程或用户线程。

  • 6 public final void join(long millisec)

等待该线程终止的时间最长为 millis 毫秒。

  • 7 public void interrupt()

中断线程。

  • 8 public final boolean isAlive()

测试线程是否处于活动状态。
上述方法是被Thread对象调用的。下面的方法是Thread类的静态方法。

序号 方法描述

  • 1 public static void yield()

暂停当前正在执行的线程对象，并执行其他线程。

  • 2 public static void sleep(long millisec)

在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。

  • 3 public static boolean holdsLock(Object x)

当且仅当当前线程在指定的对象上保持监视器锁时，才返回 true。

  • 4 public static Thread currentThread()

返回对当前正在执行的线程对象的引用。

  • 5 public static void dumpStack()

将当前线程的堆栈跟踪打印至标准错误流。

通过 Callable 和 Future 创建线程

  • 创建 Callable 接口的实现类，并实现 call() 方法，该 call() 方法将作为线程执行体，并且有返回值。

  • 创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。

  • 使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。

  • 调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值。

public class CallableThreadTest implements Callable<Integer> {
    public static void main(String[] args)  
    {  
        CallableThreadTest ctt = new CallableThreadTest();  
        FutureTask<Integer> ft = new FutureTask<>(ctt);  
        for(int i = 0;i < 50;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);  
            if(i==20)  
            {  
                new Thread(ft,"有返回值的线程").start();  
            }  
        }  
        try  
        {  
            System.out.println("子线程的返回值："+ft.get());  
        } catch (InterruptedException e)  
        {  
            e.printStackTrace();  
        } catch (ExecutionException e)  
        {  
            e.printStackTrace();  
        }  
  
    }
    @Override  
    public Integer call() throws Exception  
    {  
        int i = 0;  
        for(;i<50;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" "+i);  
        }  
        return i;  
    }  
}

来跑一下：
看结果

main 的循环变量i的值0
main 的循环变量i的值1
main 的循环变量i的值2
main 的循环变量i的值3
main 的循环变量i的值4
main 的循环变量i的值5
main 的循环变量i的值6
main 的循环变量i的值7
main 的循环变量i的值8
main 的循环变量i的值9
main 的循环变量i的值10
main 的循环变量i的值11
main 的循环变量i的值12
main 的循环变量i的值13
main 的循环变量i的值14
main 的循环变量i的值15
main 的循环变量i的值16
main 的循环变量i的值17
main 的循环变量i的值18
main 的循环变量i的值19
main 的循环变量i的值20
main 的循环变量i的值21
main 的循环变量i的值22
main 的循环变量i的值23
main 的循环变量i的值24
main 的循环变量i的值25
main 的循环变量i的值26
main 的循环变量i的值27
main 的循环变量i的值28
main 的循环变量i的值29
main 的循环变量i的值30
有返回值的线程 0
有返回值的线程 1
main 的循环变量i的值31
main 的循环变量i的值32
main 的循环变量i的值33
main 的循环变量i的值34
有返回值的线程 2
main 的循环变量i的值35
main 的循环变量i的值36
main 的循环变量i的值37
main 的循环变量i的值38
main 的循环变量i的值39
main 的循环变量i的值40
main 的循环变量i的值41
main 的循环变量i的值42
main 的循环变量i的值43
有返回值的线程 3
main 的循环变量i的值44
有返回值的线程 4
main 的循环变量i的值45
有返回值的线程 5
main 的循环变量i的值46
有返回值的线程 6
main 的循环变量i的值47
有返回值的线程 7
main 的循环变量i的值48
有返回值的线程 8
main 的循环变量i的值49
有返回值的线程 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

这个的话 其实改一下循环值 数据就会有不同，个人感觉 还是看cpu了，电脑性能不同 这个数据应该也不一样。

创建线程的三种方式的对比

采用实现Runnable、Callable接口的方式创见多线程时
优势是：

线程类只是实现了Runnable接口或Callable接口，还可以继承其他类。

在这种方式下，多个线程可以共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。

劣势是：

编程稍微复杂，如果要访问当前线程，则必须使用Thread.currentThread()方法。

使用继承Thread类的方式创建多线程时
优势是：

编写简单，如果需要访问当前线程，则无需使用Thread.currentThread()方法，直接使用this即可获得当前线程。

劣势是：
线程类已经继承了Thread类，所以不能再继承其他父类。

线程的几个主要概念

在多线程编程时，你需要了解以下几个概念：
下面 我们来浅谈一下：（因为我也没有特别深入的了解 希望暑假的时候 我在完善一下）

线程同步

因为我写的挺烂的 兄弟们可以看一下这个大佬的！

线程同步概念

当多线程并发，有多段代码同时执行时，我们希望某一段代码执行的过程中CPU不要切换到其它线程工作，这时就需要同步。如果两段代码是同步的，那么同一时间只会执行其中一个，这个结束之前另外一段代码就不会被执行。

这个就像上面的那个 T1.start();和T2.start();的那个 有印象的老哥应该还记得那个输出结果

线程同步作用

线程有可能和其他线程共享一些资源，比如，内存，文件，数据库等。

当多个线程同时读写同一份共享资源的时候，可能会引起冲突。这时候，我们需要引入线程“同步”机制，即各位线程之间要有个先来后到，不能一窝蜂挤上去抢作一团。

线程同步的真实意思和字面意思恰好相反。线程同步的真实意思，其实是“排队”：几个线程之间要排队，一个一个对共享资源进行操作，而不是同时进行操作。

线程同步方法

  • wait():使一个线程处于等待状态，并且释放所持有的对象的lock。
  • sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉 InterruptedException异常。
  • notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的
    唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。
  • notityAll ():唤醒所有处于等待状态的线程，注意并不是给所有唤醒线程一个对象的锁， 而是让它们竞争。

线程同步实现方法

同步方法
即有synchronized关键字修饰的方法。 
由于java的每个对象都有一个内置锁，当用此关键字修饰方法时， 
内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。

代码如：

 public synchronized void save(){}

注： synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类

同步代码块
即有synchronized关键字修饰的语句块。 
被该关键字修饰的语句块会自动被加上内置锁，从而实现同步

synchronized(object){ }

注：同步是一种高开销的操作，因此应该尽量减少同步的内容。 
通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。
使用特殊域变量(volatile)实现线程同步

volatile关键字为域变量的访问提供了一种免锁机制，
使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新，
因此每次使用该域就要重新计算，而不是使用寄存器中的值
volatile不会提供任何原子操作，它也不能用来修饰final类型的变量

//只给出要修改的代码，其余代码与上同
class Bank {
 
    //需要同步的变量加上volatile
    private volatile int account = 100;
 
    public int getAccount() {
        return account;
    }
 
    //这里不再需要synchronized 
    public void save(int money) {
        account += money;
    }
｝

线程间通信

为什么需要线程通信

  1. 多个线程并发执行时, 在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行,那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数据。
  2. 当然如果我们没有使用线程通信来使用多线程共同操作同一份数据的话，虽然可以实现，但是在很大程度会造成多线程之间对同一共享变量的争夺，那样的话势必为造成很多错误和损失！
  3. 所以，我们才引出了线程之间的通信，多线程之间的通信能够避免对同一共享变量的争夺。

什么是线程通信？

多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。

就是多个线程在操作同一份数据时， 避免对同一共享变量的争夺。

于是我们引出了等待唤醒机制：（wait()、notify()）

就是在一个线程进行了规定操作后，就进入等待状态（wait）， 等待其他线程执行完他们的指定代码过后 再将其唤醒（notify）；

其实说白了 就是 生产者和消费者模式

线程死锁

死锁概述

  • 线程死锁是指两个或两个以上的线程互相持有对方所需要的资源，由于synchronized的特性，一个线程持有一个资源，或者说获得一个锁，在该线程释放这个锁之前，其它线程是获取不到这个锁的，而且会一直死等下去，因此这便造成了死锁。

死锁产生的条件

  • 互斥条件：一个资源，或者说一个锁只能被一个线程所占用，当一个线程首先获取到这个锁之后，在该线程释放这个锁之前，其它线程均是无法获取到这个锁的。
  • 占有且等待：一个线程已经获取到一个锁，再获取另一个锁的过程中，即使获取不到也不会释放已经获得的锁。
  • 不可剥夺条件：任何一个线程都无法强制获取别的线程已经占有的锁
  • 循环等待条件：线程A拿着线程B的锁，线程B拿着线程A的锁。

线程控制：挂起、停止和恢复

这里只做一下简单的赘述

挂起和恢复

wait()与notify()方法

wait()方法同样可以使线程进行挂起操作，调用了wait()方法的线程进入了“非可执行”状态，使用wait()方法有两种方式，例如：

thread.wait(1000);
或：
thread.wait();
thread.notify();

其中第一种方式给定线程挂起时间，基本上与sleep()方法用法相同。第二种方式是wait()与notify()方法配合使用，这种方式让wait()方法无限等下去，直到线程接收到notify()或notifyAll()消息为止。

wait()、notify()、notifyAll()不同于其他线程方法，这3个方法是java.lang.Object类的一部分，所以在定义自己类时会继承下来。wait()、notify()、notifyAll()都被声明为final类，所以无法重新定义。

join()方法：

能够使当前执行的线程停下来等待，直至join()方法所调用的那个线程结束，再恢复执行。例如如果有一个线程A正在运行，用户希望插入一个线程B，并且要求线程B执行完毕，然后再继续线程A，此时可以使用join()方法来完成这个需求。

thread.suspend()和thread.resume()

使用 thread.suspend()方法暂停线程，使用 thread.resume()恢复暂停的线程 的特点。（这个现在好像已经淘汰了 因为会产生死锁）

sleep()方法

是一个使线程暂时停止一段执行时间的方法，该时间由给定的毫秒数决定。

class ThreadA extends Thread
{
	public void run(){
		System.out.println("ThreadA is running");
	}
}
 
public class TestNew {
	public static void main(String[] args)throws InterruptedException {
		// TODO Auto-generated method stub
		ThreadA ta = new ThreadA();
		ta.start();
		ta.sleep(5000); //等待5000ms
		System.out.println("TestNew is running");
	}
}

终止

使用退出标志终止线程

当run方法执行完后，线程就会退出。但有时run方法是永远不会结束的。
如在服务端程序中使用线程进行监听客户端请求，或是其他的需要循环处理的任务。在这种情况下，一般是将这些任务放在一个循环中，如while循环。如果想让循环永远运行下去，可以使用while（true）{……}来处理。但要想使while循环在某一特定条件下退出，最直接的方法就是设一个boolean类型的标志，并通过设置这个标志为true或false来控制while循环是否退出。

使用stop方法终止线程

使用stop方法可以强行终止正在运行或挂起的线程。我们可以使用如下的代码来终止线程：

thread.stop();
使用interrupt方法终止线程

使用interrupt方法来终端线程可分为两种情况：

（1）线程处于阻塞状态，如使用了sleep方法。

（2）使用while（！isInterrupted（））{……}来判断线程是否被中断。

在第一种情况下使用interrupt方法，sleep方法将抛出一个InterruptedException例外，而在第二种情况下线程将直接退出。
下面的代码演示了在第一种情况下使用interrupt方法。


public class ThreadInterrupt extends Thread  
{  
    public void run()  
    {  
        try  
        {  
            sleep(50000);  // 延迟50秒  
        }  
        catch (InterruptedException e)  
        {  
            System.out.println(e.getMessage());  
        }  
    }  
    public static void main(String[] args) throws Exception  
    {  
        Thread thread = new ThreadInterrupt();  
        thread.start();  
        System.out.println("在50秒之内按任意键中断线程!");  
        System.in.read();  
        thread.interrupt();  
        thread.join();  
        System.out.println("线程已经退出!");  
    }  
}

好了 今天就到这里了 下次见！
在这里插入图片描述

JWei_7
关注
  • 4
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java多线程编程
05-02
Java多线程编程是Java开发中的重要组成部分，它允许程序同时执行多个任务，极大地提高了程序的效率和响应性。在Java中，多线程主要通过`Thread`类和并发工具来实现，接下来我们将深入探讨这些关键知识点。 1. **...
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
JAVA多线程编程技术PDF
08-28
这份“JAVA多线程编程技术PDF”是学习和掌握这一领域的经典资料，涵盖了多线程的全部知识点。 首先，多线程的核心概念包括线程的创建与启动。在Java中，可以通过实现Runnable接口或继承Thread类来创建线程。创建后...
Java多线程编程技术
03-26
《Java多线程编程核心技术》建议猿友们读两遍，因为其写得没有那么抽象，第一遍有些概念不是很理解，可以先跳过并记录起来，第一遍阅读的目的主要是了解整个架构。第二遍再慢慢品味，并贯穿全部是指点来思考，并将...
Java多线程编程实战指南(核心篇)
07-17
Java多线程编程实战指南(核心篇) 高清pdf带目录 随着现代处理器的生产工艺从提升处理器主频频率转向多核化，即在一块芯片上集成多个处理器内核（Core），多核处理器（Multicore Processor）离我们越来越近了――如今...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 310
1.导入hutool的maven依赖。2.复制一下代码执行。
golang 接口
m0_70982551的博客
07-24 1096
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 145
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 589
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
weixin_43561432的博客
07-24 346
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 713
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 458
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 406
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
新建springboot项目找不到java版本8?
weixin_74009895的博客
07-28 150
新建springboot项目找不到java版本8?
高级java每日一道面试题-2024年7月29日-并发篇-什么时候用乐观锁,什么时候用悲观锁?
qq_43071699的博客
07-29 467
悲观锁适用于数据竞争激烈的场景，能够提供强一致性，但可能导致较多的线程等待。乐观锁适用于读多写少的场景，能够提供更高的并发性能，但可能需要多次尝试才能成功更新数据。
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
PAP
07-26 212
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
19.jdk源码阅读之FutureTask
前端、移动端、后端源码级底层原理分享
07-25 884
FutureTask 是 Java 并发包中的一个重要类，它实现了 RunnableFuture 接口，结合了 Future 和 Runnable 的特性。FutureTask 通常用于异步任务的执行和结果的获取。
Java —— 线程
JL_L666的博客
07-26 675
程序(program)：为完成特定的任务，选用某一种语言编写的，即指，静态对象。进程(process)：程序的一次执行过程，或是。程序是静态的、进程是。进程是调度和分配资源的最小单位。注意：不同的进程之间是不共享内存的、进程之间的数据交换和通信的成本很高。线程(thread)：进程可以进一步细化为线程，是运行中进程的一条或多条执行路径。线程调度策略单核CPU与多核CPU并行与并发上。
Jvm基础（一）
G81948577的博客
07-19 1228
本地方法就是不使用java编写的，比如C++编写的程序，只是需要传递参数。
Java多线程编程实战指南
"Java多线程编程深入详解" 在Java编程中，多线程是并发执行任务的关键技术，它使得程序能够同时处理多个任务，提高了系统资源的利用率和程序的响应速度。本书深入讲解了Java多线程编程的各个方面，旨在帮助读者理解...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值