Java多线程再学习，温故知新（四）Lock

系统管理员 2022-03-26 09:16 211阅读 0赞

## Lock接口的认识与使用 ##

Lock可以实现与Synchronized同样的功能，需要显示地获取和释放锁，繁琐能让代码更灵活  
Synchronized不需要显示地获取和释放锁简单，但是比较重不好控制

使用Lock可以方便的实现公平性，以下例子用ReentrantLock实现一个Lock功能

非阻塞的获取锁  
    能被中断的获取锁  
    超时获取锁

import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class Sequence {
    	
    	private int value;
    	Lock lock = new ReentrantLock();
    	Lock l1 = new ReentrantLock();
    	
    	/**
    	 * @return
    	 */
    	public  int getNext() {
    		lock.lock();
    		int a = value ++;
    		lock.unlock();
    		return a;
    	}
    	
    	public static void main(String[] args) {
    		
    		Sequence s = new Sequence();
    		
    		new Thread(new Runnable() {
    			
    			@Override
    			public void run() {
    				while(true) {
    					System.out.println(Thread.currentThread().getName() + " " + s.getNext());
    					try {
    						Thread.sleep(100);
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    				}
    			}
    		}).start();
    		
    		new Thread(new Runnable() {
    			
    			@Override
    			public void run() {
    				while(true) {
    					System.out.println(Thread.currentThread().getName() + " " + s.getNext());
    					try {
    						Thread.sleep(100);
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    				}
    			}
    		}).start();
    		
    		new Thread(new Runnable() {
    			
    			@Override
    			public void run() {
    				while(true) {
    					System.out.println(Thread.currentThread().getName() + " " + s.getNext());
    					try {
    						Thread.sleep(100);
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    				}
    			}
    		}).start();
    		
    	}
    }

## 自己实现一个锁 ##

使用synchronized 实现Lock接口，实现接口中lock方法和unlock方法

import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.Lock;
    
    public class MyLock implements Lock {
    	
    	private boolean isLocked = false;
    	
    	private Thread lockBy = null;
    	
    	private int lockCount = 0;
    
    	@Override
    	public synchronized void lock() {
    		// 获取当前线程
    		Thread currentThread = Thread.currentThread(); // Thread-0
    		// 第一次线程进来不会被锁，当前线程也不会被锁,第二次如果是同一线程也不锁
    		while (isLocked && currentThread != lockBy)
    			try {
    				wait();
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    		isLocked = true;//第二次进来如果不是当前线程执行这三行
    		lockBy = currentThread;
    		lockCount ++; // 1   2
    	}
    	
    	@Override
    	public synchronized void unlock() {
            //如果不是当前线程不执行
    		if(lockBy == Thread.currentThread()) {
    			lockCount --;  // 1  0
    			//只有所有锁都释放的时候才唤醒
    			if(lockCount == 0) {
    				notify();
    				isLocked = false;
    			}
    		}
    	}
    
    	@Override
    	public void lockInterruptibly() throws InterruptedException {
    		
    	}
    
    	@Override
    	public boolean tryLock() {
    		return false;
    	}
    
    	@Override
    	public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
    		// TODO Auto-generated method stub
    		return false;
    	}
    
    	
    	@Override
    	public Condition newCondition() {
    		// TODO Auto-generated method stub
    		return null;
    	}
    
    }

验证锁是否能锁住，可以锁住不会有线程安全性问题

import java.util.concurrent.locks.Lock;
    
    public class Sequence {
    
    	private MyLock lock = new MyLock();
    
    	private int value;
    
    	public int getNext() {
    		lock.lock();
    		value++;
    		lock.unlock();
    		return value;
    	}
    	
    	public static void main(String[] args) {
    		
    		Sequence s = new Sequence();
    		
    		new Thread(new Runnable() {
    			
    			@Override
    			public void run() {
    				while(true)
    				System.out.println(s.getNext());
    			}
    		}).start();
    		new Thread(new Runnable() {
    			
    			@Override
    			public void run() {
    				while(true)
    				System.out.println(s.getNext());
    			}
    		}).start();
    		new Thread(new Runnable() {
    			
    			@Override
    			public void run() {
    				while(true)
    				System.out.println(s.getNext());
    			}
    		}).start();
    		new Thread(new Runnable() {
    			
    			@Override
    			public void run() {
    				while(true)
    				System.out.println(s.getNext());
    			}
    		}).start();
    		new Thread(new Runnable() {
    			
    			@Override
    			public void run() {
    				while(true)
    				System.out.println(s.getNext());
    			}
    		}).start();
    	}
    }

验证锁是否可重入，下面例子中a,b,c都会被打印证明锁可以重入

import java.util.concurrent.locks.Lock;
    
    public class Demo {
    	
    	Lock lock = new MyLock();
    	
    	public void a() {
    		lock.lock();
    		System.out.println("a");
    		b();
    		lock.unlock();
    	}
    	
    	public void b() {
    		lock.lock();
    		System.out.println("b");
    		c();
    		lock.unlock();
    	}
    	
    	public void c() {
    		lock.lock();
    		System.out.println("c");
    		lock.unlock();
    	}
    	
    	public static void main(String[] args) {
    		Demo d = new Demo();
    		
    		new Thread(new Runnable() {
    			
    			@Override
    			public void run() {
    				d.a();
    			}
    		}).start();
    	}
    
    }