java synchronized静态同步方法与非静态同步方法，同步语句块

已于 2023-03-13 19:58:02 修改
阅读量2.5k 收藏 12
点赞数 7
分类专栏： java核心编程 文章标签： java 多线程 面试
于 2021-01-30 12:56:46 首次发布
无
本文链接：https://blog.csdn.net/wwwwwww31311/article/details/113419839
版权

大纲：java线程知识体系

对代码进行同步控制我们可以选择同步方法，也可以选择同步块，这两种方式各有优缺点。同步块不仅可以更加精确的控制对象锁，还可以控制锁的作用域，何谓锁的作用域？锁的作用域就是从锁被获取到其被释放的时间。而且可以选择要获取哪个对象的对象锁。但是如果在使用同步块机制时，如果使用过多的锁也会容易引起死锁问题，同时获取和释放所也有代价，而同步方法，它们所拥有的锁就是该方法所属的类的对象锁，换句话说，也就是this对象，而且锁的作用域也是整个方法，这可能导致其锁的作用域可能太大，也有可能引起死锁，同时因为可能包含了不需要进行同步的代码块在内，也会降低程序的运行效率。而不管是同步方法还是同步块，我们都不应该在他们的代码块内包含无限循环，如果代码内部要是有了无限循环，那么这个同步方法或者同步块在获取锁以后因为代码会一直不停的循环着运行下去，也就没有机会释放它所获取的锁，而其它等待这把锁的线程就永远无法获取这把锁，这就造成了一种死锁现象。

详细解说一下同步方法的锁，同步方法分为静态同步方法与非静态同步方法，先看代码再说理论。以下是成功解决线程安全问题的案例，但如果show方法不是静态的即使被synchronized修饰也无法解决线程问题，大家可以先试一下

class Windows implements Runnable {
    private static int ticketNum = 10;
  
    public static synchronized void show(){
        String name = Thread.currentThread().getName();
        if(ticketNum > 0) {
            try {
                //这一步是为了演示错票，原理是当前线程进入了if语句陷入沉睡的时候票被卖光，
                //然后当该线程苏醒时再来一次ticketNum--产生0号这个非法票
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(name +"卖出第" + ticketNum + "张票");
            ticketNum--;
        }
    }
    @Override
    public void run() {
        while (true){
            show();
        }
    }
}

public class ThreadTest{
        public static void main(String[] args) {
            Windows windows = new Windows();
            Windows windows1 = new Windows();
            Thread thread1 = new Thread(windows);
            thread1.setName("窗口1");
            Thread thread2 = new Thread(windows);;
            thread2.setName("窗口2");
            Thread thread3 = new Thread(windows1);
            thread3.setName("窗口3");
            thread1.start();
            thread2.start();
            thread3.start();
        }
}

运行结果，没有线程安全问题
在这里插入图片描述
为何show必须是静态同步才能解决线程问题？

1 所有的非静态同步方法用的都是同一把锁——实例对象本身(this，本例中有windows和windows1)，Synchronized修饰非静态方法，实际上是对调用该方法的对象加锁，俗称“对象锁”。也就是说如果一个实例对象的非静态同步方法获取锁(windows对象的锁)后，该实例对象的其他非静态同步方法的执行或者同类的线程(由windows构造的线程)在此执行该同步方法时必须等待获取锁的方法释放锁后才能获取锁，可是别的实例对象(windows1)的非静态同步方法因为跟该实例对象(windows)的非静态同步方法用的是不同的锁，所以毋须等待该实例对象已获取锁的非静态同步方法释放锁就可以获取他们自己的锁，也就是说windows的锁只对windows(通过windows对象构造的线程)有效而不会影响windows1),自然无法保证线程安全。

2 而所有的静态同步方法用的也是同一把锁——类对象本身（Windwos.class），Synchronized修饰静态方法，实际上是对该类对象加锁，俗称“类锁”。两个不同的对象(windows和windows1)。一旦一个静态同步方法获取锁(Windows.class)后，其他的静态同步方法的执行或者其它类型的线程(由windows1构造的线程)再次调用该静态同步方法时都必须等待该方法释放锁后才能获取锁，而不管是同一个实例对象的静态同步方法之间，还是不同的实例对象的静态同步方法之间，只要它们同一个类的实例对象！

同理，看以下代码，我们选择使用Windows.class作为同步锁，可以保证线程安全。但是如果我们还是选用this做同步锁依然无法保证线程安全，大家可以试一下

class Windows implements Runnable {
    private static int ticketNum = 10;
    private Object obj = new Object();//obj也可以用作同步锁
    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        while (true){
            //这里也推荐用this(this代表的是main中的windows对象)或Windows.class
            synchronized (Windows.class){
                if(ticketNum > 0) {
                    try {
                        //这一步是为了演示错票，原理是当前线程进入了if语句陷入沉睡的时候票被卖光，
                        //然后当该线程苏醒时再来一次ticketNum--产生0号这个非法票
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(name + "卖出第" + ticketNum + "张票");
                    ticketNum--;
                }
            }
        }
    }
}

public class ThreadTest{
        public static void main(String[] args) {
            Windows windows = new Windows();
            Windows windows1 = new Windows();
            Thread thread1 = new Thread(windows);
            thread1.setName("窗口1");
            Thread thread2 = new Thread(windows);;
            thread2.setName("窗口2");
            Thread thread3 = new Thread(windows1);
            thread3.setName("窗口3");
            thread1.start();
            thread2.start();
            thread3.start();
        }
}

对于同步块，由于其锁是可以选择的，所以只有使用同一把锁的同步块之间才有着竞争关系，这就得具体情况具体分析了，同步块的锁是可以选择的，但是不是可以任意选择的！
①对一个null对象加锁会产生异常
②对不同的对象加锁也违背了同步的初衷！一个经常发生的错误就是选用了错误的锁对象，因此必须注意：同步是基于实际对象而不是对象引用的！不要选择一个可能会在锁的作用域中改变值的实例变量作为锁对象！本例中的obj用作锁对象的话对于整个类的声明周期来说都不会发生改变，synchronized (obj){}等价于synchronized (this){}
③无论是synchronized (obj){}还是synchronized (this){}都只能保证同一个Runnable实现类的对象构造的形参保证线程安全，如果要不同类型(windows1和windows2)的线程保证线程安全，需要使用synchronized (Windwos.class){}来锁住整个类

练习题

题目一

public class Phone {

    public synchronized void sendEamil() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ":send email");
    }


    public synchronized void sendCall() {
        System.out.println(Thread.currentThread().getName() + ":send call");
    }

}


class LockDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(() -> {
            phone.sendEamil();
        },"aThread").start();

        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            phone.sendCall();
        },"bThread").start();
    }

}

结果

aThread:send email
bThread:send call

结果分析

执行synchronized同步方法需要从phone对象中获取对象锁，首先aThread线程获取到锁后陷入睡眠，睡眠期间不释放锁，所以bThread去执行sendCall方法时获取不到锁，无法执行，只能等sendEmail方法执行完毕才可继续执行

题目二

public class Phone {

    public synchronized void sendEamil() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ":send email");
    }


    public synchronized void sendCall() {
        System.out.println(Thread.currentThread().getName() + ":send call");
    }

    public  void hello() {
        System.out.println(Thread.currentThread().getName() + ":send hello");
    }

}


class LockDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(() -> {
            phone.sendEamil();
        },"aThread").start();

        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            phone.hello();
        },"bThread").start();
    }

}

结果

bThread:send hello
aThread:send email

结果分析

同理，aThread进入睡眠，期间bThread执行的是普通方法，不受锁的限制

题目三

public class Phone {

    public synchronized void sendEamil() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ":send email");
    }


    public synchronized void sendCall() {
        System.out.println(Thread.currentThread().getName() + ":send call");
    }

    public  void hello() {
        System.out.println(Thread.currentThread().getName() + ":send hello");
    }

}


class LockDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();
        Phone phone2 = new Phone();

        new Thread(() -> {
            phone.sendEamil();
        },"aThread").start();

        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            phone2.sendCall();
        },"bThread").start();
    }

}

结果

bThread:send call
aThread:send email

结果分析

aThread持有phone对象的对象锁进入睡眠，bThread尝试获取到phone2的对象锁，可获取成功

题目四

public class Phone {

    public static synchronized void sendEamil() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ":send email");
    }


    public static synchronized void sendCall() {
        System.out.println(Thread.currentThread().getName() + ":send call");
    }

    public  void hello() {
        System.out.println(Thread.currentThread().getName() + ":send hello");
    }

}


class LockDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();
        Phone phone2 = new Phone();

        new Thread(() -> {
            phone.sendEamil();
        },"aThread").start();

        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            phone2.sendCall();
        },"bThread").start();
    }

}

结果

aThread:send email
bThread:send call

结果分析

静态方法的执行需要从class对象中获取对象锁，并非从普通对象获取对象锁，而任何的类的class对象只有一个

题目五

public class Phone {

    public static synchronized void sendEamil() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ":send email");
    }


    public static void sendCall() {
        System.out.println(Thread.currentThread().getName() + ":send call");
    }

    public  void hello() {
        System.out.println(Thread.currentThread().getName() + ":send hello");
    }

}


class LockDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();
        Phone phone2 = new Phone();

        new Thread(() -> {
            phone.sendEamil();
        },"aThread").start();

        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            phone2.sendCall();
        },"bThread").start();
    }

}

结果

bThread:send call
aThread:send email

结果分析

aThread执行静态方法的需要从class对象中获取对象锁，bThread执行普通方法需要从对象phone中获取普通对象获取对象锁，二者锁的来源不会有冲突

生命不息战斗不止！！！
关注
  • 7
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
synchronized用法大全实例
06-05
- **对象锁**：如果`synchronized`修饰非静态方法或者同步语句块中的对象引用是实例引用，那么锁定的是该实例对象。例如： ```java public class MyObject { public synchronized void method() { // ... } }...
Synchronized同步静态方法和非静态方法总结
奔跑入坑大数据
11-16 1825
1.Synchronized修饰非静态方法，实际上是对调用该方法的对象加锁，俗称“对象锁”。 Java中每个对象都有一个锁，并且是唯一的。假设分配的一个对象空间，里面有多个方法，相当于空间里面有多个小房间，如果我们把所有的小房间都加锁，因为这个对象只有一把钥匙，因此同一时间只能有一个人打开一个小房间，然后用完了还回去，再由JVM 去分配下一个获得钥匙的人。 情况1：同一个对象在两个线程中分别访问该对象的两个同步方法 结果：会产生互斥。 解释：因为锁针对的是对象，当对象调用一个synch...
synchronized作用于静态方法和非静态方法上的区别
weixin_44251749的博客
08-19 3867
synchronized作用于非静态方法 synchronized作用于非静态方法，实际上是对当前实例对象加锁，就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁，可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁，所以毋须等待该实例对象已获取锁的非静态同步方法释放锁就可以获取他们自己的锁。 情况1：同一个对象在两个线程中分别访问该对象的两个同步方法 结果：会产生互斥。 解释：因为锁针对的是对象，当对象调用一个.
【吊打面试官系列】Java高并发篇 - 同步方法和同步块，哪个是更好的选择？
最新发布
java1234的博客
05-12 146
同步方法和同步块，哪个是更好的选择？
synchronized静态方法与非静态方法
BushRo
08-05 2841
一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法了，其它的线程都只能等待，换句话说，某一个时刻内，只能有唯一一个线程去访问这些synchronized。 我们需要先弄清楚synchronized 在类方法上使用的两个关键点。 1.非静态方法的锁默认为 this，也就是我们所说的对象锁, 静态方法的锁为 对应的 ...
浅析Java中synchronized与static synchronized
C18298182575的博客
11-25 718
synchronized VS static synchronized
java 静态同步锁static synchronized详解
hello_v_world的博客
07-07 2256
下面我们看例子1： 有一个phone类，里面有两个同步方法（synchronized修饰），分别为发送email和发送短信，在main方法中实例化一部手机，开启两个线程去操作phone这个资源类 public class Phone { public synchronized void sendMail() throws Exception { TimeUnit.SECONDS.sleep(4); System.out.println("******sendMail
Java synchronized关键字使用方式及特性解析
08-25
在Java中，使用synchronized关键字可以作用在方法上，从而保证了访问同一个对象的同一个方法的线程同步。例如： public synchronized void testFun(String str){ for(int i=0;i;i++){ System.out.println(str+",...
如何在JAVA中使用Synchronized
08-19
当`synchronized`关键字用于修饰一个代码块时，它创建了一个同步语句块。例如： ```java synchronized(this) { // 代码块 } ``` 在这个例子中，`this`引用当前对象。这意味着，当一个线程进入这个同步代码块...
校招面试题库java（附答案与解析）
08-09
线程的创建与管理、同步机制（synchronized、Lock、ReentrantLock等）、并发容器（如ConcurrentHashMap、CopyOnWriteArrayList等）、线程池（ExecutorService）和并发工具类（如CountDownLatch、CyclicBarrier、...
Java多线程同步(wait()notify()notifyAll())[文].pdf
10-19
- 使用wait()时，必须在同步代码块（由synchronized修饰的方法或代码块）中调用，因为只有持有锁的线程才能调用wait()。 - 恢复执行的线程会从wait()调用后的下一条语句开始，因此通常在循环中调用wait()，以确保...
synchronized修饰静态方法与实例方法
meser88的博客
04-04 688
一、synchronized修饰实例方法：synchronized修饰实例方法，实际上是对调用该方法的对象加锁。场景1：同一实例对象在两个线程中分别调用该对象的两个同步实例方法。
Synchronized作用在静态和非静态方法上的区别
串一串爪娃子
06-09 1568
synchronized关键字的用法主要有以下几种： 作用在非静态方法上 非静态方法是只能提供类的实例进行调用，所以实际上就是对调用方法的对象加锁，俗称对象锁 作用在静态方法上 静态方法是可以通过类名直接调用，所以实际上就是对调用方法的类加锁，俗称类锁 作用在代码块 根据传入的是类对象或类实例判断加锁方式 场景分析 1 2 3 4 5 6 7 8 ...
Synchronized
weixin_45062852的博客
10-26 1012
一 Synchronized简介 Synchronized是java内置的关键字。代表这个方法加锁,相当于不管哪一个线程，运行到这个方法时,都要检查有没有其它线程正在用这个方法(或者该类的其他同步方法)，有的话要等正在使用synchronized方法的线程运行完这个方法后再运行此线程,没有的话,锁定调用线程,然后直接运行。 Synchronized是同步锁，保障原子性、可见性、有序性 1 原子性 指一个操作一旦开始，就不会被其他线程所干扰，不可中断。 2.可见性 指一个线程对共享变量进行修改，另一个能立刻获
静态同步方法（static synchronizd）
yansong_8686的专栏
12-16 3050
Java语法规定，任何线程进入同步方法、同步代码块之前，必须先获取同步方法、同步代码块对应的同步监视器。 对于同步代码块而言，程序必须为它显示的指定同步监视器（可为this也可以自定义Object类型的全局变量）；对于同步非静态方法而言，该方法的同步 监视器是this----即调用该方法的java对象；对于静态的同步方法而言，该方法的同步监视器不是this而是该类本身。
synchronized 静态方法和非静态方法
wuhulala的休息室
08-06 644
synchronized 的本质就是一个不可重入锁，大致分为以下两类 1. 有对象锁 synchronized(this),或者非静态方法上加synchronized修饰 2. 类锁 synchronized(XX.class),或者静态方法上加synchronized修饰所以method1和method2的开始时间是同时的，因为method1的锁对应的是类锁，而method2对应的
Java synchronized详细解读.docx
06-21
由于同一进程的多个线程共享同一片存储空间，在带来方便的同时，也带来了访问冲突这个严重的问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问。 需要明确的几个问题： synchronized关键字可以作为函数的修饰符，也可作为函数内的语句，也就是平时说的同步方法和同步语句块。如果 再细的分类，synchronized可作用于instance变量、object reference（对象引用）、static函数和class literals(类名称字面常量)身上。 无论synchronized关键字加在方法上还是对象上，它取得的锁都是对象，而不是把一段代码或函数当作锁――而且同步方法很可能还会被其他线程的对象访问。 每个对象只有一个锁（lock）与之相关联。 实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值