Java自旋锁和读写锁

Java自旋锁理论知识

定义

Java自旋锁代码验证

package InterviewTest;
import java.util.concurrent.atomic.AtomicReference;
/*
 * 题目：实现一个自旋锁
 * 自旋锁的好处：循环比较获取，直到成功为止。没有类似wait的阻塞
 * 通过CAS操作完成自旋锁，A线程先进来调用myLock方法自己持有5秒钟，B随后进来发现
 * 当前有线程持有锁，不是null，所以只能通过自旋等待，直到A释放锁后B随后抢到
 * 
 */
public class SpinLockDemo {
	//原子引用线程
	AtomicReference<Thread> atomicReference = new AtomicReference<>();
	public void myLock() {
		Thread thread = Thread.currentThread();
		System.out.println(Thread.currentThread().getName()+"  come in O(n_n)O");
		while(!atomicReference.compareAndSet(null, thread)) {
		}
	}
	public void myUnlock(){
		Thread thread = Thread.currentThread();
		atomicReference.compareAndSet(thread, null);
		System.out.println(Thread.currentThread().getName()+"  myUnlock O(n_n)O");
	}
	public static void main(String[] args) {
		SpinLockDemo spinLockDemo = new SpinLockDemo();
		
		new Thread(() ->{
			spinLockDemo.myLock();
			try {
				Thread.sleep(5000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			spinLockDemo.myUnlock();
		},"AA").start();
		
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		new Thread(()->{
			spinLockDemo.myLock();
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			spinLockDemo.myUnlock();
		},"BB").start();
	}
}

优缺点：

**优点：**循环比较获取，直到成功为止。没有类似wait的阻塞
**缺点：**如果线程一直没有获取到资源，那么就会不断的尝试获取，类似于死循环，这样会一直占用CPU，会对CPU造成一定的压力

独占锁（写锁）/共享锁（读锁）/互斥锁

定义

读写锁代码验证

package InterviewTest;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

//写操作=原子性+独占,整个过程必须是一个完整的统一体，中间不能被分割，打断
//资源类
class MyCache{
	private volatile Map<String,Object> map = new HashMap<String, Object>();
//	private Lock lock = new ReentrantLock();//保证一致性，降低了并发性
	private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
	public void put(String key,Object value) {
		/*加写锁*/
		readWriteLock.writeLock().lock();
		try {
			/*不加锁*/
	System.out.println(Thread.currentThread().getName()+"   正在写入: "+key);
			try {
				Thread.sleep(300);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			map.put(key, value);
	System.out.println(Thread.currentThread().getName()+"   写入完成 ");
			/*不加锁*/
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			readWriteLock.writeLock().unlock();
		}
		/*加写锁*/
	}
	public void get(String key) {
		/*加读锁*/
		readWriteLock.readLock().lock();
		try {
			/*不加锁*/
	System.out.println(Thread.currentThread().getName()+"   正在读取 ");
			try {
				Thread.sleep(300);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			Object value = map.get(key);
	System.out.println(Thread.currentThread().getName()+"   读取完成 :"+value);
			/*不加锁*/
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			readWriteLock.readLock().unlock();
		}
		/*加读锁*/
	}
}
/*
 * 多个线程同时读一个资源类没有任何问题，所以为了满足并发量，
 * 读取共享资源应该可以同时进行
 * 
 * 但是，如果一个线程想去写共享资源来，就不应该再有其他的线程可以对该资源进行读或写
 * 
 * 小总结：
 * 		读----：能共享
 * 		读---写：不能共享
 * 		写---写：不能共享
 * 加lock：读写都只能一个进程进行，保证了安全性，但是降低了并发性
 * 
 */


public class ReadWriteLockDemo {
	public static void main(String[] args) {
		MyCache myCache = new MyCache();
		for(int i=1;i<=5;i++) {
			final int tempInt = i;
			new Thread(()->{
				myCache.put(tempInt+"", tempInt+"");
			},String.valueOf(i)).start();
		}
		for(int i=1;i<=5;i++) {
			final int tempInt = i;
			new Thread(()->{
				myCache.get(tempInt+"");
			},String.valueOf(i)).start();
		}
	}
}