投稿
  1. 极客之音首页
  2. 后端开发

JavaSE进阶 | 深入理解多线程（线程安全synchronized）

飞熊 • • 后端开发 • 阅读 219

追求适度，才能走向成功；人在顶峰，迈步就是下坡；身在低谷，抬足既是登高；弦，绷得太紧会断；人，思虑过度会疯；水至清无鱼，人至真无友，山至高无树；适度，不是中庸，而是一种明智的生活态度。

导读：本篇文章讲解 JavaSE进阶 | 深入理解多线程（线程安全synchronized），希望对大家有帮助，欢迎收藏，转发！站点地址：www.bmabk.com，来源：原文

目录

一：线程安全（很重要）

1.模拟两个线程对同一个银行账户取款（不使用线程同步）

二：使用线程同步机制（synchronized）

1.模拟两个线程对同一个银行账户取款（使用线程同步）

2.sychronized的理解 

3.那些变量有线程安全问题

4.sychronized出现在实例方法上

5.总结synchronized的三种写法： 

6. 经典面试题

7.死锁概述（会写死锁代码）

8.开发中怎么解决线程安全问题

一：线程安全（很重要）

关于多线程并发环境下，数据的安全问题：

1、为什么这个线程安全是重点？
      在以后在开发中，我们的项目都是运行在服务器当中，而服务器已经将线程的定义，线程对象的创建，启动等，都已经实现完了。这些代码我们都不需要编写。

      最重要的是：我们要知道，你编写的程序需要放到一个多线程的环境下运行，你更需要关注的是这些数据在多线程并发的环境下是否是安全的

      我们举个生活中的简单例子：线程并发对同一个账户取款。我和小鹏同时去取款，我是把钱取出来，如果因为数据延迟，没有及时更新账户；此时小鹏再去取款也取出来了，这就会造成数据的不安全！

JavaSE进阶 | 深入理解多线程（线程安全synchronized）

2、什么时候数据在多线程并发的环境下会存在线程安全问题？
            条件1：多线程并发。
            条件2：有共享数据。
            条件3：共享数据有修改的行为。

        满足以上3个条件之后，就会存在线程安全问题。   
3、怎么解决线程安全问题？线程同步机制
        当多线程并发的环境下，有共享数据，并且这个数据还会被修改，此时就存在线程安全问题，怎么解决这个问题？
        线程排队执行（不能并发）；用排队执行解决线程安全问题；这种机制被称为：线程同步机制。专业术语叫做：线程同步，实际上就是线程不能并发了，线程必须排队执行！   
        线程同步就是线程排队了，线程排队了就会牺牲一部分效率，数据安全第一位，只有数据安全了，我们才可以谈效率。   
4、说到线程同步这块，涉及到这两个专业术语：

        异步编程模型：线程t1和线程t2，各自执行各自的，t1不管t2，t2不管t1，谁也不需要等谁，这种编程模型叫做：异步编程模型。其实就是：多线程并发（效率较高）

        同步编程模型：线程t1和线程t2，在线程t1执行的时候，必须等待t2线程执行结束，或者说在t2线程执行的时候，必须等待t1线程执行结束，两个线程之间发生了等待关系，这就是同步编程模型。效率较低。线程排队执行。

总结： 异步就是并发； 同步就是排队！

1.模拟两个线程对同一个银行账户取款（不使用线程同步）

1、Account账户类

创建一个账户类Account，在里面定义一个取款方法withdraw；并且模拟网络延迟，让它睡1秒，此时两个线程并发访问，在第一个线程访问还没有来得及更新数据时，第二个线程数据会出现什么样的情况？

package com.bjpowernode.java.threadsafe;
// 银行账户
public class Account {
    // 账号
    private String actno;
    // 余额
    private double balance;

    // 构造方法
    public Account() {
    }
    public Account(String actno, double balance) {
        this.actno = actno;
        this.balance = balance;
    }

    // setter and getter
    public String getActno() {
        return actno;
    }
    public void setActno(String actno) {
        this.actno = actno;
    }
    public double getBalance() {
        return balance;
    }
    public void setBalance(double balance) {
        this.balance = balance;
    }

    // 取款方法
    public void withdraw(double money){
        // 取款之前的余额
        double before = this.getBalance();
        // 取款之后的余额
        double after = before - money;

        // 更新余额之前，进行睡眠1秒肯定会出问题
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 更新余额
        this.setBalance(after);

    }

}

2、两个线程对同一个账户取款

把账户对象作为属性传过来，然后通过构造方法进行赋值。

package com.bjpowernode.java.threadsafe;

public class AccountThread extends Thread{
    // 保证两个线程共享一个账户对象
    private Account act;
    // 通过构造方法传递过来账户对象
    public AccountThread(Account act) {
        this.act = act;
    }
      public void run() {
        // 假设取款5000
        double money = 5000;
        // 取款
        // 多线程并发执行这个方法
        act.withdraw(money);
        System.out.println(Thread.currentThread().getName()+
        "对账户"+act.getActno()+"取款成功，余额"+act.getBalance());
    }
}

3、测试

创建一个账户对象，目的是让两个线程操作同一个账户。

package com.bjpowernode.java.threadsafe;

public class Test {
    public static void main(String[] args) {
        // 创建对象
        Account act = new Account("act---1",10000);
        // 创建两个线程
        Thread t1 = new AccountThread(act);
        Thread t2 = new AccountThread(act);
        // 设置线程名字
        t1.setName("t1");
        t2.setName("t2");
        // 启动线程
        t1.start();
        t2.start();
    }
}
/*
t1对账户act---1取款成功，余额5000.0
t2对账户act---1取款成功，余额5000.0
*/

二：使用线程同步机制（synchronized）

1、线程同步机制的语法是：

synchronized("数据"){
             // 线程同步代码块。
           }

synchronized后面小括号中传的这个“数据”是相当关键的；这个数据必须是多线程共享的数据；才能达到多线程排队！

2、()中写什么？
    （1）要看你想让哪些线程同步；假设t1、t2、t3、t4、t5，有5个线程；你只希望t1 t2 t3排队，t4 t5不需要排队。怎么办？你一定要在()中写一个t1 t2 t3共享的对象。而这个对象对于t4 t5来说不是共享的。

    （2）这里的共享对象是：账户对象；账户对象是共享的，那么this就是账户对象吧！当然不一定是this，这里只要是多线程共享的那个对象就行

    （3）在java语言中，任何一个对象都有“一把锁”，其实这把锁就是标记！100个对象，100把锁。1个对象1把锁。对于锁的理解：相当于我们去上厕所，把门锁上，别人进不来；等解决了，打开锁别人才能进来！

3、以下代码的执行原理？
   （1）假设t1和t2线程并发，开始执行以下代码的时候，肯定有一个先一个后。
   （2）假设t1先执行了，遇到了synchronized，这个时候自动找“后面共享对象”的对象锁，找到之后，并占有这把锁，然后执行同步代码块中的程序，在程序执行过程中一直都是占有这把锁的。直到同步代码块代码结束，这把锁才会释放。
   （3）假设t1已经占有这把锁，此时t2也遇到synchronized关键字，也会去占有后面共享对象的这把锁，结果这把锁被t1占有，t2只能在同步代码块外面等待t1的结束，直到t1把同步代码块执行结束了，t1会归还这把锁，此时t2终于等到这把锁，然后t2占有这把锁之后，进入同步代码块执行程序。这样就达到了线程排队执行。
注意：这个共享对象一定要选好了；这个共享对象一定是你需要排队执行的这些线程对象所共享的！

1.模拟两个线程对同一个银行账户取款（使用线程同步）

在第一个线程更新数据之前，把这个对象锁起来，不让其它线程使用！

package com.bjpowernode.java.Threadsafe2;
// 使用线程同步，解决线程安全问题

// 银行账户
public class Account {
    // 账号
    private String actno;
    // 余额
    private double balance;

    // 构造方法
    public Account() {
    }
    public Account(String actno, double balance) {
        this.actno = actno;
        this.balance = balance;
    }

    // setter and getter
    public String getActno() {
        return actno;
    }
    public void setActno(String actno) {
        this.actno = actno;
    }
    public double getBalance() {
        return balance;
    }
    public void setBalance(double balance) {
        this.balance = balance;
    }

    // 取款方法，t1和t2并发这个方法
    // t1和t2是两个栈，两个栈操作堆中同一个对象
    public void withdraw(double money){
        // 以下这几行代码必须是线程排队的，不能并发。
        // 一个线程把这里的代码全部执行结束之后，另一个线程才能进来。
        // 线程同步机制，线程同步执行
        // this就是指当前共享的对象Account账户
        synchronized (this){
            double before = this.getBalance();
            double after = before - money;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            this.setBalance(after);
        }

    }

}
/*
t1对账户act---1取款5000.0成功，余额5000.0
t2对账户act---1取款5000.0成功，余额0.0
*/

线程生命周期流程图进行补充： 

JavaSE进阶 | 深入理解多线程（线程安全synchronized）

2.sychronized的理解 

不写this写其它的一个共享的对象；这里写this和“abc”是没区别的！

一定要理解只要是两个线程的共享对象就可以，例如：this就是当前的账户对象Account、字符串“abc”，在字符串常量池中也是共享的、Account对象中的实例变量也是共享的；只不过最终的范围可能是不同！

package com.bjpowernode.java.threadsafe2;
/*
银行账户
    使用线程同步机制，解决线程安全问题。
 */
public class Account {
    // 账号
    private String actno;
    // 余额
    private double balance; //实例变量。

    //对象
    Object obj = new Object(); // 实例变量。
   //（Account对象是多线程共享的，Account对象中的实例变量obj也是共享的。）

    public Account() {
    }

    public Account(String actno, double balance) {
        this.actno = actno;
        this.balance = balance;
    }

    public String getActno() {
        return actno;
    }

    public void setActno(String actno) {
        this.actno = actno;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    //取款的方法
    public void withdraw(double money){

        //int i = 100;
        //i = 101;

        // 以下这几行代码必须是线程排队的，不能并发。
        // 一个线程把这里的代码全部执行结束之后，另一个线程才能进来。
       
        //Object obj2 = new Object();
         synchronized (this){ // 只要是一个共享对象就行
        //synchronized (obj) { // 实例变量，Account对象是共享的，它的实例对象也可以
        //synchronized ("abc") { // "abc"在字符串常量池当中；写"abc"所有线程都会同步
        //synchronized (null) { // 报错：空指针。
        //synchronized (obj2) { // 局部变量。因为obj2不是共享对象；每次调用都会new
            double before = this.getBalance();
            double after = before - money;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.setBalance(after);
        //}
    }
}

既然共享对象可以有多种，那么有什么区别呢？

如果修改下面代码，就不同了；使用this表示同一个线程对象Account，this表示t1和t2是线程同步的，和t3没有关系；如果写”abc”那就是t1,t2,t3都是线程同步的！

package com.bjpowernode.java.threadsafe2;

public class Test {
    public static void main(String[] args) {
        // 创建账户对象（只创建1个）
        Account act = new Account("act-001", 10000);
        // 创建两个线程
        Thread t1 = new AccountThread(act);
        Thread t2 = new AccountThread(act);
        // 又new对象，创建一个线程
		Account act2 = new Account("act-001", 10000);
		Thread t3 = new AccountThread(act2);
        // 设置name
        t1.setName("t1");
        t2.setName("t2");
        // 启动线程取款
        t1.start();
        t2.start();
    }
}

扩大同步范围，不能写this，只能写当前对象！

我们也可以在调用withdraw方法的时候才加上线程同步，此时相当于扩大了同步的范围；但是一定要注意：此时就不能写this了，此时this指的是AccountThread对象；只能写账户对象Account才可以。

package com.bjpowernode.java.Threadsafe2;

public class AccountThread extends Thread{
    // 保证两个线程共享一个账户对象
    private Account act;
    // 通过构造方法传递过来账户对象
    public AccountThread(Account act) {
        this.act = act;
    }
      public void run() {
        // 假设取款5000
        double money = 5000;
        // 取款
        // 多线程并发执行这个方法

        synchronized(act){ 
        // 共享对象是act，不能写this，this代表的是线程对象AccountThread，
        // 但是线程对象我们new了两个，不是共享的，这里扩大了同步范围
            act.withdraw(money); // 在这里加synchronized，扩大了同步范围
        }
        
        System.out.println(Thread.currentThread().getName()+"对"+"账户"+act.getActno()+"取款"+money+"成功，余额"+act.getBalance());
    }
}

3.那些变量有线程安全问题

1、Java中有三大变量【重要的内容】

我们知道对于进程，内存是独立不共享的；对于线程堆区和方法区是共享的，栈区是一个线程一个栈，不共享！那么对于Java中的三大变量：实例变量：在堆中、静态变量：在方法区、局部变量：在栈中；很明显只有实例变量和静态变量是共享的！（成员变量共享）

2、以上三大变量中：

（1）局部变量永远都不会存在线程安全问题！因为局部变量不共享。（一个线程一个栈）局部变量在栈中，所以局部变量永远都不会共享。
（2）实例变量在堆中，堆只有1个。
（3）静态变量在方法区中，方法区只有1个。

3、堆和方法区都是多线程共享的，所以可能存在线程安全问题

局部变量+常量：不会有线程安全问题。
成员变量：可能会有线程安全问题。（实例变量+静态变量）

4.sychronized出现在实例方法上

1、在实例方法上可以使用synchronized吗？可以的。
（1）synchronized出现在实例方法上，一定锁的是this；没得挑，只能是this。

（2）缺点：

缺点一：只能是this，不能是其他的对象了，所以这种方式不灵活。

缺点二：synchronized出现在实例方法上，表示整个方法体都需要同步，可能会无故扩大同步的范围，导致程序的执行效率降低；所以这种方式不常用。

public synchronized void withdraw(double money){}

（3）synchronized使用在实例方法上有什么优点：代码写的少了，节俭了。

（4）如果共享的对象就是this，并且需要同步的代码块是整个方法体，建议使用这种方式。

package com.bjpowernode.java.threadsafe3;

// 银行账户
public class Account {
    // 账号
    private String actno;
    // 余额
    private double balance;

    // 构造方法
    public Account() {
    }
    public Account(String actno, double balance) {
        this.actno = actno;
        this.balance = balance;
    }

    // setter and getter
    public String getActno() {
        return actno;
    }
    public void setActno(String actno) {
        this.actno = actno;
    }
    public double getBalance() {
        return balance;
    }
    public void setBalance(double balance) {
        this.balance = balance;
    }

    // 取款的方法
    public synchronized  void withdraw(double money){ // 同步整个方法体
        double before = this.getBalance();
        double after = before - money;
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        this.setBalance(after);

    }

}

5.总结synchronized的三种写法： 

第一种：同步代码块，比较灵活

当然也可以在调用需要同步代码的方法时在写上，就像前面所说，在调用withdraw时在加上线程同步，扩大了同步范围；并且同步对象只能写共享对象，不能写this了。

synchronized(线程共享对象){
                同步代码块;
            }

第二种：在实例方法上使用synchronized

表示共享对象一定是this，并且同步代码块是整个方法体，可能会扩大同步的范围。

  public synchronized  void withdraw(double money){}

第三种：在静态方法上使用synchronized表示找类锁，类锁永远只有1把。

就算创建了100个对象，那类锁也只有一把！        
对象锁：1个对象1把锁，100个对象100把锁！
类锁：100个对象，也可能只是1把类锁！

6. 经典面试题

synchronized面试题1：

面试题：doOther方法执行的时候需要等待doSome方法的结束吗？
答：不需要，doSome执行时候会把这把锁占着，但是doOther()方法没有synchronized，不需要占用锁，直接就能执行

package com.bjpowernode.java.exam;

public class Exam01 {
    public static void main(String[] args) {
        MyClass mc = new MyClass();
        Thread t1 = new MyThread(mc);
        Thread t2 = new MyThread(mc);
        t1.setName("t1");
        t2.setName("t2");

        t1.start();
        try {
            Thread.sleep(1000); //这个睡眠的作用：为了保证t1线程先执行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();


    }
}

// 线程
class MyThread extends Thread{
    private MyClass mc;
    public MyThread(MyClass mc) {
        this.mc = mc;
    }

    public void run() {
        if(Thread.currentThread().getName().equals("t1")){
            mc.doSome();
        }
        if(Thread.currentThread().getName().equals(("t2"))){
            mc.doOther();
        }
    }
}

class MyClass {

    // doSome方法有synchronized，锁的是当前对象MyClass
    public synchronized void doSome(){
        System.out.println("doSome begin");
        try {
            Thread.sleep(1000 * 10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("doSome over");
    }

    // doOther方法没有synchronized
    public void doOther(){
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
}
/* 执行结果：
    doSome begin
    doOther begin
    doOther over
    doSome over
*/

synchronized面试题2：

面试题：doOther方法执行的时候需要等待doSome方法的结束吗？
答：需要，doSome执行时候会把这把锁占着，doOther()方法里也有synchronized，也需要占用这把锁去执行，所以需要等待doSome执行结束

package com.bjpowernode.java.exam;

public class Exam01 {
    public static void main(String[] args) {
        MyClass mc = new MyClass();
        Thread t1 = new MyThread(mc);
        Thread t2 = new MyThread(mc);
        t1.setName("t1");
        t2.setName("t2");

        t1.start();
        try {
            Thread.sleep(1000); //这个睡眠的作用：为了保证t1线程先执行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();


    }
}

// 线程
class MyThread extends Thread{
    private MyClass mc;
    public MyThread(MyClass mc) {
        this.mc = mc;
    }

    public void run() {
        if(Thread.currentThread().getName().equals("t1")){
            mc.doSome();
        }
        if(Thread.currentThread().getName().equals(("t2"))){
            mc.doOther();
        }
    }
}

class MyClass {

    // doSome方法有synchronized，锁的是当前对象MyClass
    public synchronized void doSome(){
        System.out.println("doSome begin");
        try {
            Thread.sleep(1000 * 10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("doSome over");
    }

    // doOther方法也有synchronized
    public synchronized void doOther(){
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
}
/* 执行结果：
    doSome begin
    doSome over
    doOther begin
    doOther over
*/

synchronized面试题3：

面试题：doOther方法执行的时候需要等待doSome方法的结束吗？
答：不需要，调用的不是同一个对象；doSome方法锁的是mc1对象，doSome方法锁的是mc2对象，这里是两把锁

package com.bjpowernode.java.exam03;

public class Exam02 {
    public static void main(String[] args) {
        // 创建了两个对象
        MyClass mc1 = new MyClass();
        MyClass mc2 = new MyClass();

        Thread t1 = new MyThread(mc1);
        Thread t2 = new MyThread(mc2);
        t1.setName("t1");
        t2.setName("t2");

        t1.start();
        try {
            Thread.sleep(1000); //这个睡眠的作用：为了保证t1线程先执行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();


    }
}

// 线程
class MyThread extends Thread{
    private MyClass mc;
    public MyThread(MyClass mc) {
        this.mc = mc;
    }

    public void run() {
        if(Thread.currentThread().getName().equals("t1")){
            mc.doSome();
        }
        if(Thread.currentThread().getName().equals(("t2"))){
            mc.doOther();
        }
    }
}

class MyClass {

    // doSome方法有synchronized，锁的是当前对象MyClass
    public synchronized void doSome(){
        System.out.println("doSome begin");
        try {
            Thread.sleep(1000 * 10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("doSome over");
    }

    // doOther方法也有synchronized
    public synchronized void doOther(){
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
}
/* 执行结果：
    doSome begin
    doOther begin
    doOther over
    doSome over

*/

synchronized面试题4：

面试题：doOther方法执行的时候需要等待doSome方法的结束吗？
答：都改成静态方法，synchronized出现在静态方法上是找类锁；需要等待，因为静态方法是类锁，不管创建了几个对象，类锁只有1把！

package com.bjpowernode.java.exam04;


public class Exam02 {
    public static void main(String[] args) {
        MyClass mc1 = new MyClass();
        MyClass mc2 = new MyClass();

        Thread t1 = new MyThread(mc1);
        Thread t2 = new MyThread(mc2);
        t1.setName("t1");
        t2.setName("t2");

        t1.start();
        try {
            Thread.sleep(1000); //这个睡眠的作用：为了保证t1线程先执行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();


    }
}

// 线程
class MyThread extends Thread{
    private MyClass mc;
    public MyThread(MyClass mc) {
        this.mc = mc;
    }

    public void run() {
        if(Thread.currentThread().getName().equals("t1")){
            mc.doSome();
        }
        if(Thread.currentThread().getName().equals(("t2"))){
            mc.doOther();
        }
    }
}

class MyClass {

    // doSome方法有synchronized，锁的是当前对象MyClass
    public synchronized static void doSome(){
        System.out.println("doSome begin");
        try {
            Thread.sleep(1000 * 10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("doSome over");
    }

    // doOther方法也有synchronized
    public synchronized static void doOther(){
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
}
/* 执行结果：
    doSome begin
    doSome over
    doOther begin
    doOther over

*/

7.死锁概述（会写死锁代码）

假设有两个线程，线程中含有两个相同的对象；T1是从上往下执行，T2对象是从下往上执行；T1先锁了上面一个对象，T2先锁住了下面一个对象；这就造成T1锁下面对象锁不了，T2锁上面对象锁不了；这样代码都不会执行结束，也就不会释放锁；不会出现异常，也不会出现错误，程序一直僵持在那里，比较难调试出来的错误！

JavaSE进阶 | 深入理解多线程（线程安全synchronized）

要会写死锁代码：

package com.bjpowernode.java.deadlock;

public class DeadLock {
    public static void main(String[] args) {
        Object o1 = new Object();
        Object o2 = new Object();

        Thread t1 = new MyThread1(o1,o2);
        Thread t2 = new MyThread2(o1,o2);

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

class MyThread1 extends Thread{
    Object o1;
    Object o2;

    public MyThread1(Object o1, Object o2) {
        this.o1 = o1;
        this.o2 = o2;
    }

    public void run() {
        // 先锁o1，在锁o2
        synchronized (o1){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o2){

            }
        }


    }
}

class MyThread2 extends Thread{
    Object o1;
    Object o2;

    public MyThread2(Object o1, Object o2) {
        this.o1 = o1;
        this.o2 = o2;
    }

    public void run() {
        // 先锁o2，在锁o1
        synchronized (o2){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o1){

            }
        }

    }
}

8.开发中怎么解决线程安全问题

（1）是一上来就选择线程同步吗？synchronized
不是，synchronized会让程序的执行效率降低，用户体验不好；系统的用户吞吐量降低。用户体验差；在不得已的情况下再选择线程同步机制。
（2）第一种情况：尽量使用局部变量代替“实例变量和静态变量”。

（3）第二种情况：如果必须是实例变量，那么可以考虑创建多个对象，这样实例变量的内存就不共享了。（一个线程对应1个对象，100个线程对应100个对象，对象不共享，就没有数据安全问题了）

（4）第三种情况：如果不能使用局部变量，对象也不能创建多个，这个时候就只能选择synchronized了；线程同步机制。

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

文章由极客之家整理，本文链接：https://www.bmabk.com/index.php/post/128470.html

赞 (0)
飞熊的头像飞熊bm
0 0

相关推荐

发表回复

登录后才能评论
极客之家——专业性很强的中文编程技术网站，欢迎收藏到浏览器，订阅我们！