Java 中的锁

我就是我 2022-06-15 01:45 138阅读 0赞

# lock接口 #

锁时用来控制多个线程访问共享资源的方式，一般来说，一个锁能够防止多个线程同时访问共享资源（但是有些锁可以允许多个线程并发的访问共享资源，比如读写锁）。在Lock接口出现之前，java程序时靠synchronized关键字实现锁的功能。但是Lock接口出现之后，我们用来实现锁功能，它提供了与synchronized关键字类似的同步功能，只是在使用时需要显式地获取锁和释放锁。虽然它缺少了synchronized 关键字提供的隐式获取释放锁的便捷性，但是却拥有了锁获取与释放的可操作性，可中断的获取锁以及超时获取锁等多种synchronized关键字所不具备的同步特性。

Lock lock=new ReentrantLock();
    		lock.lock();
    		try {
    			
    		} finally {
    			lock.unlock();
    		}

在finally中释放锁，目的是保证在获取到锁之后，最终能够被释放。不能把获取锁写到try里面，因为如果获取锁发生了异常，异常抛出的时候，会导致锁失效。

# synchronized和lock的区别 #

接下来我将要通过一个非常经典的例子来验证一下他们两个之间的区别。

public class LockTest {
    	public static void main(String[] args) {
    		final synData data = new synData();
    		try {
    			for (int i = 0; i < 3; i++) {
    				Thread t = new Thread(new Runnable() {
    					public void run() {
    						data.addCount();
    
    					}
    				});
    				Thread t2 = new Thread(new Runnable() {
    					public void run() {
    						try {
    							data.deleteCount();
    						} catch (InterruptedException e) {
    							// TODO Auto-generated catch block
    							e.printStackTrace();
    						}
    
    					}
    				});
    				t.setName("input" + i);
    				t.start();
    				t2.setName("output" + i);
    				t2.start();
    
    			}
    		} finally {
    
    		}
    
    	}
    }
    
    class synData {
    	public Integer count = 0;
    	private volatile Lock lock = new ReentrantLock();
    
    	public void addCount() {
    		lock.lock();
    		System.out.println(Thread.currentThread().getName() + "线程进入锁");
    		try {
    			System.out.println(Thread.currentThread().getName() + "添加数据" + count);
    			count++;
    		} catch (Exception e) {
    
    		} finally {
    			lock.unlock();
    			System.out.println(Thread.currentThread().getName()+"线程释放锁");
    		}
    	}
    
    	public synchronized void deleteCount() throws InterruptedException {
    			System.out.println(Thread.currentThread().getName() + "线程进入锁");
    			if (Thread.currentThread().getName().equals("output0")) {
    				Thread.sleep(3000);
    			}
    
    			try {
    				System.out.println(Thread.currentThread().getName() + "删除数据" + count);
    				count--;
    			} catch (Exception e) {
    
    			} finally {
    				System.out.println(Thread.currentThread().getName()+"线程释放锁");
    			}
    
    	}
    }

我们看打印结果

**input0线程进入锁  
output0线程进入锁  
input0添加数据0  
input0线程释放锁  
input1线程进入锁  
input1添加数据1  
input1线程释放锁  
input2线程进入锁  
input2添加数据2  
input2线程释放锁  
output0删除数据3  
output0线程释放锁  
output1线程进入锁  
output1删除数据2  
output1线程释放锁  
output2线程进入锁  
output2删除数据1  
output2线程释放锁**

输出线程output0进入锁，然后所有的输出线程都被锁住，把inout线程执行完之后，休眠3秒后，再执行outpu线程，然后释放锁，后面的才可以执行。

这里我们把锁换成lock试试

public  void deleteCount() throws InterruptedException {
    		lock.lock();
    			System.out.println(Thread.currentThread().getName() + "线程进入锁");
    			if (Thread.currentThread().getName().equals("output0")) {
    				Thread.sleep(3000);
    			}
    
    			try {
    				System.out.println(Thread.currentThread().getName() + "删除数据" + count);
    				count--;
    			} catch (Exception e) {
    
    			} finally {
    				lock.unlock();
    				System.out.println(Thread.currentThread().getName()+"线程释放锁");
    			}
    		}

**input0线程进入锁  
input0添加数据0  
input1线程进入锁  
input1添加数据1  
input0线程释放锁  
input1线程释放锁  
output0线程进入锁  
output0删除数据2  
output0线程释放锁  
input2线程进入锁  
input2添加数据1  
input2线程释放锁  
output1线程进入锁  
output1删除数据2  
output1线程释放锁  
output2线程进入锁  
output2删除数据1  
output2线程释放锁**  
 我们会发现ReentrantLock 与synchronized有相同的并发性和内存语义，还包含了中断锁等候和定时锁等候，这里output0获取了锁，会导致input线程也在等待这个锁的释放。因为他们都会共享count这个资源，如果你不主动释放锁的话，整个线程就会奔溃。

也许有朋友会问，怎么会输出这个结果？第二个线程怎么会在第一个线程释放锁之前得到了锁？原因在于，在add和delete方法中的lock变量是局部变量，每个线程执行该方法时都会保存一个副本，那么理所当然每个线程执行到lock.lock()处获取的是不同的锁，所以就不会发生冲突。

知道了原因改起来就比较容易了，只需要将lock声明为类的属性即可。

private static Lock lock = new ReentrantLock();

input0线程进入锁  
input0添加数据0  
input0线程释放锁  
output0线程进入锁  
output0删除数据1  
output0线程释放锁  
input1线程进入锁  
input1添加数据0  
input1线程释放锁  
output1线程进入锁  
output1删除数据1  
output1线程释放锁  
input2线程进入锁  
input2添加数据0  
input2线程释放锁  
output2线程进入锁  
output2删除数据1  
output2线程释放锁  
 我们可以看到每个线程必须释放完锁之后，下一个线程才可以进来

除此之外他们还有以下几个区别

## 1.尝试非阻塞地获取锁 当前线程尝试获取锁，如果这一时刻锁没有被其他线程获取到，则成功获取并且持有该锁。 ##

public void method() throws InterruptedException {
        lock.lockInterruptibly();
        try {  
         //.....
        }
        finally {
            lock.unlock();
        }  
    }

注意，当一个线程获取了锁之后，是不会被interrupt()方法中断的。因为本身在前面的文章中讲过单独调用interrupt()方法不能中断正在运行过程中的线程，只能中断阻塞过程中的线程。

因此当通过lockInterruptibly()方法获取某个锁时，如果不能获取到，只有进行等待的情况下，是可以响应中断的。

而用synchronized修饰的话，当一个线程处于等待某个锁的状态，是无法被中断的，只有一直等待下去。

## 2.能被中断地获取锁 在获取到锁的程序能够中断响应，当获取到锁的线程被中断时，中断异常会被抛出，同时释放该锁。 ##

## 3.超时获取锁 在指定的时间之前获取锁，如果截止时间到了仍旧无法获取锁，则返回。 ##

Lock lock = ...;
    if(lock.tryLock()) {
         try{
             //处理任务
         }catch(Exception ex){
     
         }finally{
             lock.unlock();   //释放锁
         } 
    }else {
        //如果不能获取锁，则直接做其他事情
    }

#    ReadWriteLock #

ReadWriteLock也是一个接口，在它里面只定义了两个方法：

public interface ReadWriteLock {
        /**
         * Returns the lock used for reading.
         *
         * @return the lock used for reading.
         */
        Lock readLock();
     
        /**
         * Returns the lock used for writing.
         *
         * @return the lock used for writing.
         */
        Lock writeLock();
    }

一个用来获取读锁，一个用来获取写锁。也就是说将文件的读写操作分开，分成2个锁来分配给线程，从而使得多个线程可以同时进行读操作。下面的ReentrantReadWriteLock实现了ReadWriteLock接口

ReentrantReadWriteLock有以下几个特性：

*  公平性
    
     *  非公平锁（默认） 这个和独占锁的非公平性一样，由于读线程之间没有锁竞争，所以读操作没有公平性和非公平性，写操作时，由于写操作可能立即获取到锁，所以会推迟一个或多个读操作或者写操作。因此非公平锁的吞吐量要高于公平锁。
     *  公平锁 利用AQS的CLH队列，释放当前保持的锁（读锁或者写锁）时，优先为等待时间最长的那个写线程分配写入锁，当前前提是写线程的等待时间要比所有读线程的等待时间要长。同样一个线程持有写入锁或者有一个写线程已经在等待了，那么试图获取公平锁的（非重入）所有线程（包括读写线程）都将被阻塞，直到最先的写线程释放锁。如果读线程的等待时间比写线程的等待时间还有长，那么一旦上一个写线程释放锁，这一组读线程将获取锁。
 *  重入性
    
     *  读写锁允许读线程和写线程按照请求锁的顺序重新获取读取锁或者写入锁。当然了只有写线程释放了锁，读线程才能获取重入锁。
     *  写线程获取写入锁后可以再次获取读取锁，但是读线程获取读取锁后却不能获取写入锁。
     *  另外读写锁最多支持65535个递归写入锁和65535个递归读取锁。
 *  锁降级
    
     *  写线程获取写入锁后可以获取读取锁，然后释放写入锁，这样就从写入锁变成了读取锁，从而实现锁降级的特性。
 *  锁升级
    
     *  读取锁是不能直接升级为写入锁的。因为获取一个写入锁需要释放所有读取锁，所以如果有两个读取锁视图获取写入锁而都不释放读取锁时就会发生死锁。
 *  锁获取中断
    
     *  读取锁和写入锁都支持获取锁期间被中断。这个和独占锁一致。
 *  条件变量
    
     *  写入锁提供了条件变量(Condition)的支持，这个和独占锁一致，但是读取锁却不允许获取条件变量，将得到一个UnsupportedOperationException异常。
 *  重入数
    
     *  读取锁和写入锁的数量最大分别只能是65535（包括重入数）。

public class LockRead {
    	private ReentrantReadWriteLock rwl=new ReentrantReadWriteLock();
    	String str="0123456789";
    	 public synchronized void get(Thread thread) {
    	      for(int i=0;i<str.length();i++){
    	        System.out.println(thread.getName()+"读操作完毕"+str.charAt(i));
    	      }
    	    }
    	public static void main(String[] args) {
    		final LockRead test=new LockRead();
    		new Thread(){
                public void run() {
                    test.get(Thread.currentThread());
                };
            }.start();
     
            new Thread(){
                public void run() {
                    test.get(Thread.currentThread());
                };
            }.start();
    	}
    
    }

**Thread-0读操作完毕0  
Thread-0读操作完毕1  
Thread-0读操作完毕2  
Thread-0读操作完毕3  
Thread-0读操作完毕4  
Thread-0读操作完毕5  
Thread-0读操作完毕6  
Thread-0读操作完毕7  
Thread-0读操作完毕8  
Thread-0读操作完毕9  
Thread-1读操作完毕0  
Thread-1读操作完毕1  
Thread-1读操作完毕2  
Thread-1读操作完毕3  
Thread-1读操作完毕4  
Thread-1读操作完毕5  
Thread-1读操作完毕6  
Thread-1读操作完毕7  
Thread-1读操作完毕8  
Thread-1读操作完毕9**  
这段程序的输出结果会是，直到thread1执行完读操作之后，才会打印thread2执行读操作的信息。

而改成用读写锁的话：

public void get(Thread thread) {
    		rwl.readLock().lock();
    		try {
    			for (int i = 0; i < str.length(); i++) {
    				System.out.println(thread.getName() + "读操作完毕" + str.charAt(i));
    			}
    		} finally {
    			rwl.readLock().unlock();
    		}
    	}

**Thread-0读操作完毕0  
Thread-1读操作完毕0  
Thread-0读操作完毕1  
Thread-1读操作完毕1  
Thread-0读操作完毕2  
Thread-1读操作完毕2  
Thread-1读操作完毕3  
Thread-1读操作完毕4  
Thread-1读操作完毕5  
Thread-1读操作完毕6  
Thread-1读操作完毕7  
Thread-0读操作完毕3  
Thread-0读操作完毕4  
Thread-1读操作完毕8  
Thread-0读操作完毕5  
Thread-1读操作完毕9  
Thread-0读操作完毕6  
Thread-0读操作完毕7  
Thread-0读操作完毕8  
Thread-0读操作完毕9**

说明thread1和thread2在同时进行读操作。

这样就大大提升了读操作的效率。

不过要注意的是，如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。

如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，则申请的线程会一直等待释放写锁。

# Lock和synchronized的选择 #

总结来说，Lock和synchronized有以下几点不同：

1）Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；

2）synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；

3）Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；

4）通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。

5）Lock可以提高多个线程进行读操作的效率。

在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。所以说，在具体使用时要根据适当情况选择。