Java并发编程之原子性Synchronized(九)

谁践踏了优雅 2022-04-15 05:29 314阅读 0赞

**一.前言**  
线程安全是并发编程中的重要关注点，应该注意到的是，造成线程安全问题的主要诱因有两点，一是存在共享数据(也称临界资源)，二是存在多条线程共同操作共享数据。因此为了解决这个问题，我们可能需要这样一个方案，当存在多个线程操作共享数据时，需要保证同一时刻有且只有一个线程在操作共享数据，其他线程必须等到该线程处理完数据后再进行，这种方式有个高尚的名称叫互斥锁，即能达到互斥访问目的的锁，也就是说当一个共享数据被当前正在访问的线程加上互斥锁后，在同一个时刻，其他线程只能处于等待的状态，直到当前线程处理完毕释放该锁。在 Java 中，关键字 synchronized可以保证在同一个时刻，只有一个线程可以执行某个方法或者某个代码块(主要是对方法或者代码块中存在共享数据的操作)，同时我们还应该注意到synchronized另外一个重要的作用，synchronized可保证一个线程的变化(主要是共享数据的变化)被其他线程所看到（保证可见性，完全可以替代Volatile功能），这点确实也是很重要的。  
**二. synchronized 的局限性 与 Lock 的优点**  
synchronized 是Java语言的内置特性，可以轻松实现对临界资源的同步互斥访问。那么，为什么还会出现Lock呢？试考虑以下三种情况：

1.  在使用synchronized关键字的情形下，假如占有锁的线程由于要等待IO或者其他原因（比如调用sleep方法）被阻塞了，但是又没有释放锁，那么其他线程就只能一直等待，别无他法。这会极大影响程序执行效率。因此，就需要有一种机制可以不让等待的线程一直无期限地等待下去（比如只等待一定的时间 (解决方案：tryLock(long time, TimeUnit unit)) 或者 能够响应中断 (解决方案：lockInterruptibly())），这种情况可以通过 Lock 解决。
2.  我们知道，当多个线程读写文件时，读操作和写操作会发生冲突现象，写操作和写操作也会发生冲突现象，但是读操作和读操作不会发生冲突现象。但是如果采用synchronized关键字实现同步的话，就会导致一个问题，即当多个线程都只是进行读操作时，也只有一个线程在可以进行读操作，其他线程只能等待锁的释放而无法进行读操作。因此，需要一种机制来使得当多个线程都只是进行读操作时，线程之间不会发生冲突。同样地，Lock也可以解决这种情况 (解决方案：ReentrantReadWriteLock) 。
3.  我们可以通过Lock得知线程有没有成功获取到锁 (解决方案：ReentrantLock) ，但这个是synchronized无法办到的。

上面提到的三种情形，我们都可以通过Lock来解决，但 synchronized 关键字却无能为力。事实上，Lock 是 java.util.concurrent.locks包 下的接口，Lock 实现提供了比 synchronized 关键字 更广泛的锁操作，它能以更优雅的方式处理线程同步问题。也就是说，Lock提供了比synchronized更多的功能。但是要注意以下几点：  
1）synchronized是Java的关键字，因此是Java的内置特性，是基于JVM层面实现的。而Lock是一个Java接口，是基于JDK层面实现的，通过这个接口可以实现同步访问；  
2）采用synchronized方式不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；而 Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致死锁现象。  
**三.应用方式**

1.  修饰实例方法，作用于当前实例加锁，进入同步代码前要获得当前实例的锁
2.  修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁
3.  修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。

示例代码:

public static int num = 0;
        public static int ThreadPoolNum = 1000;//线程数量
    
        public static void main(String[] args) { 
            final SynTest test = new SynTest();
            ExecutorService executorService = Executors.newCachedThreadPool();//线程池
            for (int i = 0; i < ThreadPoolNum; i++) { 
                executorService.execute(new Runnable() { 
                    @Override
                    public void run() { 
    // countNum();
    // test.countNum1();
                        test.countNum2();
                    }
                });
            }
        }
    
        //修饰静态方法
        public static synchronized void countNum() { 
            num++;
            System.out.println("结果num:" + num );
        }
    
        //修饰代码块
        public void countNum1() { 
            synchronized (this) { 
                num++;
                System.out.println("结果num:" + num );
            }
        }
        //实例对象锁
        public synchronized  void countNum2() {  
              num++;
              System.out.println("结果num:" + num );    
        }

结果

> 结果num:1  
> 结果num:2  
> .  
> .  
> .  
> 结果num:999  
> 结果num:1000