Java并发编程(四)——synchronized关键字实现加锁

谁践踏了优雅 2023-01-19 04:59 99阅读 0赞

## 案例介绍 ##

来看下面一段代码：

public class Counter { 
        private int count=0;
    
        public void add(){  
                count++;    
        }
        public void des(){ 
                count--;
        }
        public int get(){ 
            return count;
        }
    
        public static void main(String[] args) throws InterruptedException { 
            Counter counter=new Counter();
            Thread thread1=new Thread(()->{ 
                for (int i = 0; i < 10000; i++) { 
                    counter.add();
                }
            });
            
            Thread thread2=new Thread(()->{ 
                for (int i = 0; i < 10000; i++) { 
                    counter.des();
                }
            });
            thread1.start();
            thread2.start();
            thread1.join(); //等待thread1执行结束
            thread2.join();  //等待thread2执行结束
            System.out.println(counter.get());  //打印最终的结果
        }
    }

我们想实现的效果是给count变量做10000次自增，做10000次自减操作，最后结果应该还是0才对。但是现在呢？

这段代码的执行结果是不确定的，有时候是负数，有时候是正数，而且每次结果都不一样。

## 原子操作 ##

为什么会出现这么奇怪的问题呢？

原因出在count–和count++这两个操作不是原子性的，**原子操作是指不能被中断的一个或一系列操作。**

对变量进行读取和写入时，结果要正确，必须保证是原子操作，例如：

对于

> n=n+1；

看起来是一条语句，其实是对应了三条指令：

ILOAD
    IADD
    ISTORE

![image-20210127131407683][]

如图所示，如果线程1在执行ILOAD后被操作系统中断，操作系统去执行线程2，那么线程2ILOAD拿到的值仍然是100，最终两个线程的ISTORE写入后变成了101，而不是期望的102；

为了解决这个问题，我们在一个线程执行操作的时候，如果此操作没有结束，那么其他线程必须等待，不允许打断当前线程：

![image-20210127132239016][]

由此可见，保证一段代码的原子性就是通过加锁和解锁实现的。

## synchronized关键字 ##

Java程序使用`synchronized`关键字对一个对象进行加锁：

synchronized(lock) { 
        n = n + 1;
    }

我们修改上面的示例代码：

public class Counter { 
        private int count=0;
    
        public void add(){ 
            synchronized (this) { 
                count++;
            }
        }
        public void des(){ 
            synchronized (this) { 
                count--;
            }
        }
        public int get(){ 
            return count;
        }
    
        public static void main(String[] args) throws InterruptedException { 
            Counter counter=new Counter();
            Thread thread1=new Thread(()->{ 
                for (int i = 0; i < 10000; i++) { 
                    counter.add();
                }
    
            });
            Thread thread2=new Thread(()->{ 
                for (int i = 0; i < 10000; i++) { 
                    counter.des();
                }
    
            });
            thread1.start();
            thread2.start();
            thread1.join();
            thread2.join();
            System.out.println(counter.get());
        }
    }

就能够保证每次的输出结果都是0。

**关于synchronized**：

synchronized (this) {  //获取锁
              ...
            }//释放锁

表示用this（当前实例，即counter对象）作为锁，因为两个线程共用了一个counter对象，所以两个线程在执行各自的`synchronized(this) { ... }`代码块时，必须先获得锁，才能进入代码块进行。执行结束后，在`synchronized`语句块结束会自动释放锁。

这样一来，对count变量的count++和count–操作不可能同时进行，所以无论多少次运行，结果都是0.

### synchronized需要注意的问题 ###

*  使用synchronized加锁时，必须注意加锁对象必须是同一个实例；
 *  下面两种写法等价：
    
        public void add(int n) { 
            synchronized(this) {  // 锁住this
                count += n;
            } // 解锁
        }
    
        public synchronized void add(int n) {  // 锁住this
            count += n;
        } // 解锁
    
    用`synchronized`修饰的方法就是同步方法，它表示整个方法都必须用`this`实例加锁。
 *  在使用`synchronized`的时候，不必担心抛出异常。因为无论是否有异常，都会在`synchronized`结束处正确释放锁：

public void add(int m) { 
        synchronized (obj) { 
            if (m < 0) { 
                throw new RuntimeException();
            }
            this.value += m;
        } // 无论有无异常，都会在此释放锁
    }

*  对于static方法加锁，锁住的是类，而不是实例：
    
        public synchronized static void test(int n) { 
            ...
        }
    
    static方法是属于类的，而不属于某个实例，static方法没有this实例的概念。任何一个类都有一个由JVM自动创建的`Class`实例，因此，对`static`方法添加`synchronized`，锁住的是该类的`Class`实例。上述`synchronized static`方法实际上相当于：

public class Counter { 
        public static void test(int n) { 
            synchronized(Counter.class) { 
                ...
            }
        }
    }

### 总结 ###

*  synchronized关键字是用来加锁的，目的是为了保证操作的原子性
 *  synchronized修饰的方法锁住的是this实例，它可以锁住整个方法代码块，方法执行完自动释放锁

## 我的博客 ##

欢迎访问我的博客：[易水寒博客][Link 1]

[image-20210127131407683]: https://img.liuyj.top/image-20210127131407683.png
[image-20210127132239016]: /images/20221021/0b22a2c5cce6401e95d617a948d02d83.png
[Link 1]: https://www.liuyj.top/