synchronized关键字的用法、使用wait及notify方法实现线程间的通信

最新推荐文章于 2023-03-13 20:29:14 发布
最新推荐文章于 2023-03-13 20:29:14 发布
阅读量629 收藏 1
点赞数 2
分类专栏： Java并发编程 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZSA222/article/details/123291928
版权

文章目录

1.多线程的同步

为什么要引入同步机制

  • 在多线程环境中，可能会有两个甚至更多的线程试图同时 访问一个有限的资源。必须对这种潜在资源冲突进行预防。
  • 解决方法：在线程使用一个资源时为其加锁即可。访问资 源的第一个线程为其加上锁以后，其他线程便不能再使用 那个资源，除非被解锁。

问题代码举例

俩个线程同时取账户的钱

/**
 * @ClassName FetchMoney
 * @author: shouanzh
 * @Description 测试
 * @date 2022/3/5 12:27
 */
public class FetchMoney {

    public static void main(String[] args) {

		// 同一资源
        Bank bank = new Bank();

//        MoneyRunnableTherd moneyRunnableTherd = new MoneyRunnableTherd();
//        moneyRunnableTherd.setBank(bank);
//        Thread thread = new Thread(moneyRunnableTherd);
//        Thread thread2 = new Thread(moneyRunnableTherd);
//        thread.start();
//        thread2.start();

        MoneyTherd moneyTherd = new MoneyTherd(bank);
        moneyTherd.setName("银行柜台");

        MoneyTherd moneyTherd2 = new MoneyTherd(bank);
        moneyTherd2.setName("ATM");

        moneyTherd.start();
        moneyTherd2.start();

    }

}

// 个人账户
class Bank {

    private int money = 1000;

    public int getMoney(int number) {

        if (number < 0) {
            return -1;
        } else if (number > money) {
            return -2;
        } else if (money < 0) {
            return -3;
        } else {
            try {
                // 取钱模拟耗时
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            money -= number;
            System.out.println("剩余 money:" + money);
            return number;
        }
    }
}

// 取钱线程extends Thread
class MoneyTherd extends Thread {

    private Bank bank;

    public MoneyTherd(Bank bank) {
        this.bank = bank;
    }

    @Override
    public void run() {
        // 取出800
        System.out.println("取出：" + bank.getMoney(800));
    }
}

// 取钱线程implements Runnable
class MoneyRunnableTherd implements Runnable {

    private Bank bank;

    public void setBank(Bank bank) {
        this.bank = bank;
    }

    @Override
    public void run() {
        // 取出800
        System.out.println("取出：" + bank.getMoney(800));
    }
}

运行结果
在这里插入图片描述

2.synchronized修饰方法

  • synchronized 关键字：当 synchronized 关键字修饰一个方 法的时候，该方法叫做同步方法。
  • Java 中的每个对象都有一个锁（lock)或者叫做监视器 (monitor)，当访问某个对象的 synchronized 方法时，表 示将该对象上锁，此时其他任何线程都无法再去访问该 synchronized 方法了，直到之前的那个线程执行方法完毕 后（或者是抛出了异常)，那么将该对象的锁释放掉，其 他线程才有可能再去访问该synchronized 方法。
  • 如果一个对象有多个 synchronized 方法，某一时刻某个 线程已经进入到了某个 synchronized 方法，那么在该方法 没有执行完毕前，其他线程是无法访问该对象的任何 synchronized 方法的。

举例一

/**
 * @ClassName FetchMoney
 * @author: shouanzh
 * @Description 测试
 * @date 2022/3/5 12:27
 */
public class FetchMoney {

    public static void main(String[] args) {

        Bank bank = new Bank();

        MoneyTherd moneyTherd = new MoneyTherd(bank);
        moneyTherd.setName("银行柜台");

        MoneyTherd moneyTherd2 = new MoneyTherd(bank);
        moneyTherd2.setName("ATM");

        moneyTherd.start();
        moneyTherd2.start();

    }

}

// 个人账户
class Bank {

    private int money = 1000;

    public synchronized int getMoney(int number) {

        if (number < 0) {
            return -1;
        } else if (number > money) {
            return -2;
        } else if (money < 0) {
            return -3;
        } else {
            try {
                // 取钱模拟耗时
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            money -= number;
            System.out.println("剩余 money:" + money);
            return number;
        }
    }
}

// 取钱线程
class MoneyTherd extends Thread {

    private Bank bank;

    public MoneyTherd(Bank bank) {
        this.bank = bank;
    }

    @Override
    public void run() {
        // 取出800
        System.out.println("取出：" + bank.getMoney(800));
    }
}

运行结果：
在这里插入图片描述
举例二
如果一个对象有多个 synchronized 方法，某一时刻某个 线程已经进入到了某个 synchronized 方法，那么在该方法 没有执行完毕前，其他线程是无法访问该对象的任何 synchronized 方法的。

/**
 * @ClassName ThredTeat1
 * @author: shouanzh
 * @Description ThredTeat1
 * @date 2022/3/5 13:31
 */
public class ThredTeat1 {

    public static void main(String[] args) {

        Example example = new Example();

        TheThred theThred = new TheThred(example);
        TheThred2 theThred2 = new TheThred2(example);

        theThred.start();
        theThred2.start();


    }

}

class Example {

    public synchronized void execute ()  {
        try {
            for (int i = 0; i < 5; i++) {
                Thread.sleep(500);
                System.out.println("hello:" + i);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public synchronized void execute2 ()  {
        try {
            for (int i = 0; i < 5; i++) {
                Thread.sleep(500);
                System.out.println("word:" + i);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

class TheThred extends Thread {

    private Example example;

    public TheThred(Example example) {
        this.example = example;
    }

    @Override
    public void run() {
        example.execute();
    }

}

class TheThred2 extends Thread {

    private Example example;

    public TheThred2(Example example) {
        this.example = example;
    }

    @Override
    public void run() {
        example.execute2();
    }

}

运行结果：

hello:0
hello:1
hello:2
hello:3
hello:4
word:0
word:1
word:2
word:3
word:4

Process finished with exit code 0

3.synchronized修饰static方法

如果某个 synchronized方法是 static的， ，那么当线程访问该方法时， 它锁的并不是synchronized方法所在的对象，而是synchronized 方 法所在的对象所对应的Class对象，因为Java中无论一个类有多少 个对象，这些对象会对应唯一一个Class对象，因此当线程分别访 问同一个类的两个对象的两个 static， synchronized 方法时，他们 的执行顺序也是顺序的，也就是说一个线程先去执行方法，执行 完毕后另一个线程才开始执行。

static的方法属于类方法，它属于这个Class（注意：这里的Class不是指Class的某个具体对象），那么static获取到的锁，就是当前调用这个方法的对象所属的类(Class，而不再是由这个Class产生的某个具体对象了)。而‘非static’方法获取到的锁，就是当前调用这个方法的对象的锁了。所以，他们之间不会产生互斥。

public class ThredTeat1 {

    public static void main(String[] args) {

        Example example = new Example();

        TheThred theThred = new TheThred(example);
        TheThred2 theThred2 = new TheThred2(example);

        theThred.start();
        theThred2.start();


    }

}

class Example {

    public synchronized void execute ()  {
        try {
            for (int i = 0; i < 5; i++) {
                Thread.sleep(500);
                System.out.println("hello:" + i);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public synchronized static void execute2 ()  {
        try {
            for (int i = 0; i < 5; i++) {
                Thread.sleep(500);
                System.out.println("word:" + i);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

class TheThred extends Thread {

    private Example example;

    public TheThred(Example example) {
        this.example = example;
    }

    @Override
    public void run() {
        example.execute();
    }

}

class TheThred2 extends Thread {

    private Example example;

    public TheThred2(Example example) {
        this.example = example;
    }

    @Override
    public void run() {
        example.execute2();
    }

}

运行结果: execute() 和 execute2() 同时执行,说明锁的不是同一个对象

hello:0
word:0
word:1
hello:1
word:2
hello:2
word:3
hello:3
word:4
hello:4

Process finished with exit code 0

举例二

public class ThredTeat1 {

    public static void main(String[] args) {

        Example example = new Example();

        TheThred theThred = new TheThred(example);

        example = new Example();

        TheThred2 theThred2 = new TheThred2(example);

        theThred.start();
        theThred2.start();


    }

}

class Example {

    public synchronized static void execute ()  {
        try {
            for (int i = 0; i < 5; i++) {
                Thread.sleep(500);
                System.out.println("hello:" + i);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public synchronized static void execute2 ()  {
        try {
            for (int i = 0; i < 5; i++) {
                Thread.sleep(500);
                System.out.println("word:" + i);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

class TheThred extends Thread {

    private Example example;

    public TheThred(Example example) {
        this.example = example;
    }

    @Override
    public void run() {
        example.execute();
    }

}

class TheThred2 extends Thread {

    private Example example;

    public TheThred2(Example example) {
        this.example = example;
    }

    @Override
    public void run() {
        example.execute2();
    }

}

运行结果

hello:0
hello:1
hello:2
hello:3
hello:4
word:0
word:1
word:2
word:3
word:4

Process finished with exit code 0

4.synchronized代码块

synchronized代码块写法

synchronized(object) {

}
表示线程执行时会对object上锁

/**
 * @ClassName TherdTest2
 * @author: shouanzh
 * @Description synchronized代码块
 * @date 2022/3/5 14:50
 */
public class TherdTest2 {

    public static void main(String[] args) {

        Example2 example2 = new Example2();

        ThredTest thredTest = new ThredTest(example2);
        ThredTest1 thredTest1 = new ThredTest1(example2);

        thredTest.start();
        thredTest1.start();

    }

}

class Example2 {

    private Object object = new Object();

    public void execute() {

        synchronized (object) {
            try {
                for (int i = 0; i < 5; i++) {
                    Thread.sleep(500);
                    System.out.println("hello:" + i);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    public void execute2() {
        synchronized (object) {
            try {
                for (int i = 0; i < 5; i++) {
                    Thread.sleep(500);
                    System.out.println("word:" + i);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

class ThredTest extends Thread {

    private Example2 example;

    public ThredTest(Example2 example) {
        this.example = example;
    }

    @Override
    public void run() {
        example.execute();
    }

}

class ThredTest1 extends Thread {

    private Example2 example;

    public ThredTest1(Example2 example) {
        this.example = example;
    }

    @Override
    public void run() {
        example.execute2();
    }

}

运行结果

hello:0
hello:1
hello:2
hello:3
hello:4
word:0
word:1
word:2
word:3
word:4

Process finished with exit code 0

5.小结

synchronized 方法是一种粗粒度的并发控制，某一时刻， 只能有一个线程执行该synchronized 方法；
synchronized 块 则是一种细粒度的并发控制，只会将块中的代码同步，位 于方法内、synchronized 块之外的代码是可以被多个线程 同时访问到的。

6.使用wait及notify方法实现线程间的通信

wait 与 notify 方法都是定义在 Object 类中，而且是 final 的，因此会被所有的 Java类所继承并且无法重写。这两个 方法要求在调用时线程应该已经获得了对象的锁，因此对 这两个方法的调用需要放在synchronized方法或块当中。

当线程执行了 wait 方法时，它会释放掉对象的锁。

另一个会导致线程暂停的方法就是 Thread 类的 sleep方法， 它会导致线程睡眠指定的毫秒数，但线程在睡眠的过程中 是不会释放掉对象的锁的。

代码举例

/**
 * @ClassName Sample
 * @author: shouanzh
 * @Description Sample
 * @date 2022/3/5 16:04
 */
public class Sample {

    private int number;

    public synchronized void increase() {
        while (number != 0) {
            try {
                // wait() 会释放锁、释放cpu  所以每次被唤醒 都要重新检查状态，因为不知道等待期间发生了什么
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        number++;
        System.out.println(number);

        notify();

    }

    public synchronized void decrease() {

        while (number == 0) {
            try {
                // wait() 会释放锁、释放cpu  所以每次被唤醒 都要重新检查状态，因为不知道等待期间发生了什么
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        number--;
        System.out.println(number);

        notify();
    }


}

/**
 * @ClassName IncreaseThred
 * @author: shouanzh
 * @Description IncreaseThred
 * @date 2022/3/5 16:13
 */
public class IncreaseThred extends Thread{

    private Sample sample;

    public IncreaseThred(Sample sample) {
        this.sample = sample;
    }

    @Override
    public void run() {

        try {
            for (int i = 0; i < 10; i++) {

                Thread.sleep(600);

                sample.increase();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}


/**
 * @ClassName DecreaseThred
 * @author: shouanzh
 * @Description DecreaseThred
 * @date 2022/3/5 16:18
 */
public class DecreaseThred extends Thread{

    private Sample sample;

    public DecreaseThred(Sample sample) {
        this.sample = sample;
    }

    @Override
    public void run() {

        try {
            for (int i = 0; i < 10; i++) {

                Thread.sleep(500);

                sample.decrease();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}


/**
 * @ClassName Maintest
 * @author: shouanzh
 * @Description Maintest
 * @date 2022/3/5 16:19
 */
public class Maintest {

    public static void main(String[] args) {

        Sample sample = new Sample();

        IncreaseThred increaseThred = new IncreaseThred(sample);
        DecreaseThred decreaseThred = new DecreaseThred(sample);
        IncreaseThred increaseThred1 = new IncreaseThred(sample);
        DecreaseThred decreaseThred1 = new DecreaseThred(sample);

        increaseThred.start();
        decreaseThred.start();
        increaseThred1.start();
        decreaseThred1.start();

    }

}

运行结果

1
0
1
0
1
0
1
0
1
0
1
0
1


Process finished with exit code 0

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

Zhang_960110
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【并发编程】 — 线程间的通信wait、notify、notifyAll
12-21
文章目录1 wait、notify、notifyAll简单介绍1.1 使用方法 + 为什么不是Thread类的方法1.2 什么时候加锁、什么时候释放锁？1.3 notify、notifyAll的区别2 两个比较经典的使用案例2.1 案例1 — ABCABC。。。三个线程顺序打印问题2.1.1 题目2.1.2 题目分析2.1.3 我的答案2.2 生产者消费者问题2.2.1 题目2.2.2 题目分析2.2.3 我的答案 源码地址：https://github.com/nieandsun/concurrent-study.git 1 wait、notify、notifyAll简单介绍 1.1
java多线程同步(wait、notify)生产者消费者简单示例
Dawish的专栏
07-16 2279
一、为何写最为一个Android开发者，如果做得不够深入可能为不会去处理多线程同步的问题，稍微简单点可能使用一个线程池就可以搞定了，有关线程池的介绍可以参考我的另一篇文章：ExecutorService+LruCache+DiskLruCache用一个类打造简单的图片加载库 只是前段时间研究Android音视频硬解码，看到开源项目中用到了线程同步，就是在视频的YUV数据的暂存，和解码为视频并展示，
Java并发之同步 —— synchronized 关键字及wait,notify使用
zl_momomo的博客
07-25 393
前言：         从java 1.0开始，java中的每一个对象都有一个内部锁。如果一个方法使用synchronized关键字声明，那么对象的锁将保护整个方法。也就是说,要调用该方法，线程必须获得对象的内部锁。     内部的对象锁只有一个相关条件。wait方法添加一个线程到等待集中，notifyAll/notify方法解除等待线程的阻塞状态。换句话说，等价于 intrinsicCond...
JAVA中线程同步的几种实现方法
S_X007的博客
03-10 4495
JAVA中线程同步的几种实现方法 一、synchronized同步的方法： 1、synchronized同步方法 　　即有synchronized关键字修饰的方法。 由于java的每个对象都有一个内置锁，当用此关键字修饰方法时， 内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。 注： synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类。 2、synchronized同步代码块 　　即有synchronized关键字修饰的语句块。 被该关键字修饰
Java线程同步实现一：synchronzied和wait()/notify()
qq_40902067的博客
05-12 161
1、一个典型的Java线程安全例子 package com.chanshuyi.thread; public class ThreadDemo93 { public static void main(String[] args) { Account account = new Account(2300); new DrawMoneyThread(account).start(); new DepositeThread(account).start(
6-4 多线程编程：使用多线程同步与通信，模拟实现售票系统的售票和退票过程。 (20 分)
qq_52719788的博客
11-15 2561
使用synchronized实现同步控制，并使用wait()和notify()实现线程之间的通信。 编程要求如下： 可售出票的数量为一个固定值(total)，从键盘读入。 当余票的数量足够出售时(余票数量大于客户购买票数)，则先售票；如果没有余票了(票数为0)或余票数量不够了(余票数量小于客户购买票数)，则需要等待退票。退票后，如果余票足够出售，则又开始售票。 退票规则：有票被售出，才能退票。如果退票数大于已售票总数，也只能退回已售出票的实际数量。比如：已售出3张票，第一次退回了2张票，第2次就只能退
synchronized关键字及wait()/notify()/notifyAll()详解
Lizhj的博客
07-29 1282
概念 JDK官网中对synchronized关键字有如下定义，synchronized关键字可以实现一个简单的策略来防止线程干扰和内存一致性错误，如果一个对象对多线程是可见的，那么对该对象的所有读或者写都将通过同步的方式来进行。具体表现如下： synchronized关键字提供了一种锁机制，能够确保共享变量的互斥访问，从而防止数据不一致问题的出现。 synchronized关键字包括monitor enter和monitor exit两个JVM指令，它能够保证在任何时候任何线程执行到monitor
ReentrantLock源码分析(一)基于ConditionObject实现线程挂起和唤醒
zhangshenglu1的博客
03-13 295
synchronized提供了wait和notify的方法实现线程在持有锁时，可以实现挂起，唤醒的操作。同样我们在ReentrantLock也拥有类似的功能，ReentrantLock提供了await和signal方法去实现类似wait和notify的功能。想执行await或者是signal就必须先持有lock锁的资源，ReentrantLock实现等待和唤醒的示例：System.out.println("子线程获取锁资源并await挂起线程");try {
线程同步(使用了synchronized)和线程通讯(使用了wait,notify)
自信人生一百年
04-20 141
线程同步 什么是线程同步？ 当使用多个线程来访问同一个数据时，非常容易出现线程安全问题(比如多个线程都在操作同一数据导致数据不一致),所以我们用同步机制来解决这些问题。实现同步机制有两个方法：1。同步代码块：synchronized(同一个数据){} 同一个数据：就是N条线程同时访问一个数据。   2。     同步方法：public synchronized 数据返回类...
synchronized 与wait、notify的关系，多线程安全 与 线程通信 的关系。
热门推荐
晓游的专栏
06-03 1万+
上一篇博客《synchronized 的用法》中讲解了synchronized 关键字的 所有具体用法， 以及它是如何解决多线程安全问题的。 借这篇文章回顾一下线程通信的基础知识，可能这些知识点大家都能略知一二，但实际项目开发中 几个月不用，可能又会忘记一半，对有些概念似是而非、模棱两可，导致业务项目用到时又需要重新学习，这里自己完整总结一次，方便下次使用时查阅。 一、什么是...
如何在Java中正确使用 wait, notify 和 notifyAll
12-22
　在 Java 中可以用 wait、notify 和 notifyAll 来实现线程间的通信。。举个例子，如果你的Java程序中有两个线程——即生产者和消费者，那么生产者可以通知消费者，让消费者开始消耗数据，因为队列缓冲区中有内容待...
Java—线程的通信
12-22
文章目录Java—线程的通信概念引入wait（）与notify（）和notifyAll（）生产者和消费者模式 概念 线程通信概念：线程是操作系统中独立的个体，但这些个体如果不经过特殊处理就不能成为一个整体，线程间的通信就成为...
java—多线程的通信、生产者与消费者模式
12-21
run方法是不能用synchronized修饰，他是继承来的，不能改变其结构，而且，如果run方法加了synchronized，就变成单线程了，就没有并发了。 只要不是静态的同步方法，同步方法默认的同步监视器就是this。 静态的同步...
java并发编程：线程基础
最新发布
08-09
本资源致力于向您介绍 Java 并发编程中的线程基础，涵盖了多线程编程的核心概念、线程...线程间通信： 详解线程间通信的方法，包括 wait、notify 和 notifyAll 方法的使用。讲解如何通过这些方法实现线程的协作和同步。
JUC学习------Synchronized实现线程之间的通信
niulinbiao的博客
01-19 305
文章预览前言一、案例注意 前言 Synchronized实现线程之间的通信主要使用notify()和wait()方法 ​ wait()和notify()都是定义在Object类中，为什么如此设计。因为synchronized中的这把锁可以是任意对象，所以任意对象都可以调用wait()和notify()，并且只有同一把锁才能对线程进行操作，不同锁之间是不可以相互操作的，所以wait和notify属于Object notify() notify()唤醒等待的线程，如果监视器种只有一个等待线程，使用notif
Java多线程
qq_42334879的博客
02-17 129
1、使用synchronized关键字的使用方式： （1）修饰实例的方法：作用于当前对象实例加锁，进入同步代码前要获得当前对象实例的锁； （2）修饰静态方法：作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁，即给当前类加锁，会作用于类的所有对象实例，因为静态成员不属于任何一个实例对象，是类成员(static表明该类的一个静态资源，不管new了多少个对象，只有一份，所以对该类的所有对象都加了...
浅谈synchronized、wait、notify和notifyAll
曹建涛的博客
10-20 1244
一、概念解读 synchronized：同步锁，可修饰类、方法、代码块； wait：使当前线程进入等待状态，直到锁定对象被唤醒（notify、notifyAll），然后当前线程进入就绪状态；可指定最大等待时间，自动唤醒； notify：唤醒当前对象上等待的单个线程； notifyAll：唤醒当前对象上等待的所有县城； 二、sleep?很多面试题都会涉及到“sleep和wait的区别？”，开始可能都只
线程状态模型与synchronized的wait与notify方法
好好学java
04-29 843
1. 线程状态图 这是线程的7状态模型图，常见的7大状态之间的转换关系也在上面。多线程之间的通信主要用到4个方法，wait（）、wait（long time）、notify（）、notifyAll（），其他方法在多线程基础中都有介绍。 wait（）：作用是使当前线程从调用处中断并且释放锁转入等待队列，直到收到notify或者notifyAll的通知才能从等待队列转入锁池队列，没有收到停止会一直死等。 wait（long time）：相比wait多了一个等待的时间time，如果经过ti..
synchronized实现线程同步的用法和实现原理
源码之下，了无秘密
02-14 5652
作用和用法 在多线程对共享资源进行并发访问方面，JDK提供了synchronized关键字来进行线程同步，实现多线程并发访问的线程安全。synchronized的作用主要体现在三个方面：（1）确保线程互斥地访问同步代码；（2）保证共享变量的线程可见性；（3）禁止指令重排。其中（2）和（3）相当于volatile关键字的作用。 sychronized可以用在（1）静态方法，（2）普通成员方法...
synchronized关键字wait()，notify被成为什么机制
07-15
`synchronized`关键字配合`wait()`和`notify()`方法一起使用，被称为等待/通知机制（wait/notify mechanism）。 这种机制是用于实现线程间的协作和同步的一种方式。当一个线程在临界区内调用了对象的`wait()`方法时...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值