美文网首页android系统进阶
同步、异步、类锁、对象锁

同步、异步、类锁、对象锁

作者: 勤学奋进小郎君 | 来源:发表于2018-12-26 21:47 被阅读0次

同步

一个任务的执行，需要依赖另一个任务的完成。
标准的程序执行流程就是同步的，只有上一个函数执行完成，下一个函数才可以开始执行，这就是依赖关系

异步

一个任务的执行，不需要依赖另一个任务的完成。
并发的概念，只需要告诉另一个任务需要干什么，它会直接去执行

对象锁：只有竞争同一个对象的时候

  • synchronized修饰非静态方法、代码块synchronized (this)、synchronized (非this对象)线程要执行对应的同步代码，需要获取对象锁

锁住方法

先展示一个没有锁的例子，他的输出结果根据代码可以知道，因为我们实例化了一个对象，然后先开启了一个线程传了一个参数a过去，执行到System.out.println("a arrived");他就开始睡眠2s，于此同时又开启了另一个线程，同样调用的是同一对象的同一个方法，传递了b过去，所以出现下面这个结果

public class main {

    public static void main(String[] args) throws IOException {
        person p = new person();
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                try {
                    p.addstr("a");
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                try {
                    p.addstr("b");
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }).start();
        }
    }


class person{
    private int number = 0;
    public void addstr(String string) throws InterruptedException {
        if (string.equals("a")) {
            number = 100;
            System.out.println("a arrived");
            Thread.sleep(2000);
        }else {
            number = 200;
            System.out.println("b arrived");
            }
        System.out.println(string + " number=" + String.valueOf(number));
        }
    }

输出结果：

a arrived
b arrived
b number=200
a number=200

稍作更改给addstr方法加上锁，这时候多线程竞争同一个对象的带锁的方法时，就要按顺序来，要等上一个调用释放锁

class person{
    private int number = 0;
    synchronized public void addstr(String string) throws InterruptedException {
        if (string.equals("a")) {
            number = 100;
            System.out.println("a arrived");
            Thread.sleep(2000);
        }else {
            number = 200;
            System.out.println("b arrived");
            }
        System.out.println(string + " number=" + String.valueOf(number));
        }
    }

还有一种情况就是，锁住一个类的两个方法，两个线程同时调用锁住的不同对象，这种情况，经过测试，输出结果显示，执行第二个被锁住的方法也需要等待，也就是一个类内，使用一个锁，锁住一个或多个方法。

        person p = new person();
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                try {
                    p.printA(string);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                try {
                    p.printB(string);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }).start();
        }
    }


class person{
    private int number = 0;
    synchronized public void printA(String string) throws InterruptedException {
        System.out.println("A 进入线程！");
        Thread.sleep(2000);
        System.out.println("A 离开线程！");
        }
    
    synchronized public void printB(String string) throws InterruptedException {
        System.out.println("B 进入线程！");
        System.out.println("B 离开线程！");
        }
}

输出结果：

A 进入线程！
A 离开线程！
B 进入线程！
B 离开线程！

synchronized (this)

再次对上面的person类稍作修改，我们锁住一个代码块，同样的当多个线程竞争同一个对象的这个代码块时需要按照锁的规矩来，上一个释放，下一个才可以使用，输出结果同上

class person{
    private int number = 0;
    public void addstr(String string) throws InterruptedException {
        synchronized(this) {
        if (string.equals("a")) {
            number = 100;
            System.out.println("a arrived");
            Thread.sleep(2000);
        }else {
            number = 200;
            System.out.println("b arrived");
            }
        System.out.println(string + " number=" + String.valueOf(number));
        }
        }
    }

这里需要注意一下，因为多线程只有竞争这个代码块的内容才是使用锁的规矩，也就是这个代码块上面、下面都是不同步的，修改一下代码，这个这个同步代码块上面、下面加上两句输出System.out.println(string + "来了");、System.out.println(string + " number=" + String.valueOf(number));，这个时候输出结果有下面两种结果。首先解释一个b来了的输出，因为System.out.println(string + "来了");这一句没有锁，所以在第一个带有参数a睡眠的时候，第二个线程运行到这里输出完b来了，它就在这里等着，等第一个线程释放了锁，它才能继续执行。至于结果有两种，则是因为另外一个输出语句System.out.println(string + " number=" + String.valueOf(number));没有上锁，完全根据谁快、谁执行，或者并发执行都是可以的

class person{
    private int number = 0;
    public void addstr(String string) throws InterruptedException {
        System.out.println(string + "来了");
        synchronized(this) {
        if (string.equals("a")) {
            number = 100;
            System.out.println("a arrived");
            Thread.sleep(2000);
        }else {
            number = 200;
            System.out.println("b arrived");
            }
        }
        System.out.println(string + " number=" + String.valueOf(number));
        }
    }

输出结果：

a来了
a arrived
b来了
b arrived
a number=100
b number=200

或者

a来了
a arrived
b来了
b arrived
b number=200
a number=200

同样的，synchronized (this)也存在同一个类中，使用一个锁锁住一个或多个代码块，但是代码块上下是不同步的

class person{
    public String son;
    public person(String son) {
        this.son = son;
    }
    private int number = 0;
    synchronized public void printA(String string) throws InterruptedException {
        System.out.println("A 进入线程！");
        Thread.sleep(2000);
        System.out.println("A 离开线程！");
        }
    
    public void printB(String string) throws InterruptedException {
        System.out.println("B ready!");
        synchronized (this) {
        System.out.println("B 进入线程！");
        System.out.println("B 离开线程！");
        }
    }

输出结果：

A 进入线程！
B ready!
A 离开线程！
B 进入线程！
B 离开线程！

synchronized (非this对象)

只要多线程访问的对象带有被锁住的对象，并且是同一个，就需要按照锁的规则来，就像下面的例子，虽然实例化了两个不同的对象，但是他们访问的都是同一个String对象，就有竞争关系。其实可以被锁住的对象就像一个标记，任何线程使用了这个被锁住的对象，就相当于被标记了，被标记的线程执行到synchronized声明的地方，就要按顺序来，不存在并发进行

public static void main(String[] args) throws IOException {
        String string = "son";
        person p = new person(string);
        person p1 = new person(string);
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                try {
                    p.addstr("a");
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                try {
                    p1.addstr("b");
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }).start();
        }
    }


class person{
    public String son;
    public person(String son) {
        this.son = son;
    }
    private int number = 0;
    public void addstr(String string) throws InterruptedException {
        System.out.println(string + "来了");
        synchronized(son) {
        if (string.equals("a")) {
            number = 100;
            System.out.println("a arrived");
            Thread.sleep(2000);
        }else {
            number = 200;
            System.out.println("b arrived");
            }
        }
        System.out.println(string + " number=" + String.valueOf(number));
        }
    }

类锁

  • synchronized修饰静态方法、synchronized(类.class),锁的是对应的类，需要获取类锁
    类锁其实也是使用对象锁，当加载一个class文件时，会创建一个java.lang.Class类的实例，锁一个类的时候就是锁住java.lang.Class类的实例

下面这个例子，是对象锁，使用不同person对象，即使用了不同的锁锁住person对象

        String string = "son";
        person p = new person(string);
        person p1 = new person(string);
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                try {
                    p.printA(string);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                try {
                    p1.printB(string);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }).start();
        }
    }


class person{
    public String son;
    public person(String son) {
        this.son = son;
    }
    private int number = 0;
    synchronized public  void printA(String string) throws InterruptedException {
        System.out.println("A 进入线程！");
        Thread.sleep(2000);
        System.out.println("A 离开线程！");
        }
    
    synchronized public  void printB(String string) throws InterruptedException {
        System.out.println("B ready!");
        System.out.println("B 进入线程！");
        System.out.println("B 离开线程！");
    }
}

对象锁的输出结果：

A 进入线程！
B ready!
B 进入线程！
B 离开线程！
A 离开线程！

稍作修改加上static，让我们使用类锁，即使实例化了不同的对象，但是使用的同一个类，这时候的输出结果就不一样了，这里还用了同一个类，使用一个锁锁住一个或多个方法、代码块

class person{
    public String son;
    public person(String son) {
        this.son = son;
    }
    private int number = 0;
    synchronized public static void printA(String string) throws InterruptedException {
        System.out.println("A 进入线程！");
        Thread.sleep(2000);
        System.out.println("A 离开线程！");
        }
    
    synchronized public static void printB(String string) throws InterruptedException {
        System.out.println("B ready!");
        System.out.println("B 进入线程！");
        System.out.println("B 离开线程！");
    }
}

输出结果：

A 进入线程！
A 离开线程！
B ready!
B 进入线程！
B 离开线程！

再次引入一个小心得点：类锁和对象锁混用
同样使用上面的方法代码稍微修改了一下，可以从输出结果看出，使用对象锁的代码块，即使是同一个对象，也没有执行锁的机制，说明了类锁和对象锁混用的情况下，只有类锁有效，对象锁无效

this: 表示当前类实例化后的对象

        person p = new person(string);
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                try {
                    p.printA(string);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                try {
                    p.printB(string);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }).start();
        }
    }

class person{
    public String son;
    public person(String son) {
        this.son = son;
    }
    private int number = 0;
    synchronized public static void printA(String string) throws InterruptedException {
        System.out.println("A 进入线程！");
        Thread.sleep(2000);
        System.out.println("A 离开线程！");
        }
    
    public void printB(String string) throws InterruptedException {
        System.out.println("B ready!");
        synchronized (this) {
        System.out.println("B 进入线程！");
        System.out.println("B 离开线程！");
        }
    }
}

为了证明和锁的顺序没关系，调换顺序来证明

class person{
    public String son;
    public person(String son) {
        this.son = son;
    }
    private int number = 0;
    
    public void printA(String string) throws InterruptedException {
        System.out.println("A ready!");
        synchronized (this) {
        System.out.println("A 进入线程！");
        Thread.sleep(2000);
        System.out.println("A 离开线程！");
        }
    }
    
    synchronized public static void printB(String string) throws InterruptedException {
        System.out.println("B 进入线程！");
        System.out.println("B 离开线程！");
        }
}

输出结果：

A ready!
A 进入线程！
B 进入线程！
B 离开线程！
A 离开线程！

Java对象锁和类锁全面解析（多线程synchronized关键字）

相关文章

  • 同步、异步、类锁、对象锁

    同步 一个任务的执行，需要依赖另一个任务的完成。标准的程序执行流程就是同步的，只有上一个函数执行完成，下一个函数才...

  • 让你不再害怕JAVA的锁（一）

    java中的同步锁包括对象锁和类锁。 对象锁： 针对的是具体的对象实例；类锁：针对的是整个class类 现在先让我...

  • Synchronized锁 偏向锁 锁优化

    Synchronized实现同步 同步普通方法，锁当前实例对象 同步静态方法，锁当前类的Class对象 同步方法块...

  • Synchronized关键字

    修饰普通方法，锁当前实例对象 修饰静态同步方法，锁当前类对象 修饰同步代码块，锁括号中配置对对象 synchron...

  • java-summery

    1、对象锁和类锁 java的内置锁：每个java对象都可以用做一个实现同步的锁，这些锁成为内置锁。线程进入同步代码...

  • synchronized ：同步锁

    synchronized 同步锁分为对象锁、类锁、静态方法锁、非静态方法锁等。其中对象锁和非静态方法锁的作用域是对...

  • 线程安全-- synchronized

    synchronized 锁的范围 对于普通同步方法，锁是当前实例对象 对于静态同步方法，锁是当前类的class对...

  • synchronized

    synchronized同步方式总结 普通同步函数的锁是this，当前类实例对象，同步代码块锁可以自己定义，静态同...

  • synchronized

    同步锁synchronized关键字1>>修饰实例方法 对象锁为this2>>修饰静态方法 对象锁是当前类的字节码...

  • 并发编程反模式

    不连贯的同步性: 为了同步某个对象或者对象本身的某个域的访问,使用同步锁(内部锁或者显式锁,例如,对象本身的内部锁...

网友评论

    本文标题：同步、异步、类锁、对象锁

    本文链接：https://www.haomeiwen.com/subject/ujmqlqtx.html

    延伸阅读

    深度阅读

    • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

    栏目导航

    热点阅读

    android系统进阶

    关于我们|服务条款|联系我们|同步、异步、类锁、对象锁|投稿指南|网站地图|RSS订阅|排版工具|手机版

    提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

    Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

    备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

    本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

    所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！