基础学习-05-java锁

桃扇骨 2021-10-19 03:01 299阅读 0赞

#### 1.公平锁 ####

多个线程按照申请锁的顺序来获取锁。  
按照FIFO（先进先出）规则来获取锁。

#### 2.非公平锁 ####

多个线程获取锁的顺序不是按照申请锁的顺序，有可能后申请的线程优先获得锁。  
在高并发的情况下，那么就有可能造成优先级反转或饥饿现象。

#### 3.公平锁和非公平锁的获取 ####

并发包中java.util.concurrent.locks.ReentrantLock的创建，可以通过构造函数的布尔值来获取公平锁和非公平锁，默认是非公平锁的。

//java.util.concurrent.locks.ReentrantLock类中
    //无参构造，是非公平锁的
    public ReentrantLock() { 
            sync = new NonfairSync();
    }
    //通过boolean来获取公平锁或非公平锁
    //true为公平锁，false为非公平锁
    public ReentrantLock(boolean fair) { 
            sync = fair ? new FairSync() : new NonfairSync();
        }

#### 4.可重入锁（递归锁） ####

同一线程外层函数获得锁后，内层递归函数依然能获取该锁。  
同一线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。  
即：线程可以进入任何一个它已经拥有的锁所同步的代码块。

*  ReentrantLock、Synchronized就是典型的可重入锁。
 *  可重入锁最大作用：避免死锁。

#### 5.自旋锁 ####

尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁。  
好处：减少线程上下文切换的消耗  
缺点：循环获取会消耗CPU

![!\[自旋锁原理\]\[1\]][1]

package cn.chen.demo.lockdemo;
    
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.atomic.AtomicReference;
    
    /** * * @ClassName: SpinLockDemo * @Description: 自旋锁的实现 * @author: chenlf * 1.原理：循环比较获取直到成功为止，没有类似wait阻塞 * 2.通过CAS操作完成自旋锁 * */
    public class SpinLockDemo { 
    	//原子引用线程
    	AtomicReference<Thread> atomicThread = new AtomicReference<>();
    	//上锁
    	public void myLock() { 
    		//当前线程对象
    		Thread thread = Thread.currentThread();
    		System.out.println("当前线程：" + Thread.currentThread().getName()+" 获取锁成功！");
    		//比较当前对象，期望值是null,如果atomicThread为null，则将当前线程thread设置进去。
    			//此处满足条件，atomicThread.compareAndSet(null, thread)返回值为true
    			//取反，因此第一次并没有进while循环体
    		while (!atomicThread.compareAndSet(null, thread)) { 
    			
    		}
    	}
    	//解锁
    	public void myUnLock() { 
    		//当前线程对象
    		Thread thread = Thread.currentThread();
    		//解锁时变成null
    		atomicThread.compareAndSet(thread, null);
    		System.out.println("当前线程：" + Thread.currentThread().getName()+" 释放锁成功！");
    		
    	}
    	
    	public static void main(String[] args) { 
    		SpinLockDemo spinLock = new SpinLockDemo();
    		//线程A
    		new Thread(()->{ 
    			spinLock.myLock();//上锁
    			try {  TimeUnit.SECONDS.sleep(5);} catch (Exception e) {  e.printStackTrace(); }//暂停线程占用锁5秒钟 
    			spinLock.myUnLock();//解锁
    		},"线程A"	).start();
    		//为了确保线程A先获取锁，暂停2秒钟
    		try {  TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) {  e.printStackTrace(); }
    		//线程B
    		new Thread(()->{ 
    			spinLock.myLock();//上锁
    			try {  TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) {  e.printStackTrace(); }
    			spinLock.myUnLock();//解锁
    		},"线程B"	).start();
    	}
    	/** * 运行结果： 当前线程：线程A 获取锁成功！ 当前线程：线程B 获取锁成功！ 当前线程：线程A 释放锁成功！ 当前线程：线程B 释放锁成功！ B需要等A用完锁才能用锁 */
    }

#### 6.读写锁 ####

独占锁：锁一次只能被一个线程所持有。ReentrantLock和Synchronized均是独占锁  
共享锁：锁可以被多个线程所持有。  
ReentrantReadWritrLock 其读锁是共享锁，写锁则为独占锁。  
读锁的共享锁可以保证并发读，效率非常高。读写，写读，写写的过程为互斥的。

package cn.chen.demo.lockdemo;
    /** * * @ClassName: ReentrantReadWriteLockDemo * @Description: 读写锁 * @author: chenlf * 读：多个线程可以同时读取一个资源类。 * 写：如果有一个线程想去写共享资源，那么其他线程就无法对该资源进行读或写 * 因此，读读可以共存，而读写、写写则是互斥的。 */
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.ReentrantReadWriteLock;
    
    /** * * @ClassName: MyCache * @Description:模拟缓存 * @author: chenlf * */
    class MyCache{ //资源类
    	//保证可见性、及时性：一有更新立即通知
    	private volatile Map<String,Object> map = new HashMap<>();
    	//读写说
    	private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    	
    	/** * @Title: put * @Description: 写操作 * @author: chenlf */
    	public void put(String key, Object value) { 
    		rwLock.writeLock().lock();//写锁
    		try { 
    			System.out.println(Thread.currentThread().getName()+" 正在写入："+key+"="+value);
    			//暂停线程占用锁 
    			try {  TimeUnit.MILLISECONDS.sleep(300);} catch (Exception e) {  e.printStackTrace(); }
    			map.put(key, value);
    			System.out.println(Thread.currentThread().getName()+" 写入完成："+key+"="+value);
    		} catch (Exception e) { 
    			e.printStackTrace();
    		} finally { 
    			rwLock.writeLock().unlock();//释放锁
    		}
    	}
    	
    	/** * @Title: get * @Description: 读操作 * @author: chenlf */
    	public void get(String key) { 
    		rwLock.readLock().lock();
    		try { 
    			System.out.println(Thread.currentThread().getName()+" 正在读取："+key);
    			try {  TimeUnit.MILLISECONDS.sleep(300);} catch (Exception e) {  e.printStackTrace(); }
    			Object value = map.get(key);
    			System.out.println(Thread.currentThread().getName()+" 读取完成："+value);
    		} catch (Exception e) { 
    			e.printStackTrace();
    		} finally { 
    			rwLock.readLock().unlock();
    		}
    	}
    	
    	/** * * @Title: clearMap * @Description: 清除缓存 * @author: chenlf */
    	public void clearMap(){ 
    		map.clear();
    	}
    }
    
    public class ReentrantReadWriteLockDemo { 
    
    		public static void main(String[] args) { 
    			
    			MyCache myCache = new MyCache();
    			//模拟写操作
    			for (int i = 0; i <= 5; i++) { 
    				final int tempInt = i;
    				new Thread(()-> { 
    					myCache.put(tempInt+"", tempInt+"");
    				},String.valueOf(i)).start();
    			}
    			//模拟读操作
    			for (int i = 0; i <= 5; i++) { 
    				final int tempInt = i;
    				new Thread(()-> { 
    					myCache.get(tempInt+"");
    				},String.valueOf(i)).start();
    			}
    		}
    		//写不被打断，读不做限制
    }

[1]: /images/20211018/0b390d872a8e4995a6008aa8863180ab.png