独占锁 共享锁 java_可重入不可重入锁，自旋锁，独占锁（写锁），共享锁（读锁），互斥锁，学习案例...

可重入不可重入锁

/**

* @ClassName ReenterLockDemo

* @Description 可重入锁(也叫递归锁)

*

* 指的是同一线程 外层函数获得锁之后，内层递归函数仍然能获得该锁的代码

* 在同一个线程的外层方法获取锁的时候，进入内层方法时会自动获得该锁

*

* 也就是说 线程可以进入任何一个他已经拥有的锁所同步着的代码块

**/

public class ReenterLockDemo {

public static void main(String[] args) {

Phone phone = new Phone();

ExecutorService executorService = Executors.newFixedThreadPool(2);

// for(int i =0; i < 100; i++){

// executorService.execute(()-> {

// try {

// phone.sendMsg();

// } catch (Exception e) {

// e.printStackTrace();

// }

// });

// }

for(int i =0; i < 2; i++){

executorService.execute(phone);

}

executorService.shutdown();

}

}

class Phone implements Runnable{

public synchronized void sendMsg() throws Exception{

System.out.println(Thread.currentThread().getName() + "sendMsg");

sendEmail();

}

public synchronized void sendEmail() throws Exception{

System.out.println(Thread.currentThread().getName() + "sendEmail");

}

Lock lock = new ReentrantLock();

@Override

public void run() {

get();

}

public void get(){

lock.lock();

try {

System.out.println(Thread.currentThread().getName() + "get");

set();

}finally {

lock.unlock();

}

}

public void set(){

lock.lock();

System.out.println(Thread.currentThread().getName() + "set");

lock.unlock();

}

}

自旋锁

/**

* @ClassName SpinLockDemo

* @Description 自旋锁

*

* 自旋锁是指尝试获取锁的线程不会立即堵塞，而是采用循环的方式尝试去获取锁

* 这样的好处是可以减少线程上下文的切换， 缺点是循环会消耗cpu

**/

public class SpinLockDemo {

AtomicReference atomicReference = new AtomicReference<>();

public void myLock(){

Thread thread = Thread.currentThread();

System.out.println(thread.getName() + "\t come in !");

while (!atomicReference.compareAndSet(null,thread)){

// System.out.println("我转！我转！");

}

}

public void myUnLock(){

Thread thread = Thread.currentThread();

atomicReference.compareAndSet(thread,null);

System.out.println(thread.getName() + "\t myUnLock !");

}

public static void main(String[] args) throws InterruptedException {

SpinLockDemo demo = new SpinLockDemo();

new Thread(() ->{

demo.myLock();

try {

TimeUnit.SECONDS.sleep(5);

} catch (InterruptedException e) {

e.printStackTrace();

}

demo.myUnLock();

},"AA").start();

TimeUnit.SECONDS.sleep(1);

new Thread(() ->{

demo.myLock();

demo.myUnLock();

},"BB").start();

}

}

独占锁(写锁)，共享锁(读锁)，互斥锁

/**

* @ClassName ReadWriteLockDemo

* @Description 互斥锁

*

* 多个线程同时读一个资源类没有任何问题，所以为了满足并发量，读取共享资源时，应该可以同时进行

* 但是如果有一个线程尝试去写共享资源时，就不应该有其他的线程去读或者写

* 小总结： 读-读 能共存

* 读-写 不能共存

* 写-写 不能共存

**/

class MyCache{

private volatile Map map = new HashMap<>();

private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();

public void put(String key, Object value) {

rwLock.writeLock().lock();

try {

System.out.println(Thread.currentThread().getName() + "\t 正在写入: " + key);

try {

TimeUnit.MILLISECONDS.sleep(300);

} catch (InterruptedException e) {

e.printStackTrace();

}

map.put(key, value);

System.out.println(Thread.currentThread().getName() + "\t 写入完成 ");

}catch (Exception e){

}finally {

rwLock.writeLock().unlock();

}

}

public void get(String key) {

rwLock.readLock().lock();

try {

System.out.println(Thread.currentThread().getName() + "\t 正在读取");

try {

TimeUnit.MILLISECONDS.sleep(300);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + "\t 读取完成: " + map.get(key));

}catch (Exception e){

}finally {

rwLock.readLock().unlock();

}

}

}

public class ReadWriteLockDemo {

public static void main(String[] args) {

MyCache myCache = new MyCache();

for(int i = 1; i <= 5; i++){

final int ii = i;

new Thread(()-> myCache.put(ii + "", ii + "")

,String.valueOf(i)).start();

}

for(int i = 1; i <= 5; i++){

final int ii = i;

new Thread(()-> myCache.get(ii + "")

,String.valueOf(i)).start();

}

}

}

本文地址：https://blog.csdn.net/qq_38854914/article/details/107379037

如您对本文有疑问或者有任何想说的，请点击进行留言回复，万千网友为您解惑！