并发编程二:普通锁

旧城等待， 2022-09-25 05:12 235阅读 0赞

# 并发编程之普通锁 #

## 介绍 ##

锁是一种线程同步机制,和synchronized同步代码块一样,但是锁具备一些更高级和`  细粒度的对同步的控制。
    锁和syncronized同步方法/代码块本是相同的，它们的目的都是为了保证共享资源被安全的访问。

--------------------

锁（lock）作为用于保护临界区（critical section）的一种机制，被广泛应用在多线程程序中。
    无论是 Java 语言中的 synchronized 关键字，还是使用并发包的Lock实现,都是多线程应用开发人员手中强有力的工具。
    但是强大的工具通常是把双刃剑，过多或不正确的使用锁，会导致多线程应用的性能下降。

--------------------

备注:锁这种机制和理念并不是Java所特有的,这只是一种思想其它任何语言都可以实现。

## Java Lock介绍和使用 ##

从jdk1.5之后在java.util.concurrent.locks包下包含了几个锁的实现,所以我们能够很轻易的使用锁来控制同步,
    我们无需自己实现锁的功能。但是我们任然需要知道如何使用他们,并且知道他们是如何实现依然非常的重要。

### Lock接口定义 ###

public interface Lock {
    
        //获得锁资源方法
        void lock();
        //释放锁资源方法
        void unlock();
        //建立一个对象监视器
        Condition newCondition();
        //尝试获得锁资源
        boolean tryLock();
        //指定时间内尝试获取锁资源
        boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    
        void lockInterruptibly() throws InterruptedException;
    
    }
    
    备注:使用锁最后一定要释放锁资源，否则资源就可能永远得不到释放。
    典型使用锁代码:
    
         Lock lock = ...; 
         lock.lock();
         try {
             //访问共享资源
         } finally {
             //释放共享资源
             lock.unlock();
         }

### 一个简单例子引出锁 ###

定义一个Counter类,其有一个方法就是自增count值。如果多线程场景下访问可能就会出问题。因此需要最自增方法做同步处理。

--------------------

/**
     * 
     * @author xuyi
     * @Time 2016年8月13日 上午8:52:05
     * @类名 Counter
     * @功能描述:一个简单的计算类,里面只包含一个自增方法和count属性
     * @春风十里不如你
     * @备注:
     */
    public class Counter
    {
    
        // 统计数值
        private int count;
    
        // 自增方法
        public int incr()
        {
            return (count++);// 或者把++写在前面
        }
    
    }
    
    
    备注:如果单线程环境访问这个对象并不会有任何问题，但是如果多线程访问则可能就会出问题了， 
    因为incr方法并没有使用同步机制，导致多个线程可以同时访问这个方法，那么就会导致他们的计算结果不正确了。
    因为该方法不是原子操作，所以没有同步机制还是会出现安全问题。

--------------------

解决方案:
        1、对共享资源进行同步
        2、使操作变为原子性操作
        3、将count申明为可见的原子性AtomicInteger类型然后再操作
    
        这里我们只使用第一种方式来扩展锁知识。

#### 使用synchronized同步机制 ####

将上面的incr方法改为如下，使用synchronized同步代码块
    // 自增方法
    public int incr()
    {
        synchronized (this)
        {
            return (count++);// 或者把++写在前面
        }
    }

#### 使用Lock锁 ####

正如之前我们提到的Java已经给我们提供了很棒的Lock实现类，我们可以使用ReentrantLock对象来达到锁同步的目的。

--------------------

public class Counter
    {
    
        // 统计数值
        private int             count;
    
        // 申明一个ReentrantLock对象
        private ReentrantLock   lock    = new ReentrantLock();
    
        // 自增方法
        public int incr()
        {
            lock.lock();//将资源上锁，保证资源访问时安全的
            try
            {
                return (count++);// 或者把++写在前面
    
            } finally
            {
                lock.unlock();//最终释放锁资源
            }
        }
    }

### 自定义实现锁 ###

虽然JDK给我们提供了ReentrantLock和ReentrantReadWriteLock这两个非常棒的锁实现，
    大部分场景下我们都能使用它们来解决很多问题。但是我们不仅要会用，更应该知道它们背后锁实现的原理。

#### 简单的锁实现 ####

/**
     * 
     * @author xuyi
     * @Time 2016年8月13日 上午9:14:38
     * @类名 SimpleLock
     * @功能描述:实现锁的基本功能
     * @春风十里不如你
     * @备注:
     */
    public class SimpleLock
    {
    
        // 是否获得锁的标识
        private boolean isLocked = false;
    
        // 获取锁资源
        public void lock()
        {
            synchronized (this)
            {
                while (isLocked)
                {// 如果锁资源已经被别的线程占有了,那么就在此等待
                    try
                    {
                        wait();
                    } catch (InterruptedException e)
                    {
                    }
                }
                // 如果锁资源目前没有被别的资源占有,那么将锁标识位设置为true,表示锁资源被当前线程占有。
                isLocked = true;
            }
        }
    
        // 释放锁资源
        public void unlock()
        {
    
            synchronized (this)
            {
                // 将锁资源标识为空闲状态,然后通知其它等待线程来抢占资源
                isLocked = false;
                notify();
            }
        }
    
        // 其实该锁实现还是借助了JVM的synchronized同步机制,只是进行了稍加封装。
    
    }

--------------------

备注:该简单锁实现是比较简单粗暴的，因为它没有考虑同个对象资源里面，方法可能会存在互相调用，而导致锁重入的情况。

--------------------

/**
     * 
     * @author xuyi
     * @Time 2016年8月13日 上午9:24:04
     * @类名 Resource
     * @功能描述:存在锁重入的方法
     * @春风十里不如你
     * @备注:
     */
    public class Resource
    {
    
        // 定义一个简单锁对象
        private SimpleLock lock = new SimpleLock();
    
        public void outter()
        {
            lock.lock();
            try
            {
                // ...
                inner();
                // ...
            } finally
            {
                lock.unlock();
            }
        }
    
        public void inner()
        {
            lock.lock();
            try
            {
                // ...
            } finally
            {
                lock.unlock();
            }
        }
    }
    
    
    
    
    备注:对于这个对象如果调用outter方法，使用SimpleLock来处理那么就会导致死锁了，所以此时我们应该升级我们的简单锁了。

#### 可重入锁实现 ####

关于重入锁，我们可以从上面那个例子看出来其到底是什么意思。
    
    Java中的synchronized同步块是可重入的。这意味着如果一个java线程进入了代码中的synchronized同步块，
    并因此获得了该同步块使用的同步对象对应的管程上的锁，那么这个线程可以进入由同一个管程对象所同步的另一个java代码块。
    
    ReentrantLock也是可重入锁的实现

--------------------

/**
     * 
     * @author xuyi
     * @Time 2016年8月13日 上午9:34:01
     * @类名 SimpleReentrantLock
     * @功能描述:简单可重入锁的实现
     * @春风十里不如你
     * @备注:
     */
    public class SimpleReentrantLock
    {
    
        // 是否占有锁资源的标识位
        private boolean isLocked        = false;
        // 当前锁资源被哪个线程持有
        private Thread  lockedByThread  = null;
        // 某线程上锁次数
        private int     lockCount       = 0;
    
        public void lock()
        {
            synchronized (this)
            {
                Thread currentThread = Thread.currentThread();
                while (isLocked && currentThread != lockedByThread)
                {// 如果锁资源被占有了,并且当前线程并不是占有锁资源的线程。
                    try
                    {
                        wait();
                    } catch (InterruptedException e)
                    {
                    }
                }
                isLocked = true;
                lockCount++;
                lockedByThread = currentThread;
            }
    
        }
    
        public void unlock()
        {
    
            if (Thread.currentThread() == this.lockedByThread)
            {// 如果当前线程就是获得锁资源的线程,那么就lockCount进行自减.
                lockCount--;
                if (lockCount == 0)
                {// 如果lockCount恢复到0时就释放资源
                    isLocked = false;
                    notify();
                }
            }
        }
    
    }

## 总结 ##

锁的概念在很多场景都是会存在的不经事编程语言、数据库、操作系统、文件的其本质就是对共享资源的并发访问。
    其实java提供的ReentrantLock实现已经非常棒了，多看看其源码实现原理有助于提升自己的对编程模型的认识。

## 参考 ##

1、JDK源码实现  
2、[http://tutorials.jenkov.com/java-concurrency/locks.html][http_tutorials.jenkov.com_java-concurrency_locks.html]  
3、[https://www.ibm.com/developerworks/cn/java/j-lo-lock/][https_www.ibm.com_developerworks_cn_java_j-lo-lock]

[http_tutorials.jenkov.com_java-concurrency_locks.html]: http://tutorials.jenkov.com/java-concurrency/locks.html
[https_www.ibm.com_developerworks_cn_java_j-lo-lock]: https://www.ibm.com/developerworks/cn/java/j-lo-lock/