(二)多线程基础篇 —— Synchronized 多线程同步讲解

最新推荐文章于 2024-01-08 20:37:00 发布
最新推荐文章于 2024-01-08 20:37:00 发布
阅读量308 收藏 1
点赞数
分类专栏： Java基础 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tunmengsmile/article/details/107954294
版权

目录

 

 

前言：

1.定义

2.Synchronized 原理

3.synchronized 锁的是什么

3.1 实例对象锁与类对象锁

4.示例分析

4.1 不引入锁synchronized我们存钱会发生什么

4.2 同步非静态实例方法（synchronized method）

4.3同步代码块（synchronized (类.class)），锁是小括号 () 中的类对象（Class 对象）

4.4对同步代码块优化的思考之同步代码块（synchronized (类实例对象)），锁是小括号 () 中的实例对象。

4.5同步静态方法

五总结

 

前言：

在Java多线程编程中，我们长需要考虑线程安全问题，其中关键字Synchronized，在线程同步中扮演着重要的作用，我将讲解 Java关键字Synchronized的知识

 

1.定义

Synchronized 是Java中的一个关键字，被Synchronized修饰的方法 / 代码，保证同一时刻最多只有1个线程执行 。

 

2.Synchronized 原理

实现原理： JVM 是通过进入、退出 对象监视器(Monitor) 来实现对方法、同步块的同步的，而对象监视器的本质依赖于底层操作系统的 互斥锁(Mutex Lock) 实现。

具体实现是在编译之后在同步方法调用前加入一个monitor.enter指令，在退出方法和异常处插入monitor.exit的指令。

对于没有获取到锁的线程将会阻塞到方法入口处，直到获取锁的线程monitor.exit之后才能尝试继续获取锁。

注意：synchronized方法或声明执行期间，如程序遇到任何异常或return，线程都会释放锁

 

流程图如下：

3.synchronized 锁的是什么

 

首先我们明确一点，synchronized 锁的不是代码，锁的都是对象。

锁的对象有以下几种：

  • 同步非静态方法（synchronized method），锁是当前对象的实例对象。

  • 同步静态方法（synchronized static method），锁是当前对象的类对象（Class 对象）。

  • 同步代码块（synchronized (this)，synchronized (类实例对象)），锁是小括号 () 中的实例对象。

  • 同步代码块（synchronized (类.class)），锁是小括号 () 中的类对象（Class 对象）。

     

3.1 实例对象锁与类对象锁

①实例对象锁，不同的实例拥有不同的实例对象锁，所以对于同一个实例对象，在同一时刻只有一个线程可以访问这个实例对象的同步方法；不同的实例对象，不能保证多线程的同步操作。

②类对象锁（全局锁），在 JVM 中一个类只有一个与之对应的类对象，所以在同一时刻只有一个线程可以访问这个类的同步方法。

 

4.示例分析


我们用最经典的存钱实例讲解这个问题；

4.1 不引入锁synchronized我们存钱会发生什么


1.新建一个银行类Bank


public class Bank {
    private    int  BankMoney =1000;
    /***
     * 存钱方法
     * @param money
     * @param names
     */
    public   void  dopost(int  money,String names){
            String name = Thread.currentThread().getName();
            Log.e("BankT",name+"-----当前余额："+BankMoney);
            BankMoney+=money;
            Log.e("BankT",name+"-------"+names+"-----存入银行后余额："+BankMoney);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        

    }
}

2.建立顾客完成存钱的操作

           //2.runnableT执行体
      private class MyRunnableT implements  Runnable{
        Bank mBk;
        int money;
        String  name;
        public MyRunnableT(Bank mk,int money,String name){
            this.mBk=mk;
            this.money=money;
            this.name=name;
        }

        @Override
        public void run() {

            mBk.dopost(money,name);
        }
    }

     //3.开启三个线程执行存钱操作
        Bank bank = new Bank();
        //创建三个不同的对象
        Thread thread_1 = new Thread(new MyRunnableT(bank , 200, "小明"));
        Thread thread_2 = new Thread(new MyRunnableT(bank , 200, "小张"));
        Thread thread_3 = new Thread(new MyRunnableT(bank , 200, "小王"));
        thread_1.start();
        thread_2.start();
        thread_3.start();

运行结果：

看到打印结果我们发现他并没有按照我们期望的结果顺序去显示结果，如：我们期望小明先执行，然后小张执行，最后小王在执行，为什么出现这样的结果呢。这个就是因为在多线程执行的过程中cpu 调度线程执行任务时是随机的选取一个任务去执行。因此出现了乱序执行的现象，且没有保证多线程同时操作同一个资源的同步性。

4.2 同步非静态实例方法（synchronized method）

①给dopost 方法添加关键子synchronized

public class Bank {

    private   int  BankMoney =1000;

    /***
     * 存钱方法
     * @param money
     * @param names
     */
    public  synchronized  void  dopost(int  money,String names){
        //设置当前对象的类对象 实现全局锁，
            String name = Thread.currentThread().getName();
            Log.e("BankT",name+"-----当前余额："+BankMoney);
            BankMoney+=money;
            Log.e("BankT",name+"-------"+names+"-----存入银行后余额："+BankMoney);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

    }
}

② 仅仅创建一个bank 实例对象 ，开启线程；

 

     private class MyRunnableT implements  Runnable{
        Bank mBk;
        int money;
        String  name;
        public MyRunnableT(Bank mk,int money,String name){
            this.mBk=mk;
            this.money=money;
            this.name=name;
        }

        @Override
        public void run() {

            mBk.dopost(money,name);
        }
    }


  //开启三个线程；
 private void sync() {
       //  创建当前对象的实例对象//仅仅创建一个bank 实例对象
        Bank bank = new Bank();
        Thread thread_1 = new Thread(new MyRunnableT(bank, 200, "小明"),"thread_1");
        Thread thread_2 = new Thread(new MyRunnableT(bank, 200, "小张"),"thread_2");
        Thread thread_3 = new Thread(new MyRunnableT(bank, 200, "小王"),"thread_3");
        thread_1.start();
        thread_2.start();
        thread_3.start();

    }

运行结果如下：

可以看到，结果正确执行。因为对于同一个实例对象（仅仅创建一个bank 实例对象），各线程之间访问其中的同步方法是互斥的。

 

 

 

如果我们分别创建实例传入线程中是什么效果呢

 private class MyRunnableT implements  Runnable{
        Bank mBk;
        int money;
        String  name;
        public MyRunnableT(Bank mk,int money,String name){
            this.mBk=mk;
            this.money=money;
            this.name=name;
        }

        @Override
        public void run() {

            mBk.dopost(money,name);
        }
    } 
 

private void sync() {
       //  创建当前对象的实例对象
        Bank bank_1 = new Bank();
        Bank bank_2 = new Bank();
        Bank bank_3 = new Bank();
        Thread thread_1 = new Thread(new MyRunnableT(bank_1, 200, "小明"),"thread_1");
        Thread thread_2 = new Thread(new MyRunnableT(bank_2, 200, "小张"),"thread_2");
        Thread thread_3 = new Thread(new MyRunnableT(bank_3, 200, "小王"),"thread_3");
        thread_1.start();
        thread_2.start();
        thread_3.start();

    }

执行结果如下：

从上面的运行结果，我们发现对 Bank 中 money 的操作并没有同步，synchronized 失效了？这是因为实例对象锁，只对同一个实例生效，对同一个对象的不同实例不保证同步（示例代码中每个线程传入的bank都创建了一个实例,不是同一个实例）。

要解决这个问题有两种方式：①可以改变成4.2同步非静态实例方法（synchronized method）的实现形式，只创建一个实例对象。② 同步代码块（synchronized (类.class)），锁是小括号 () 中的类对象（Class 对象）的实现形式。

 

4.3同步代码块（synchronized (类.class)），锁是小括号 () 中的类对象（Class 对象）

修改dopost 方法为 类对象锁其他部分代码不变，在执行程序；

  /***
     * 存钱方法
     * @param money
     * @param names
     */
    public    void  dopost(int  money,String names){
        //设置当前对象的类对象 实现全局锁，
        synchronized (Bank.class){
            String name = Thread.currentThread().getName();
            Log.e("BankT",name+"-----当前余额："+BankMoney);
            BankMoney+=money;
            Log.e("BankT",name+"-------"+names+"-----存入银行后余额："+BankMoney);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
       }

    }

运行结果如下：

从结果中我们发现，线程是同步操作了，但为什么在我们的 BankMoney怎么才 1200 啊？

要回答上面问题也很简单，首先线程是同步操作了，这个没有疑问，说明我们的全局锁生效了，那为什么钱少了，因为我们这里 mew 了三个对象，三个对象都有各自的BankMoney，他们并不共享，所以最后都是 1200，那有没有办法，让这些线程间共享 BankMoney呢？方法很简单，只要设置 BankMoney为 static 即可

 

4.4对同步代码块优化的思考之同步代码块（synchronized (类实例对象)），锁是小括号 () 中的实例对象。

我们知道同步的对象不是实例对象就是类对象。现在假设一个类有多个同步方法，那么当某个线程进入其中一个同步方法时，这个类的其它同步方法也会被锁住，造成其它与当前锁定操作的同步方法毫无关系的同步方法也被锁住，最后的结果就是影响了整个多线程执行的性能，使原本不需要互斥的方法也都进行了互斥操作。比如：

public class Bank {

    private  static  int  BankMoney =1000;

    /***
     * 存钱方法
     * @param money
     * @param names
     */
    public    void  dopost(int  money,String names){
        //设置当前对象的实例锁
        long begin = System.currentTimeMillis();
        synchronized (this){
            String name = Thread.currentThread().getName();
            Log.e("BankT",name+"-----当前余额："+BankMoney);
            BankMoney+=money;
            Log.e("BankT",name+"-------"+names+"-----存入银行后余额："+BankMoney);
            try {
                Thread.sleep(1000);

                long end = System.currentTimeMillis();
                Log.e("BankT",  "--存入耗时：" + (end - begin));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
       }

    }

    /**
     * 一个与资金操作没有任务关系的同步方法
     */
    public void showInfo() {
        long begin = System.currentTimeMillis();

        String threadName = Thread.currentThread().getName();
        synchronized (this) {
            try {
                Log.e("BankT",threadName + "--开始查看信息");
                Thread.sleep(5000);
                Log.e("BankT",threadName + "--银行详细信息...");
                long end = System.currentTimeMillis();
                Log.e("BankT",threadName + "--查看耗时：" + (end - begin));

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

private class MyRunnableT implements  Runnable{
        Bank mBk;
        int money;
        String  name;
        public MyRunnableT(Bank mk,int money,String name){
            this.mBk=mk;
            this.money=money;
            this.name=name;
        }

        @Override
        public void run() {

            mBk.dopost(money,name);
        }
    } 

private void sync() {
       //  创建当前对象的实例对象
        final Bank bank_1 = new Bank();
        Thread thread_1 = new Thread(new MyRunnableT(bank_1, 200, "小明"),"thread_1");

        Thread thread_2 = new Thread(new Runnable() {
            @Override
            public void run() {
                //调用一个与资金操作没有任务关系的同步方法
                bank_1.showInfo();
            }
        }, "thread_2");
        thread_1.start();
        thread_2.start();

    }

运行结果如下：

从运行结果中，我们看到小刚这个线程平白无故多等了 1 秒钟，严重影响了线程性能。

针对上面的情况，我们可以采用多个实例对象锁的方案解决，比如：

只修改Bank类 创建两个不同的object对象实例锁，

public class Bank {

    private  static  int  BankMoney =1000;
    private final Object syncDopost = new Object(); // 同步锁
    private final Object syncShowInfo = new Object(); // 同步锁

    /***
     * 存钱方法
     * @param money
     * @param names
     */
    public    void  dopost(int  money,String names){
        //设置当前对象的实例对象 
        long begin = System.currentTimeMillis();
        synchronized (this.syncDopost){
            String name = Thread.currentThread().getName();
            Log.e("BankT",name+"-----当前余额："+BankMoney);
            BankMoney+=money;
            Log.e("BankT",name+"-------"+names+"-----存入银行后余额："+BankMoney);
            try {
                Thread.sleep(1000);

                long end = System.currentTimeMillis();
                Log.e("BankT",  "--存入耗时：" + (end - begin));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
       }

    }

    /**
     * 一个与资金操作没有任务关系的同步方法
     */
    public void showInfo() {
        long begin = System.currentTimeMillis();

        String threadName = Thread.currentThread().getName();
        synchronized (this.syncShowInfo) {
            try {
                Log.e("BankT",threadName + "--开始查看信息");
                Thread.sleep(5000);
                Log.e("BankT",threadName + "--银行详细信息...");
                long end = System.currentTimeMillis();
                Log.e("BankT",threadName + "--查看耗时：" + (end - begin));

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

运行结果如下：

我们发现，两个线程间同步被取消了，性能问题也解决了。

总结：可以创建不同同步方法的不同同步锁（减小锁的范围）来优化同步代码块。

4.5同步静态方法

同步静态方法，锁的是类对象而不是某个实例对象，所以可以理解为对于静态方法的锁是全局的锁，同步也是全局的同步。

示例如下：

public class Bank {

    private  static  int  BankMoney =1000;
    /***
     * 存钱方法
     * @param money
     * @param names
     */
    public static synchronized  void  dopost(int  money,String names){
        //设置当前对象的类对象 实现全局锁，
            String name = Thread.currentThread().getName();
            Log.e("BankT",name+"-----当前余额："+BankMoney);
            BankMoney+=money;
            Log.e("BankT",name+"-------"+names+"-----存入银行后余额："+BankMoney);
            try {
                Thread.sleep(1000);

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

    }
    
}
 private void sync() {
       //  创建当前对象的实例对象
        Bank bank_1 = new Bank();
        Bank bank_2 = new Bank();
        Bank bank_3 = new Bank();
        Thread thread_1 = new Thread(new MyRunnableT(bank_1, 200, "小明"),"thread_1");
        Thread thread_2 = new Thread(new MyRunnableT(bank_2, 200, "小张"),"thread_2");
        Thread thread_3 = new Thread(new MyRunnableT(bank_3, 200, "小王"),"thread_3");
        thread_1.start();
        thread_2.start();
        thread_3.start();

    }


    private class MyRunnableT implements  Runnable{
        Bank mBk;
        int money;
        String  name;
        public MyRunnableT(Bank mk,int money,String name){
            this.mBk=mk;
            this.money=money;
            this.name=name;
        }

        @Override
        public void run() {

            mBk.dopost(money,name);
        }
    }

运行结果如下：

 

五总结

同步锁 synchronized ：

  1. synchronized 锁的不是代码，锁的都是对象。

  2. 实例对象锁：同步非静态方法（synchronized method），同步代码块（synchronized (this)，synchronized (类实例对象)）。

  3. 类对象（Class 对象）锁：同步静态方法（synchronized static method），同步代码块（synchronized (类.class)）。

  4. 类的不同的实例拥有不同的实例对象锁，但类对象锁（全局锁）有仅只有一个。

  5. 优化同步代码块的方式有，减少同步区域或减小锁的范围。

  6. Synchronized修饰方法时存在缺陷：若修饰一个大的方法，将会大大影响效率，一般使用 Synchronized关键字声明代码块减小开销。

  7. 从synchronized的特点中可以看到它是一种重量级锁，会涉及到操作系统状态的切换影响效率，所以JDK1.6中对synchronized进行了各种优化，为了能减少获取和释放锁带来的消耗引入了偏向锁和轻量锁。

  8. 当代码段执行结束或出现异常后会自动释放对监视器的锁定
  9. 是非公平锁，在等待获取锁的过程中不可被中断
  10. synchronized的内存语义（详见面试打怪升升级-被问烂的volatile关键字，这次我要搞懂它（深入到操作系统层面理解，超多图片示意图））
  11. 互斥性，被synchronized修饰的方法同时只能由一个线程执行

  

 

囤梦smile
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【多线程】浅说Synchronized
阳阳的博客
04-13 1082
一、前言 synchronized关键字用来保证在同一时刻只有一个线程可以执行被它修饰的变量或者代码块。 这一篇中，只涉及synchronized的底层实现原理，不涉及对synchronized效率以及如何优化的讨论。 二、使用方式 （1）给静态方法加锁 public class Main { public static synchronized void static...
多线程（2）-使用synchronized进行线程同步
conge
01-20 139
前文：java中多线程的锁，分为两种，悲观锁和乐观锁。使用synchronized作为锁的形式，就是悲观锁，又称为同步锁。   一、synchronized原理 在java中，每一个对象有且仅有一个同步锁。同步锁是依赖于对象而存在。 当我们调用某对象的synchronized方法时，就获取了该对象的同步锁。 不同线程对同步锁的访问是互斥的。 通俗一点：N个线程...
在一般程序开发中可以使用synchronized同步多线程
weixin_34409741的博客
01-15 148
假设：有两个boy，都要玩同一个toy，此时就会出现同步情况，必须一个玩好了，另一个才能玩。多线程也是这样子。 如果程序不是高并发的场景，则使用synchronized线程同步足够处理。 synchronized关键字解释（synchronized(this)同步代码块也可以被替换为同步对象方法或者同步类方法，本质是一样的）： 多个线程，访问同一个对象中的synchronized(this)同...
多线程——synchronized详解
Pluto372的博客
10-13 3256
互斥同步是一种最常见也是最主要的并发正确性保障手段。同步是指在多个线程并发访问共享数据时，保证共享数据在同一个时刻只被一条（或者是一些， 当使用信号量的时候）线程使用。而互斥是实现同步的一种手段，临界区（Critical Section）、互斥量 （Mutex）和信号量（Semaphore）都是常见的互斥实现方式。因此在“互斥同步”这四个字里面，互斥是因，同步是果；互斥是方法，同步是目的。在Java里面，最基本的互斥同步手段就是synchronized关键字。
【多线程进阶】synchronized的总结
热门推荐
书生-w的博客
04-03 2万+
如果某一个资源被多个线程共享，为了避免因为资源抢占导致资源数据错乱，我们需要对线程进行同步，那么synchronized就是实现线程同步的关键字，可以说在并发控制中是必不可少的部分，今天就来看一下synchronized的使用和底层原理。
Java多线程之synchronized&volatile基础篇
12-20
在Java编程语言中，多线程是实现并发执行任务的关键机制。线程是操作系统调度的基本单元，它在进程中运行，负责执行特定的代码序列。在Java中，有多种方式来创建和管理线程。 首先，我们可以继承`Thread`类来创建...
Java第九章多线程程序设计基础篇.ppt
11-13
Java 多线程程序设计基础 多线程程序设计是 Java 语言的一个重要特性，允许程序同时执行多个任务，从而提高程序的效率和响应速度。本章将详细介绍 Java 多线程程序设计的基础知识。 §9.1 线程的概念 在 Java 中...
Java多线程之基础篇(二).docx
04-16
Java提供了多种线程安全的类，如ConcurrentHashMap、BlockingQueue等，以及并发工具类如Semaphore、CyclicBarrier等，帮助开发者编写高效的多线程程序，避免了手动同步的复杂性。 总的来说，Java多线程编程涉及许多...
Java多线程之基础篇(一).docx
04-16
`synchronized`关键字用于控制多线程对共享资源的访问，确保同一时间只有一个线程可以访问特定的代码块或方法。 2. Synchronized基本原则和实例 当一个线程进入synchronized代码块或方法后，其他试图进入的线程会...
Java多线程同步Synchronized深入解析
12-22
同步的概念： 　　同步分为同步方法和同步块两种方式。 　　锁定的内容分为锁定类的某个特定实例和锁定类对象（类的所有实例） 　　变量分为实例变量（不带static的变量）和类变量（带static的变量） 　　使用同步的原因 　　1、在系统中对访类要使用多线程进行访问； 　　2、在该类中有 类变量，或者是 在类的方法中有访问公共资源（如一个外部文件的读写）。 　　同步锁锁定的内容是什么？ 　　无论你将Synchronized加在方法前还是加在一个变量前，其锁定的都是一个 类对象。每一个对象都只有一个锁与之相关联。 　　下例中分情况的列举各种情况下的同步效果
线程安全你还在用synchronized?
08-07
你还在用synchronized？线程安全相关知识深入剖析
java多线程基础篇讲解
03-11
Java多线程基础篇讲解是针对初学者设计的教程，旨在用简洁明了的语言帮助学习者更容易理解多线程的概念和应用。多线程编程在现代计算机系统中扮演着重要角色，尤其在CPU主频发展遇到瓶颈的情况下，通过超线程技术和...
多线程-synchronized详解
最新发布
qq_42251944的博客
01-08 497
当某个线程尝试获取其它线程已经持有的锁时，尝试获取锁的线程就会阻塞。但是，内置锁synchronized是可重入的，如果某个线程尝试获取由自己已经持有的锁时，请求成功。另外，关键字synchronized修饰的方法，整个方法体就是同步代码块，锁的对象是调用当前方法的对象；需要注意的是，静态方法以对象的字节码文件为（.class文件）作为锁对象。1、基本作用：Java提供了一种内置的锁机制来支持原子性，同步代码块（Synchronized Block ）锁重入表示获取锁的粒度是线程。（1）编写一个同步方法。
Java Synchronized 重量级锁原理深入剖析上(互斥篇)
09-15 1781
前言 上篇文章分析了偏向锁、轻量级锁的演变过程，本篇将分析重头戏：重量级锁的原理。 通过本篇文章，你将了解到： 1、ObjectMonitor 的运用 2、锁的膨胀过程 3、重量级锁的加锁流程 4、重量级锁的解锁流程 5、重量级锁小结 6、与偏向锁、轻量级锁的比对 1、ObjectMonitor 的运用 我们知道当锁处在轻量级锁的状态时，Mark Word 存放着指向Lock Record指针，Lock Record是线程私有的。 而处在重量级锁状态时说明有线程没拿到锁需要阻塞等待锁，当拥有锁的线程释放
多线程（synchronized）
zxx862309181的博客
05-18 744
synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种： 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象； 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的
同步方法（Synchronized Methods）
平凡
07-05 3368
java编程语言提供两种基本的同步方式：同步方法和同步代码块，其中比较复杂的同步代码块会在下一节当中讨论，这一节主要是讲解同步方法。   为了实现方法同步，只要简单的将关键字synchronized添加到方法的声明处，如：public class SynchronizedCounter{ private int c = 0; public synchronized void incre
多线程—synchronized
qq_42251944的博客
10-20 768
synchronized俗称对象锁，它采用互斥的方式让同一时刻至多只有一个线程持有对象锁，其他线程想获取这个对象锁时就会阻塞，这样就不用担心上下文切换。 关系：synchronized使用对象锁保证了临界区（下面有介绍）内代码的原子性（完整性），临界区内的代码对外是不可分割的，不会被线程上下文切换所打断。 注意：同一个临界区，线程访问的对象锁应该是一致的，就好比进入同一个房间，钥匙必须都是那一把，才能达到锁住的目的。 Java中互斥和同步都可以采用synchronized来完成，但有区别： （1）互
GLES3.0中文API-glFenceSync
MSK1111的博客
02-11 3104
名称 glFenceSync — 创建一个新的同步对象并将其插入GL命令流 C 规范 GLsync glFenceSync( GLenum condition, GLbitfield flags); 参数 condition 指定将同步对象的状态设置为已发出信号必须满足的条件。条件必须为GL_SYNC_GPU_COMMANDS_COMPLETE。 flags 指定控制同步对象行为的标志的按位组合。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值