Java中关键字synchronized的使用方法详解

2024-04-02 19:04:59 146人浏览泡泡鱼

Python 官方文档：入门教程 => 点击学习

摘要

synchronized是Java里的一个关键字，起到的一个效果是“监视器锁”~~，它的功能就是保证操作的原子性，同时禁止指令重排序和保证内存的可见性！ public clas

synchronized是Java里的一个关键字，起到的一个效果是“监视器锁”~~，它的功能就是保证操作的原子性，同时禁止指令重排序和保证内存的可见性！


public  class TestDemo {
    static  class Counter{
        public int count = 0;

        public void add(){
            count++;
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread t1 = new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 50000; i++) {
                    counter.add();
                }
            }
        };

        Thread t2 = new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 50000; i++) {
                    counter.add();
                }
            }
        };

        //启动两个线程
        t1.start();
        t2.start();
        //等待两个线程结束
        t1.join();
        t2.join();
        System.out.println(counter.count);
    }
}

此时的线程就是不安全的，如何解决呢？

给我们的Counter对象里的add方法加上synchronized关键字，针对这个方法进行了加锁操作。进入代码块(调用方法)自动加锁，出了代码块(方法结束)，自动解锁。


public  class TestDemo {
    static  class Counter{
        public int count = 0;
         
         //修饰方法
         synchronized public void add{
             count++;
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread t1 = new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 50000; i++) {
                    counter.add();
                }
            }
        };

        Thread t2 = new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 50000; i++) {
                    counter.add();
                }
            }
        };

        //启动两个线程
        t1.start();
        t2.start();
        //等待两个线程结束
        t1.join();
        t2.join();
        System.out.println(counter.count);
    }
}

那么这里的代码是如何保证正确的呢？

使用synchronized 就相当于在我们执行的指令里又加入了2条新指令。

LOCK (加锁)

UNLOCK （解锁）

LOCK操作特性：只有一个线程能执行成功！如果第一个线程执行成功，第二个线程也尝试LOCK，就会阻塞等待，直到第一个线程执行UNLOCK 释放锁~

通过LOCK和UNLOCK 就把 LOAD ADD SAVE 这三个指令，给打包成了一个原子的操作(中间不能被打断，也不能被其他线程穿插)。

这里的加锁也是保证原子性的核心操作，所以线程里的没组指令就会顺序执行，不在穿插执行，就保证了线程1执行完之后再去执行线程2。

举个例子：

就好比张三和李四去ATM里去取钱，当张三进去取钱时，进去后就会锁门，李四就会在外面等待，直到张三取完钱出来后，李四在进去取钱。

synchronized 也会禁止编译器进行“内存可见性”和“指令重排序”的优化~ 同时程序运行的效率就会降低，
也会导致线程之间相互去等待，就涉及到系统的一些调度，也会引入一些时间成本。

synchronized修饰的对象有以下几种：

修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；


public class TestDemo{
    public void methond() {
        // 进入代码块会锁 this 指向对象中的锁；
        // 出代码块会释放 this 指向的对象中的锁
        synchronized (this) {

        }
    }
    public static void main(String[] args) {
        TestDemo demo = new TestDemo();
        demo.methond();
    }
}

修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；


public class TestDemo{
    public synchronized void methond() {

    }
    public static void main(String[] args) {
        TestDemo demo = new TestDemo();
        demo.methond();
        // 进入方法会锁 demo 指向对象中的锁；
        // 出方法会释放 demo 指向的对象中的锁
    }
}

修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；


public class TestDemo{
    public synchronized static void methond() {

    }
    public static void main(String[] args) {
        methond();
        // 进入方法会锁 TestDemo.class 指向对象中的锁；
        //出方法会释放 TestDemo.class 指向的对象中的锁
    }
}

修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。


public class TestDemo{
    public static void methond() {
        // 进入代码块会锁 TestDemo.class 指向对象中的锁；
        //出代码块会释放 TestDemo.class 指向的对象中的锁
        synchronized (TestDemo.class) {

        }
    }
    public static void main(String[] args) {
        TestDemo demo = new TestDemo();
        demo.methond();
    }
}

总结：

无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；
如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。
每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。
实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。

拓展：


public  class TestDemo {

    static   class Counter{
        public int count = 0;

           public void add(){
               synchronized (this){
                   count++;
               }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread t1 = new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 50000; i++) {
                    synchronized (counter){
                        counter.add();
                    }
                }
            }
        };
        Thread t2 = new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 50000; i++) {
                    synchronized (counter){
                        counter.add();
                    }
                }
            }
        };

        //启动两个线程
        t1.start();
        t2.start();
        //等待两个线程结束
        t1.join();
        t2.join();
        System.out.println(counter.count);
    }
}

此时可以看出上述代码，加了两次锁，会发生什么呢？