JUC-8锁问题

最新推荐文章于 2024-10-16 16:34:42 发布

14L

最新推荐文章于 2024-10-16 16:34:42 发布

阅读量292

点赞数 4

分类专栏： JUC 文章标签： java 算法开发语言

本文链接：https://blog.csdn.net/qq_43400687/article/details/138589482

版权

JUC 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

JUC-8锁问题

1.两个synchronized方法的调用

package com.kuang.lock8;

import java.util.concurrent.TimeUnit;

public class Test3 {
    public static void main(String[] args) {
        Phone1 phone1 = new Phone1();
        
        new Thread(phone1::sendmsg).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        new Thread(phone1 ::call).start();
    }
}

class Phone1{
    public synchronized void sendmsg(){

  
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

先输出 发短信 再输出 打电话

2.两个synchronized方法的调用（其中第一个延迟4s）

package com.kuang.lock8;

import java.util.concurrent.TimeUnit;

public class Test3 {
    public static void main(String[] args) {
        Phone1 phone1 = new Phone1();
        
        new Thread(phone1::sendmsg).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        new Thread(phone1 ::call).start();
    }
}

class Phone1{
    public synchronized void sendmsg(){

        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

先输出 发短信 再输出 打电话

这说明，不是因为发短信这个线程先执行，所以先打印；而是因为synchronized锁的存在，这个锁锁的是对象即 phone1

3.一个synchronized方法、一个普通方法的调用

package com.kuang.lock8;

import java.util.concurrent.TimeUnit;

public class Test4 {
    public static void main(String[] args) {
        Phone3 phone1 = new Phone3();
        new Thread(phone1::sendmsg).start();

        new Thread(phone1::hello).start();
    }
}

class Phone3{
    public synchronized void sendmsg(){

        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }

    public void hello(){
        System.out.println("hello");
    }
}

先输出 hello 再输出发短信
原因：hello()方法是一个普通方法，没有synchronized关键字，不会被锁控制

4.两个对象，分别进行synchronized方法的调用

package com.kuang.lock8;

import java.util.concurrent.TimeUnit;

public class Test3 {
    public static void main(String[] args) {
        Phone1 phone1 = new Phone1();
        Phone1 phone2 = new Phone1();
        new Thread(phone1::sendmsg).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        new Thread(phone2::call).start();
    }
}

class Phone1{
    public synchronized void sendmsg(){

        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

先输出 打电话 再输出 发短信
原因：synchronized锁的东西是对象，现在有两个对象，所以不会相互影响，call()不用等待4s，所以先输出

5.两个静态synchronized方法的调用（其中第一个延迟4s）

package com.kuang.lock8;

import java.util.concurrent.TimeUnit;

public class Test3 {
    public static void main(String[] args) {
        Phone1 phone1 = new Phone1();
        
        new Thread(phone1::sendmsg).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        new Thread(phone1 ::call).start();
    }
}

class Phone1{
    public static synchronized void sendmsg(){

        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("发短信");
    }
    public static synchronized void call(){
        System.out.println("打电话");
    }
}

先输出 发短信 再输出 打电话

6.两个对象，分别进行静态synchronized方法的调用

package com.kuang.lock8;

import java.util.concurrent.TimeUnit;

public class Test3 {
    public static void main(String[] args) {
        Phone1 phone1 = new Phone1();
        Phone1 phone2 = new Phone1();
        new Thread(phone1::sendmsg).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        new Thread(phone2::call).start();
    }
}

class Phone1{
    public static synchronized void sendmsg(){

        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("发短信");
    }
    public static synchronized void call(){
        System.out.println("打电话");
    }
}

先输出 发短信 再输出 打电话
原因：从 5，6可以看出，static 修饰 synchronized后，由于static修饰的方法在编译时就加载完成，所以此时synchronized锁的对象时Phone1.class 一个class类只会有一个.class，所以即使是两个对象也没用，因为锁的是底层的类

7.一个静态synchronized方法、一个synchronized方法的调用

package com.kuang.lock8;

import java.util.concurrent.TimeUnit;

public class Test3 {
    public static void main(String[] args) {
        Phone1 phone1 = new Phone1();
       
        new Thread(phone1::sendmsg).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        new Thread(phone1 ::call).start();
    }
}

class Phone1{
    public static synchronized void sendmsg(){

        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

先输出 打电话 再输出 发短信
原因：因为static synchronized锁的是.class synchronized锁的是对象 phone1，是两把不同的锁，互不干扰

8.两个对象，一个对象静态synchronized方法、一个对象synchronized方法的调用

package com.kuang.lock8;

import java.util.concurrent.TimeUnit;

public class Test3 {
    public static void main(String[] args) {
        Phone1 phone1 = new Phone1();
        Phone1 phone2 = new Phone1();
        new Thread(phone1::sendmsg).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        new Thread(phone2::call).start();
    }
}

class Phone1{
    public static synchronized void sendmsg(){

        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}