java多线程

已于 2024-06-05 22:22:09 修改
阅读量584 收藏 9
点赞数 15
文章标签： java 开发语言
于 2024-06-04 21:26:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44690215/article/details/139440935
版权

多线程编程

1、多线程

1、什么是多线程？

有了多线程，我们就可以让程序同时做多件事情

2、多线程的作用？

提高效率

3、多线程的应用场景

只要你想让多个事情同时运行就需要用到多线程
比如：软件中的好事操作、所有的聊天软件、所有的服务器

2、并发与并行

1、并发：

在同一个时刻，有多个指令在单个CPU交替执行
在这里插入图片描述

2、并行：

在同一时刻，有多个指令在多个CPU同时执行
在这里插入图片描述

3、多线程第一种实现方式：继承Thread类的方式

在这里插入图片描述

package thread01;

public class MyThread extends Thread{

    @Override
    public void run() {
        //书写线程要执行的代码
        for (int i = 0; i < 1000; i++) {
            System.out.println(getName()+"Hello ");
        }
    }
}


package thread01;

public class ThreadDemo {

    public static void main(String[] args) {
        /**
         * 多线程的第一种启动方式
         * 1、自己定义一个类继承Thread
         * 2、重写里面的run方法
         * 3、创建子类的对象，并启动线程
         *
         */
        MyThread t1=new MyThread();
        MyThread t2=new MyThread();
        t1.setName("线程1");
        t2.setName("线程2");

        t1.start();
        t2.start();
    }
}

在这里插入图片描述

4、第二种方式：实现Runnable接口

package thread02;

import static java.lang.Character.getName;

public class MyThread implements Runnable{
    @Override
    public void run() {
        //书写线程要执行的代码
        for (int i = 0; i < 1000; i++) {
            //获取当前线程对象
            Thread t=Thread.currentThread();
            System.out.println(t.getName()+"Hello ");
        }
    }
}


package thread02;

public class ThreadDemo {
    public static void main(String[] args) {
        /**
         * 第二种创建方式
         * 1、自己定义一个类实现Runnable接口
         * 2、重写里面的run方法
         * 3、创建自己的类的对象
         * 4、创建一个Thread类的对象，并开启线程
         */

        MyThread t1=new MyThread();

        Thread t11=new Thread(t1);
        Thread t12=new Thread(t1);
        t11.setName("线程1");
        t12.setName("线程2");
        t11.start();
        t12.start();
    }
}

在这里插入图片描述

5、第三种实现方式：利用Callable接口和Future接口实现

package thread03;

import java.util.concurrent.Callable;

public class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        //书写线程要执行的代码
        int sum=0;
        for (int i = 0; i < 1000; i++) {
            //获取当前线程对象
            Thread t=Thread.currentThread();
            System.out.println(t.getName()+"Hello ");
            sum+=i;
        }
        return sum;
    }
}


package thread03;

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

public class ThreadDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        /**
         * 第三种方式：
         * 特点：可以获取多线程运行结果
         * 1、创建一个类MyCallable实现Callable接口
         * 2、重写call（是有返回值的，表示多线程运行的结果）
         * 3、创建MyCallable对象（表示多线程要执行的任务）
         * 4、创建FutureTask对象（作用：管理多线程运行的结果）
         * 5、创建Thread类的对象，并启动（表示线程）
         */
        MyCallable mc=new MyCallable();
        FutureTask ft=new FutureTask(mc);

        Thread t1=new Thread(ft);
        t1.start();

        System.out.println(ft.get());


    }
}

在这里插入图片描述
总结：
在这里插入图片描述

6、多线程常用方法

在这里插入图片描述

package threadmethod;

public class MyThread extends Thread{

    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        //书写线程要执行的代码
        for (int i = 0; i < 1000; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            //获取当前线程对象
            Thread t=Thread.currentThread();
            System.out.println(getName()+"@"+i);//getName获取线程名称
        }
    }
}


package threadmethod;


public class ThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        /**
         *setName(String name)
         * 1、线程默认有名字；格式Thread-X(0,1,2,3...)
         * 2、如果给线程设置名字，两种方式：使用set方法，或者使用构造方法进行设置
         *
         * static Thread currentThread()
         * 细节：
         *     当jvm虚拟机启动之后，会自动的启动多条线程
         *     其中有一条线程就叫做main线程
         *     他的作用就是去调用main方法，并执行里面的代码
         *     在以前，我们所写的所有代码，其实都是运行在main线程当中
         *
         * static void sleep(long time)  让线程休眠指定的时间（单位：毫秒）
         *   细节：
         *      1、哪条线程执行到这个方法，哪条线程就会停留在这里对应的时间
         *      2、方法的参数就表示休眠的时间
         *      3、时间到了之后，线程会自动醒来
         */
        MyThread t1=new MyThread("坦克");
        MyThread t2=new MyThread("飞机");
        t1.start();
        t2.start();

//        System.out.println(Thread.currentThread().getName());//获取当前线程对象
//        System.out.println("11111111");
//        Thread.sleep(5000);
//        System.out.println("22222222");




    }
}

7、线程的优先级

package threadpriority;

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


package threadpriority;

public class ThreadDemo {
    public static void main(String[] args) {
        /**
         *
         * setPriority(int newPriority)   设置线程的优先级
         * final int getPriority()    获取线程的优先级
         */

        MyBunnable myBunnable = new MyBunnable();

        Thread thread1 = new Thread(myBunnable,"飞机");
        Thread thread2 = new Thread(myBunnable,"坦克");

        thread1.setPriority(1);
        thread2.setPriority(10);

        System.out.println(thread1.getPriority());
        System.out.println(thread2.getPriority());
        System.out.println(Thread.currentThread().getPriority());

        thread1.start();
        thread2.start();
    }
}

8、守护线程（备胎线程）

void setDaemon(bool on)
当非守护线程执行完毕之后，守护线程会陆续结束
在这里插入图片描述

9、出让线程/礼让线程

10、插入线程

package thread01;

public class MyThread extends Thread{

    @Override
    public void run() {
        //书写线程要执行的代码
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+"@"+i);
        }
    }
}


package thread01;

public class ThreadDemo {

    public static void main(String[] args) throws InterruptedException {
        /**
         * public final void join()  插入线程、插队线程
         *
         */
        MyThread t1=new MyThread();
        t1.setName("线程1");
        t1.start();

        t1.join();//将线程1插入到main线程之前，当线程1执行完之后才执行main线程

        for (int i = 0; i < 10; i++) {
            System.out.println("main线程："+i);
        }

    }
}

在这里插入图片描述

11、线程的生命周期

在这里插入图片描述

12、线程的安全问题

1、同步代码块

在这里插入图片描述

package instance1;

public class MyThread extends Thread{


    static int tickets=0;//表示所有这个类的对象，都共享ticket数据
    static Object obj=new Object();//锁对象，一定是唯一的
    @Override
    public void run() {
        while (true){
            //同步代码块
            synchronized (obj){
                if (tickets<100){


                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }

                    tickets++;
                    System.out.println(getName()+"正在卖第"+tickets+"张票");

                }else{
                    break;
                }
            }
        }

    }
}


package instance1;

public class ThreadDemo {
    public static void main(String[] args) {
        /**
         * 需求：电影院卖票：共100张票，3个窗口卖票。设计多线程程序卖票。
         */

        MyThread t1=new MyThread();
        MyThread t2=new MyThread();
        MyThread t3=new MyThread();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}


D:\software\jdk\bin\java.exe "-javaagent:D:\software\IntelliJ IDEA 2023.3.2\lib\idea_rt.jar=56272:D:\software\IntelliJ IDEA 2023.3.2\bin" -Dfile.encoding=UTF-8 -classpath D:\Java\MyThread\com.thread\target\classes instance1.ThreadDemo
窗口1正在卖第1张票
窗口1正在卖第2张票
窗口1正在卖第3张票
窗口1正在卖第4张票
窗口1正在卖第5张票
窗口1正在卖第6张票
窗口1正在卖第7张票
窗口1正在卖第8张票
窗口1正在卖第9张票
窗口1正在卖第10张票
窗口1正在卖第11张票
窗口1正在卖第12张票
窗口1正在卖第13张票
窗口1正在卖第14张票
窗口1正在卖第15张票
窗口1正在卖第16张票
窗口1正在卖第17张票
窗口1正在卖第18张票
窗口1正在卖第19张票
窗口1正在卖第20张票
窗口1正在卖第21张票
窗口1正在卖第22张票
窗口1正在卖第23张票
窗口1正在卖第24张票
窗口1正在卖第25张票
窗口1正在卖第26张票
窗口1正在卖第27张票
窗口1正在卖第28张票
窗口1正在卖第29张票
窗口1正在卖第30张票
窗口1正在卖第31张票
窗口1正在卖第32张票
窗口1正在卖第33张票
窗口1正在卖第34张票
窗口1正在卖第35张票
窗口1正在卖第36张票
窗口1正在卖第37张票
窗口1正在卖第38张票
窗口1正在卖第39张票
窗口1正在卖第40张票
窗口1正在卖第41张票
窗口1正在卖第42张票
窗口1正在卖第43张票
窗口1正在卖第44张票
窗口1正在卖第45张票
窗口1正在卖第46张票
窗口1正在卖第47张票
窗口1正在卖第48张票
窗口1正在卖第49张票
窗口1正在卖第50张票
窗口1正在卖第51张票
窗口1正在卖第52张票
窗口1正在卖第53张票
窗口1正在卖第54张票
窗口1正在卖第55张票
窗口1正在卖第56张票
窗口1正在卖第57张票
窗口1正在卖第58张票
窗口1正在卖第59张票
窗口1正在卖第60张票
窗口1正在卖第61张票
窗口1正在卖第62张票
窗口1正在卖第63张票
窗口1正在卖第64张票
窗口1正在卖第65张票
窗口1正在卖第66张票
窗口1正在卖第67张票
窗口1正在卖第68张票
窗口1正在卖第69张票
窗口1正在卖第70张票
窗口1正在卖第71张票
窗口1正在卖第72张票
窗口1正在卖第73张票
窗口1正在卖第74张票
窗口1正在卖第75张票
窗口1正在卖第76张票
窗口1正在卖第77张票
窗口1正在卖第78张票
窗口1正在卖第79张票
窗口1正在卖第80张票
窗口3正在卖第81张票
窗口3正在卖第82张票
窗口3正在卖第83张票
窗口3正在卖第84张票
窗口3正在卖第85张票
窗口3正在卖第86张票
窗口3正在卖第87张票
窗口3正在卖第88张票
窗口3正在卖第89张票
窗口3正在卖第90张票
窗口3正在卖第91张票
窗口3正在卖第92张票
窗口3正在卖第93张票
窗口2正在卖第94张票
窗口2正在卖第95张票
窗口2正在卖第96张票
窗口2正在卖第97张票
窗口3正在卖第98张票
窗口3正在卖第99张票
窗口3正在卖第100张票

Process finished with exit code 0

注意：
1、锁对象一定是唯一的，如果是不同的锁（下图所述），则加锁毫无意义（等于没锁）
在这里插入图片描述错误示范：
在这里插入图片描述
正确示范：
在这里插入图片描述

2、同步方法

在这里插入图片描述

package instance2;

public class ThreadDemo {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();

        Thread thread1 = new Thread(myRunnable);
        Thread thread2 = new Thread(myRunnable);
        Thread thread3 = new Thread(myRunnable);

        thread1.setName("窗口1");
        thread2.setName("窗口2");
        thread3.setName("窗口3");

        thread1.start();
        thread2.start();
        thread3.start();
    }
}


package instance2;

public class MyRunnable implements Runnable{

    int tickets=0;
    @Override
    public void run() {
        /**
         * 1、循环
         * 2、同步代码块（同步方法）
         * 3、判断共享数据是否到了末尾，到了末尾
         * 4、没有到末尾
         *
         */
        while (true){
            if (method()){
                break;
            }
        }

    }
    public synchronized boolean method(){
        if (tickets==100){
            return true;

        }else{
            tickets++;
            System.out.println(Thread.currentThread().getName()+"正在卖第"+tickets+"张票");

        }
        return false;
    }
}

StringBuilder 和 StringBuffer 都是在 Java 中用于处理可变字符串的类。它们允许你在不创建新对象的情况下修改字符串内容，这对于性能优化非常有用，尤其是当你需要频繁地修改字符串时。

以下是 StringBuilder 和 StringBuffer 的主要区别：

线程安全性：

StringBuffer 的方法是同步的，这意味着它是线程安全的。你可以在一个多线程环境中安全地使用 StringBuffer 而不用担心数据一致性问题。
StringBuilder 的方法不是同步的，因此它是线程不安全的。在单线程环境中使用 StringBuilder 更加高效，因为它不需要同步所带来的额外开销。
性能：

因为 StringBuffer 的方法包含同步代码块，所以它的性能可能低于 StringBuilder，特别是在单线程应用中。
StringBuilder 没有同步开销，所以在单线程应用中通常比 StringBuffer 快。
引入时间：

StringBuffer 在早期版本的 Java 中就存在了。
StringBuilder 是在 Java 5（JDK 1.5）中引入的，作为 StringBuffer 的一个更高效的替代品，适用于单线程环境。
总结来说，如果你的应用是单线程的，或者你已经采取了其他措施来确保线程安全，那么你应该使用 StringBuilder 来获得更好的性能。如果你的应用是多线程的，并且需要在多个线程之间共享和修改字符串，那么你应该使用 StringBuffer 来确保线程安全。

选择哪个类取决于你的具体需求和应用程序的特性。

13、Lock锁

在这里插入图片描述

package lock1;

import instance1.MyThread;

public class ThreadDemo {
    public static void main(String[] args) {
        instance1.MyThread t1=new instance1.MyThread();
        instance1.MyThread t2=new instance1.MyThread();
        instance1.MyThread t3=new MyThread();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}


package lock1;

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

public class MyThread extends Thread{
    static Lock lock=new ReentrantLock();
    static int tickets=0;

    @Override
    public void run() {
        while (true){
            lock.lock();//加锁
            if(tickets==100){
                break;
            }else{
                tickets++;
                System.out.println(Thread.currentThread().getName()+"正在卖第"+tickets+"张票");

            }
            lock.unlock();//释放锁
        }
    }
}

14、死锁：是一个错误，不要去产生死锁

在这里插入图片描述

15-1、等待唤醒机制

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

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

package instancenotify01;

public class ThreadDemo {
    public static void main(String[] args) {
        /**
         * 需求：完成生产者和消费者（等待唤醒机制）的代码
         * 实现线程轮流交替执行的效果
         */

        Cook cook = new Cook();
        Foodie foodie = new Foodie();

        cook.setName("厨师");
        foodie.setName("吃货");

        cook.start();
        foodie.start();
    }
}


package instancenotify01;

public class Desk {
    /**
     * 作用：控制生产者和消费者的执行
     */
    //是否有面条，0：没有，1：有
    public static int foodFlag=0;

    //总个数
    public static int count=10;

    //锁对象
    public static Object lock=new Object();


}


package instancenotify01;

public class Cook extends Thread{
    @Override
    public void run() {

        while (true){
            synchronized (Desk.lock){
                if (Desk.count==0){
                    break;
                }else{
                    if (Desk.foodFlag==1){
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }else{
                        System.out.println("厨师做了一碗面条");
                        Desk.foodFlag=1;
                        Desk.lock.notifyAll();
                    }
                }
            }
        }

    }
}


package instancenotify01;

public class Foodie extends Thread{
    @Override
    public void run() {
        /**
         * 1、循环
         * 2、同步代码块
         * 3、判断共享数据是否（到了末尾）
         * 4、没有到末尾
         */
        while (true){
            synchronized (Desk.lock){
                if (Desk.count==0){
                    break;
                }else{
                    /**
                     * 1、先判断桌子上是否有面条
                     * 2、如果没有，就等待
                     * 3、如果有，就开吃
                     * 4、吃完之后，唤醒厨师继续做
                     * 5、吃的总数-1
                     * 6、修改桌子的状态
                     */
                    if (Desk.foodFlag==0){
                        try {
                            Desk.lock.wait();//让当前线程与锁进行绑定
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }

                    }else{
                        Desk.count--;
                        System.out.println("吃货正在吃面条，还能再吃"+Desk.count+"碗！！！");
                        Desk.lock.notifyAll();

                        Desk.foodFlag=0;
                    }

                }
            }
        }

    }
}

15-2、阻塞队列

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

package instancenotify02;

import java.util.concurrent.ArrayBlockingQueue;

public class ThreadDemo {
    public static void main(String[] args) {
        /**
         * 需求：利用阻塞队列完成生产者和消费者（等待唤醒机制）的代码
         * 细节：
         *     生产者和消费者必须使用同一个阻塞队列
         */
        //创建阻塞队列
        ArrayBlockingQueue<Object> queue = new ArrayBlockingQueue<>(1);

        //创建线程对象，并将阻塞队列传递过去
        Cook cook = new Cook(queue);
        Foodie foodie = new Foodie(queue);

        cook.start();
        foodie.start();
    }
}


package instancenotify02;

import java.util.concurrent.ArrayBlockingQueue;

public class Cook extends Thread{

    ArrayBlockingQueue<String> queue;

    public Cook(ArrayBlockingQueue queue){
        this.queue=queue;
    }
    @Override
    public void run() {
        while (true){
            try {
                queue.put("面条");
                System.out.println("厨师放了一碗面条");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

        }

    }
}


package instancenotify02;

import java.util.concurrent.ArrayBlockingQueue;

public class Foodie extends Thread{

    ArrayBlockingQueue<String> queue;

    public Foodie(ArrayBlockingQueue queue){
        this.queue=queue;
    }
    @Override
    public void run() {
        while (true){
            try {
                String food = queue.take();
                System.out.println(food);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

        }

    }
}

16、线程的状态

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

17、案例练习

1、

在这里插入图片描述

2、

在这里插入图片描述

3、

在这里插入图片描述

4、

在这里插入图片描述

5、

在这里插入图片描述

6、

在这里插入图片描述

7、

在这里插入图片描述

8、

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

栀晚鸯乱
关注
  • 15
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java 多线程
11-07
### Java多线程知识点详解 #### 一、Java Thread 概念 在Java中，**线程**是一种轻量级的进程，它是程序执行流的最小单元。一个标准的Java应用通常至少包含一个线程，即主（Main）线程。Java支持多线程编程，这...
Java多线程详解及示例
07-20
Java多线程编程是提升程序性能和响应性的关键技术。理解多线程的概念，掌握线程的创建、同步、通信、死锁避免等核心知识点，以及合理使用线程池，对于编写高效、稳定的并发程序至关重要。通过实践，开发者可以更好地...
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
Java多线程知识点总结
08-19
Java多线程是Java编程语言中一个非常重要的概念，它允许开发者在一个程序中创建多个执行线程并行运行，以提高程序的执行效率和响应速度。在Java中，线程的生命周期包含五个基本状态，分别是新建状态（New）、就绪...
开发多线程程序时，需要注意那些问题
最新发布
OO_SEN的博客
08-23 420
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
笔记redis
风止的博客
08-22 776
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
@Transactional中使用线程锁导致了锁失效与解决方案
liuruiaaa的博客
08-23 561
@Transactional中使用线程锁导致了锁失效与解决方案
android apk 加固后的地图加载异常及重新签名
calivnBao的博客
08-20 259
android apk 加固后的地图加载异常及重新签名
Java学习_18_Stream流
qq_41136689的博客
08-23 1011
博客仅记录个人学习进度和一些查缺补漏。学习内容：BV17F411T7Ao流的出现让数据处理从几十行代码缩减到一两行就能实现，简化了很多集合数组的操作。
JavaScript 错误 - Throw 和 Try to Catch的使用
逆风优雅的博客
08-23 114
trycatchthrow上面的代码 因为 try中 没有adddlert这个方法，或者这个方法有误，这时，代码会执行catch部分。JavaScript 实际上会创建带有两个属性的Error 对象name和message。
微服务框架
Founder_Xiao_Xin的博客
08-20 791
在分布式系统中，服务可能失败导致雪崩，Hystrix 是防雪崩利器，具有服务降级、服务熔断、服务隔离、监控等防止雪崩的技术。服务降级：接口调用失败调用本地方法返回空。服务熔断：接口调用失败进入熔断方法返回错误信息。服务隔离：隔离服务之间相互影响。服务监控：记录服务调用的运行指标。在分布式系统中，一个业务因跨越不同数据库或不同微服务而包含多个子事务，要求所有子事务同时成功或失败，这就是分布式事务。例如某电商系统下单操作，需请求订单服务、账户服务、库存服务。
Java中队列和栈实现——基于集合
2301_80412275的博客
08-19 208
Queue是一个非常实用的接口，适用于许多需要顺序处理的场景，如任务调度、消息传递等。通过不同的实现类，可以根据需求选择合适的队列类型。
使用Java通过身份证号码匹配省市县名称的技术博客
weixin_41489908的博客
08-21 337
每日自动更新各类学习教程及工具下载合集​​在中国，身份证号码包含了持有人的出生地信息。通过解析身份证号码的前六位，我们可以获取对应的省、市、县（区）信息。在这篇博客中，我们将探讨如何使用Java代码来实现这一功能，并展示详细的代码示例和运行结果。
[笔记] hyperf event
BLOCKGOLD.E的博客
08-20 482
得益于组件的支撑，用户可以很方便的对以下事件进行监听。例如。接下来我们就实现一个记录SQL的监听器，来说一下怎么使用。首先我们定义好，实现接口并对类定义php/***//***/return [/***/if (!
JavaSE-详细介绍
qq_68874993的博客
08-19 743
Java SE是Java技术的核心和基础
Java中自定义注解的使用
echola_mendes的博客
08-22 845
以【记录操作日志】为例，一般在开发中为了记录用户操作，当系统出现问题时，可以追溯日志所提供详细的错误信息，帮助开发者快速定位问题的原因最简单的方法：在每个方法中增加日志信息打印代码，来记录操作日志，但是这样重复代码也很多，也不易扩展，而且易出错使用自定义注解就会方便很多，减少不必要的重复代码，减少非业务代码的侵入性，如果需要扩展操作用户的信息以及IP就会很方便，易于扩展和维护@interface在需要使用自定义注解的地方使用该注解@LogOperation("新增")// 方法实现。
介绍一下FutureTask
challenge51all的专栏
08-19 254
在多线程编程中非常有用，特别是在需要异步执行任务并获取其结果的场景中。一样获取异步任务的执行结果、检查任务是否完成、取消任务等操作。希望以上介绍对您有所帮助！如果您还有其他问题，请随时提问。中，并在单独的线程中执行，不会阻塞当前线程。方法获取任务的执行结果。是 Java 中用于异步计算的一个类。可以将一个耗时的计算或操作封装在。方法检查任务是否已经完成，使用。一样被线程执行，又可以像。方法会阻塞直到任务完成。方法检查任务是否被取消。方法尝试取消任务的执行。
如何用Java SpringBoot+Vue搭建校内跑腿业务系统？实战教程解析
WEIXIN_JSJBCZDS的博客
08-21 970
如何用Java SpringBoot+Vue搭建校内跑腿业务系统？实战教程解析 【毕设攻略】Java SpringBoot+Vue打造校内跑腿系统！从零开始，手把手教你构建完整的业务流程。实战教程，技术难点全解析，让你的毕设项目脱颖而出，校园创业从这里启航！点击视频，开启你的编程之旅！
Java多线程深度解析
"《Java多线程详解》- 汪文君" 本书是关于Java多线程编程的深度解析，作者汪文君分享了他在工作中和学习中的理解和实践经验。书中内容详细介绍了多线程的基本概念、Java对多线程的支持以及如何在实际编程中运用多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值