Java多线程基础

最新推荐文章于 2023-08-03 10:13:54 发布
最新推荐文章于 2023-08-03 10:13:54 发布
阅读量109 收藏
点赞数
分类专栏： Java 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KG6666666/article/details/112986350
版权

目录


一. 线程 & 进程

进程: 是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间

线程: 是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少 有一个线程 线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分 成若干个线程


二. 线程调度

分时调度: 所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

抢占式调度: 优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，

Java使用的是抢占式调度。
CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言，某个时刻， 只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是 在同一时 刻运行。 其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的 使 用率更高。


三. 同步 & 异步, 并发 & 并行

同步: 排队执行 , 效率低但是安全.
异步: 同时执行 , 效率高但是数据不安全.

举个例子: 有一桌子菜, 大家排队吃饭就是同步, 一起同时吃饭就是异步。
排队吃饭效率较低, 但是你看到你喜欢的菜就没人跟你抢，很安全.
相反，一桌人同时吃饭效率较高, 但是当你看到一块肉并伸出筷子时, 可能已经被别人夹走了, 数据不安全。

并发: 两个或多个事件在同一个时间段内发生。
并行: 两个或多个事件在同一时刻发生(同时发生)。


四. 如何实现多线程？

1. 继承Thread类

第一步: 定义一个类继承Thread类
第二步: 重写run方法

public class MyThread extends Thread {
    //run方法就是线程要执行的任务方法
    @Override
    public void run() {
        //这里的代码就是一条新的执行路径
        //这个执行路径是触发方式，不是调用run方法，而是通过thread对象的start方法来启动任务
        for (int i = 0; i < 10; i++) {
            System.out.println("MyThread"+i);
        }
    }
}

第三步: 创建MyThread类的对象
第四步: 调用start方法, 启动线程

public class Demo1 {
    public static void main(String[] args) {

        MyThread m = new MyThread();
        m.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("Main"+i);
        } 
    }
}


2. 实现Runnable接口

第一步: 定义一个类实现Runnable类
第二步: 重写run方法

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        //线程的任务
        for (int i = 0; i < 10; i++) {
            System.out.println("MyRunnable"+i);
        }
    }
}

第三步: 创建一个任务对象
第四步: 创建一个线程并给他一个任务
第五步: 调用start方法, 启动线程

public class Demo1 {
    public static void main(String[] args) {
        //1 创建一个任务对象
        MyRunnable r = new MyRunnable();
        //创建一个线程并给他一个任务
        Thread t = new Thread(r);
        //启动线程
        t.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("Main"+i);
        }
    }
}


3. 为什么更推荐实现Runnable而不是继承Thread

实现Runnable与继承Thread相比有如下优势:

1.通过创建任务，然后给线程分配任务的方式实现多线程，更适合多个线程同时执行任务的情况

2.可以避免单继承所带来的局限性

3.任务与线程是分离的，提高了程序的健壮性

4.后期学习的线程池技术，接受Runnable类型的任务，不接受Thread类型的线程


4. 匿名内部类

继承Thread类

public class MyThread0 {
    public static void main(String[] args) {
        new Thread() {
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("Thread" + i);
                }
            }
        }.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("Main" + i);
        }
    }
}

或者实现Runnable接口

public class MyThread0 {
    public static void main(String[] args) {
		new Thread(new Runnable() {				
    	public void run() {			   
        for(int i = 0; i < 5; i++) {	
            System.out.println("Runnable" + i);
        	}
    	}
	}).start(); 
		for (int i = 0; i < 5; i++) {
    	System.out.println("Main" + i);
		}
	}
}

温馨提示: main方法其实也是一个线程, 也称为主线程。在java中所以的线程都是同时启动的，至于哪个线程先执行，这得看哪个线程先抢到CPU的资源。


五.sleep方法

修饰和类型方法描述
static voidsleep(long millis)使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行），具体取决于系统定时器和调度程序的精度和准确性。
static voidsleep(long millis, int nanos)导致正在执行的线程以指定的毫秒数加上指定的纳秒数来暂停（临时停止执行），这取决于系统定时器和调度器的精度和准确性。
public class Demo4 {
    public static void main(String[] args) throws InterruptedException {
        //线程的休眠
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
            Thread.sleep(1000);     //1000毫秒
        }
    }
}
}

输出结果是从0-9的9个整数, 只不过没打印一个数都会停顿一秒


六.wait & notify方法

修饰和类型方法描述
voidwait()导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法。
voidwait(long timeout)导致当前线程等待，直到另一个线程调用 notify()方法或该对象的 notifyAll()方法，或者指定的时间已过。
voidwait(long timeout, int nanos)导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法，或者某些其他线程中断当前线程，或一定量的实时时间。
voidnotify()唤醒正在等待对象监视器的单个线程。
voidnotifyAll()唤醒正在等待对象监视器的所有线程。

这里我们通过一个生产者与消费者的例子来快速熟悉这两个方法
假设现在有三个类, 分别是厨师类, 服务员类, 和食物类.

大致的服务流程:

厨师每做好一道菜都会唤醒服务员并进入无限期等待状态, 当服务员把菜送上餐桌后便会将厨师唤醒让其开始做下一道菜, 自己则再一次进入等待状态, 循环100次.

我们先演示不加wait和notify的结果

厨师类

static class Cook extends Thread{
        private Food f;
        public Cook(Food f) {
            this.f = f;
        }

        @Override
        public void run() {
            for(int i=0;i<100;i++){
                if(i%2==0){
                    f.setNameAndSaste("土耳其冰淇凌","巧克力味");
                }else{
                    f.setNameAndSaste("麻婆豆腐","香辣味");
                }
            }
        }
    }

服务员类

    static class Waiter extends Thread{
        private Food f;
        public Waiter(Food f) {
            this.f = f;
        }
        @Override
        public void run() {
            for(int i=0;i<100;i++){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                f.get();
            }
        }
    }

食物类

 static class Food{
        private String name;
        private String taste;

 

        public void setNameAndSaste(String name,String taste){
           
                this.name = name;
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.taste = taste;
            }
        
        public void get(){
        	System.out.println("服务员端走的菜的名称是:" + name + ",味道:" + taste);            
            }
        }
    }

Main方法

public class Demo  {
    public static void main(String[] args) {
        Food f = new Food();
        new Cook(f).start();
        new Waiter(f).start();
    }

运行结果:
在这里插入图片描述
问题很明显, 巧克力味的麻婆豆腐和香辣味的冰淇凌? 这就离谱!!!

解决方案: 在Food类中加一个标记flag

当flag为true时, 厨师可以开始做菜, 在做完菜后, 设置flag为false, 并唤醒服务员(让他上菜), 再让厨师线程进入等待状态

当flag为false时，服务员可以上菜，上菜后再设置flag变为true(厨师在flag为true时才能做菜), 再把厨师线程线程唤醒, 最后让自己(服务员)进入等待状态

改进的Food类

static class Food{
        private String name;
        private String taste;

        //true 表示可以生产
        private boolean flag = true;

        public synchronized void setNameAndSaste(String name,String taste){
            if(flag) {
                this.name = name;
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.taste = taste;
                flag = false;
                this.notifyAll();
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        public synchronized void get(){
            if(!flag) {
                System.out.println("服务员端走的菜的名称是:" + name + ",味道:" + taste);
                flag = true;
                this.notifyAll();
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }


七. 线程生命周期

在这里插入图片描述

  1. 一旦线程对象被new出来后，线程就进入了新建状态；

  2. 当该对象调用start()方法，就进入就绪状态；

  3. 进入就绪状态后，当该对象抢到CPU时间片就会进入运行状态；

  4. 进入运行状态后

  5. 4.1. 若run()方法或main()方法结束后，线程就进入终止状态；

    4.2. 当线程调用了自身的sleep()方法或其他线程的join()方法, 线程就会进入阻塞状态（注意: 调用sleep ()函数后，线程不会释放"锁"）。当sleep()结束或join()结束后，该线程回到可运行状态，继续争抢CPU时间片。

    4.3. 当线程调用了yield()方法，该线程放弃当前获得的CPU时间片，回到就绪状态，这时与其他进程处于同等竞争状态。

    4.5. 当线程调用了suspend() 和 resume() 方法，suspend()使得线程进入阻塞状态，并且不会自动恢复，只有resume() 方法被调用，才能使得线程重新进入可运行状态。一般suspend() 和 resume() 被用在等待另一个线程产生的结果的情形：测试发现结果还没有产生后，让线程阻塞，另一个线程产生了结果后，调用 resume() 使其恢复。

    4.6、wait() 和 notify() 方法：当线程调用wait()方法后会进入等待状态，进入这个状态后，只能依靠其他线程调用notify()或notifyAll()方法才能被唤醒（一般都用notifyAll()方法，唤醒有所线程）当调用wait()后，线程会释放掉它所占有的“锁标志”，从而使线程所在对象中的其它synchronized数据可被别的线程使用

注意：wait() 和 notify() 与suspend() 和 resume() 这两对方法看起来很相似，但是它们是有区别的。suspend()方法在线程阻塞时都不会释放占用的"锁"(如果占用了的话)，而wait()方法的调用不会让线程释放掉占有的"锁"。


八. 线程安全

多线程为什么会出现安全问题呢？我们不妨先举个例子
三个售票窗口同时卖10张火车票(这里我们创建3个线程来模拟该情景)

public class Demo7 {
    public static void main(String[] args) {
        
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable{
        //总票数
        private int count = 10;
        @Override
        public void run() {
            while (count>0){
                //卖票
                System.out.println("正在准备卖票");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println("卖票结束,余票："+count);
            }
        }
    }
}

运行结果如下
在这里插入图片描述
结果发现出现了余票"增加"以及余票负数等问题
这是因为多线程在进行同一卖票任务时，当余票只剩一张时, 三个线程都已经进入到while(count>0)的语句里, 所以最后会出现负数的情况。

以下是三种解决方式

1. 同步代码块(隐式锁)

把synchronized关键字加上一个锁对象.
语法: synchronized(锁对象){}

public class Demo8 {
    public static void main(String[] args) {
        Object o = new Object();
        
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable{
        //总票数
        private int count = 10;
        private Object o = new Object();
        @Override
        public void run() {
            //Object o = new Object();    //这里不是同一把锁，所以锁不住
                while (true) {
                    synchronized (o) {
                        if (count > 0) {
                         //卖票
                            System.out.println("正在准备卖票");
                            try {
                            Thread.sleep(1000);
                            } catch (InterruptedException e) {
                            e.printStackTrace();
                            }
                            count--;
                            System.out.println(Thread.currentThread().getName()+"卖票结束,余票：" + count);
                        }else {
                            break;
                        }

                }
            }
        }
    }
}

2. 同步方法(隐式锁)

把synchronized关键字修饰在方法Sale()中
语法: public synchronized boolean sale(){}

public class Demo9 {
    public static void main(String[] args) {
        Object o = new Object();
        //线程不安全
        //解决方案2  同步方法
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable{
        //总票数
        private int count = 10;
        @Override
        public void run() {

            while (true) {
                boolean flag = sale();
                if(!flag){
                    break;
                }
            }
        }
        public synchronized boolean sale(){
            if (count > 0) {
                //卖票
                System.out.println("正在准备卖票");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println(Thread.currentThread().getName()+"卖票结束,余票：" + count);
                return true;
            }
                return false;

        }
    }
}

3. Lock(显示锁)

语法:
1. 创建一把锁: Lock l = new ReentrantLock()
2. 加锁: l.lock()
3. 解锁: l.unlock()

public class Demo10 {
    public static void main(String[] args) {
        Object o = new Object();
        //线程不安全
        //解决方案1   显示锁  Lock  子类 ReentrantLock

        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable{
        //总票数
        private int count = 10;
        
        private Lock l = new ReentrantLock();
        @Override
        public void run() {
            while (true) {
                l.lock();
                    if (count > 0) {
                        //卖票
                        System.out.println("正在准备卖票");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        count--;
                        System.out.println(Thread.currentThread().getName()+"卖票结束,余票：" + count);
                    }else {
                        break;
                    }
                    l.unlock();
            }
        }
    }
}


九. 线程池

线程池, 顾名思义就是一个装线程的容器. 通过重用已存在的线程，降低线程创建和销毁造成的消耗. 线程若是无限制的创建，可能会导致内存占用过多，并且会造成cpu过度切换.

1. 缓存线程池

特点: 没有长度限制

流程:
1. 判断线程池是否存在空闲线程
2. 存在则使用
3. 不存在则创建线程并使用

在这里插入图片描述

public class Demo13 {
    public static void main(String[] args) {
        
        ExecutorService service = Executors.newCachedThreadPool();
        
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }

        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }

        });service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }

        });

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


    }
}

2. 定长线程池

特点: 长度固定

流程:

1 判断线程池是否存在空闲线程
2 存在则使用
3 不存在空闲线程  且线程池未满的情况下  则创建线程  并放入线程池中  然后使用
4 不存在空闲线程  且线程池已满的情况下  则等待线程池的空闲线程

public class Demo14 {
   
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(2);
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });
    }
}

结果如下
在这里插入图片描述
由于线程池指定长度为2, 在执行第三个任务时并没有创建第3个线程, 而是由空闲下来的线程来执行

3. 单线程线程池

特点: 线程池里只有一个线程

流程:

    1 判断线程池的那个线程是否空闲
    2 空闲则使用
    3 不空闲则等待它空闲后再使用

public class Demo15 {
    /*单线程线程池
    执行流程
        1 判断线程池的那个线程是否空闲
        2 空闲则使用
        3 不空闲则等待它空闲后再使用
    **/
    public static void main(String[] args) {
        ExecutorService service = Executors.newSingleThreadExecutor();
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });
    }
}

运行结果如下
在这里插入图片描述
三个任务全部由一个线程来执行

4. 周期定长线程池

流程:

    1 判断线程池是否存在空闲线程
    2 存在则使用
    3 不存在空闲线程  且线程池未满的情况下  则创建线程  并放入线程池中  然后使用
    4 不存在空闲线程  且线程池已满的情况下  则等待线程池的空闲线程

定时执行一次

public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2);
        //定时执行一次
        //参数1：定时执行的任务
        //参数2：时长数字
        //参数3：参数2的时间单位    Timeunit的常量指定
       scheduledExecutorService.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        },5, TimeUnit.SECONDS);      //5秒钟后执行*/

周期性执行任务

public class Demo16 {
 
    public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2);
        /*
        周期性执行任务
            参数1：任务
            参数2：延迟时长数字（第一次在执行上面时间以后）
            参数3：周期时长数字（没隔多久执行一次）
            参数4：时长数字的单位
        * **/
        scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        },5,1,TimeUnit.SECONDS);
    }
}
KG6666666
关注
专栏目录
记录一次关于vue+localstorage编译部署的诡异报错（Error: Loading chunk S+eF failed.）
随便记记
03-20 1183
前情提要： 背景：本人项目是基于vue-element-template的框架实现的(虽然删减了一部分)，navbar(顶部导航)和sidebar(侧边导航)都是默认的组件，与页面部分是同级的兄弟组件 起因：在登录系统时希望运用localstorage存入当前登录所有用户的基本信息，然后在navbar和sidebar两个组件中读写 问题描述： 代码编译后在本地运行正常，把编译后的dist文...
vue异步数据 报错_解决vuex数据异步造成初始化的时候没值报错问题
weixin_33895396的博客
02-05 1005
当使用vue做登录的时候，我们会把拿到的部分用户信息存在vuex+cookie中，我们知道，vuex的数据是会随着浏览器刷新而丢失的，此时我们会重新请求接口对vuex的数据进行再次赋值，如下当有cookie但是vuex没有数据的时候再次请求赋值statemutationvuex的数据是异步的，当我们页面需要直接拿vuex的值进行渲染的时候，初始化瞬间(即请求过程进行的时候)，vuex是没有这个值的...
vue异步数据 报错_vue中异步请求数据，异步请求还没完成，文件就执行了就会报错，怎么解决？...
weixin_39633276的博客
12-21 924
vue中，axios异步加载数据，但是有的文件里面需要用到异步拿到的数据，数据还没拿到，文件已经执行了，这时候数据就是空，就会报错，这个问题怎么解决？具体表现：我这边vue项目是进入页面的时候会调用一个login方法，然后设置localStorage，this.login().then(res=>{if(res.code===0){localStorage.setItem...
10. vue axios 请求未完成时路由跳转报错问题
qq_22225239的博客
12-03 713
10. vue axios 请求未完成时路由跳转报错问题 axios 请求未完成时路由跳转报错问题 前两天项目基本功能算是完成了，在公司测试时遇到了遇到了一个问题，那就是在请求未完成时进行路由跳转时会报错，想了几种办法来解决，例如加loading，请求拦截，还有就是路由跳转时取消之前的请求。 这里我用的是路由跳转时取消之前的请求 问题解决方法 data() { return ...
vue axios 阻塞未完成请求
牛马程序员进阶之路
04-07 2987
import _ from 'lodash' import axios from 'axios' const { CancelToken, Cancel } = axios const tokens = {} /** * 请求前处理 config（尽可能在最先注册的拦截器中调用） * @param {import('axios').AxiosRequestConfig} config */ export const setConfig = function(config) { const { .
Java多线程干货系列（1）Java多线程基础编程开发技术
11-22
Java多线程是Java编程中的重要...以上内容仅涵盖了Java多线程基础编程的一部分知识点，实际开发中还需要关注更多的并发控制策略、性能优化和调试技巧。对于深入理解Java多线程，还需要学习和实践更多相关的高级特性。
Java多线程基础-01、数组概述.rar
11-20
本资料“Java多线程基础-01、数组概述”将带你入门Java的多线程世界，并结合数组这一基本数据结构进行讲解。 首先，我们需要理解什么是线程。线程是操作系统分配CPU时间的基本单位，一个进程可以有多个线程，它们...
Java 多线程基础笔记
最新发布
08-17
Java 多线程基础笔记
Java多线程基础-03、数组定义方式二、元素默认值规则.rar
11-20
总之，Java多线程基础是高效编程的关键，而理解数组定义和元素默认值规则则是构建安全、健壮的多线程程序的基础。通过合理运用多线程技术和掌握数组的内在特性，你可以编写出更加高性能、可扩展的Java应用程序。
一篇文章弄懂Java多线程基础和Java内存模型
12-21
Java多线程是并发编程的重要组成部分，理解和掌握其基础以及Java内存模型对于任何Java开发者来说都是必不可少的。本文将深入探讨这两个主题。 首先，我们来理解多线程的生命周期及其五种基本状态： 1. 新建状态...
vue如何实现动态加载脚本
11-21
这篇文章主要介绍了vue如何实现动态加载脚本,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 今天在研究，tinymce富文本编辑器怎样在vue中使用，然后看到其它框架上的使用方法，它是动态加载tinymce脚本的，若果在本地引入静态文件或者，npm安装都会导致vue项目打包体积过大，这种动态脚本引入方式，是一个不错的实践，下面上的代码块叫 dynamicLoadScript 顾名思义，动态加载脚本，这个js只对加载tinymce有效，不过要想加载其它脚本，稍微做一下改动即可 我们可以建立一个dynamicLoadScript.js文件 上代码
Vue 里面解决点击某一个请求接口 接口还没处理完 又点击请求 数据显示串的问题
chenfairy的博客
08-03 509
Vue 里面解决点击某一个请求接口 接口还没处理完 又点击请求 数据显示串的问题
vue组件异步传值报错处理
Mr_Renhappy的博客
05-23 767
解决问题前先串一遍父子组件的生命周期钩子顺序 渲染过程 父组件挂载完一定在子组件都挂载完成后才算父组件挂载完成，所以父组件的 mounted 一定是在子组件的mounted后面 父beforeCreate ->父created -> 父beforeMounted -> 子beforeCreate -> 子created -> 子 beforeMounted -> 子mounted -> 父mounted 子组件更新过程 1.影响到父组件： 父befo..
记我一次用vue写接口报404的经历
mhc20201554114的博客
06-11 693
这几天在用vue写项目，遇到了一个很难受的报错，就是404，也就是我请求时候传递的参数出了毛病。刚开始我还以为是大意了，没有闪，才犯了这种错误。请求类型给加错了或者url拼接出了毛病，但是我反复检查了四五遍后，还是没有找到问题所在，当时就把所有的完成操作之后的响应步骤全给删了，只留下了最基础的一部分语句，想要看看是不是能运行，但是很无奈的是还是报404。请求部分的代码如下： 在我找了半天之后，才在浏览器的控制台里找到原因，在拼接过后的url中的project前多出了这么一串字符%E2%80%8B，我百思
在Vue3中如何使用Suspense组件来处理异步加载和错误处理？
2301_77795034的博客
07-04 590
但是，如果我们使用异步加载，我们就可以在请求失败时加载一个备用的代码分支，比如显示一个“加载中”的提示，让用户知道我们的应用正在努力加载数据。但是，如果我们使用异步加载，我们就可以在页面加载时先加载一部分代码，然后当用户需要使用其他功能时，再加载其他的代码。也就是在异步操作进行中，显示给用户的临时内容。这个属性可以帮助我们在等待异步操作完成时，提供一些有用的提示信息给用户，让用户知道我们的应用正在努力加载数据。这个属性可以帮助我们控制异步加载的顺序，确保我们的应用在加载数据时不会出现卡顿或者错乱的情况。
vue项目中页面调用数据的字段响应在数据加载完毕之前出现undefined
想成为大神的小白
08-18 4658
踩坑记： 在项目中遇到后台数据还没有加载完毕，但是页面上调用了后台数据中的字段，这样就回报undefined。 只需在这个数据的标签上加上v-if="判断的字段名"，也就是当这个字段存在的时候才显示。 这样就可以解决掉undefined的问题。...
【Vue3】报错处理合集
Qxn530的博客
09-14 3395
Vue3遇到的报错合集
vue 父组件与子组件传递参数失败问题
chenjun1992的博客
06-17 2156
今天写博客获取评论模块，需要从父组件向子组件传递topicId，但评论一直不显示 子组件： export default { name: "CommentView", prop: ['topicId'], components: { AddComment }, data() { return { comments: [] }; }, created() { this.fetchComment() }, methods: { f
vue异步数据 报错_vue之数据异步加载！坑
weixin_39739846的博客
02-05 610
“Error in render: "TypeError: Cannot read property ‘0‘ of undefined"”渲染错误问题搭建项目商家详情头部时，能够完整渲染出整体头部界面无问题，但开发者工具仍然报出“Error in render: "TypeError: Cannot read property ‘0‘ of undefined”错误，具体如下百度翻译：见文之意：这...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值