锁机制

public class MyLock {
//标识锁是否可用 如果值为true代表当前有线程正在使用该锁，如果为false代表没有人用锁
private boolean isLocked=false;
//获取锁：加锁
public synchronized void lock() throws InterruptedException {
//判断当前该锁是否正在使用
while (isLocked){
wait();
}
//当前没有人使用情况下就占用该锁
isLocked=true;
}
//释放锁
public synchronized void unLock(){
//将当前锁资源释放
isLocked=false;
//唤起正在等待使用锁的线程
notify();
}
}
public class MyLockTest {
MyLock myLock=new MyLock();
//A业务方法
public void print() throws InterruptedException {
//获取一把锁
myLock.lock();
System.out.println("print业务方法");
doAdd();
//释放锁
myLock.unLock();
}

//B业务方法
public void doAdd() throws InterruptedException {
//获取一把锁
myLock.lock();
System.out.println("doAdd业务方法");
//释放锁
myLock.unLock();
}

public static void main(String[] args) throws InterruptedException {
MyLockTest test=new MyLockTest();
test.print();
}
}

public class MyLockTest {
//A业务方法
public synchronized void print() throws InterruptedException {
//获取了一把锁
System.out.println("print业务方法");

doAdd();

}

//B业务方法
public synchronized void doAdd() throws InterruptedException {
System.out.println("doAdd业务方法");
//释放锁
}

public static void main(String[] args) throws InterruptedException {
MyLockTest test=new MyLockTest();
test.print();
}
}

public class MyLockTest {
//创建锁对象
Lock lock=new ReentrantLock();
//A业务方法
public void print() throws InterruptedException {
//获取了一把锁
lock.lock();
System.out.println("print业务方法");
doAdd();
//释放锁
lock.unlock();
}

//B业务方法
public void doAdd() throws InterruptedException {
//获取了一把锁
lock.lock();
System.out.println("doAdd业务方法");
//释放锁
lock.unlock();
}

public static void main(String[] args) throws InterruptedException {
MyLockTest test=new MyLockTest();
test.print();
}
}


ReentrantLock底层：
public ReentrantLock() {
//默认非公平锁
sync = new NonfairSync();
}

public ReentrantLock(boolean fair) {
//如果为true代表公平锁，否则为非公平锁
sync = fair ? new FairSync() : new NonfairSync();
}


public class MyReentrantLock {
//标识锁是否可用 如果值为true代表当前有线程正在使用该锁，如果为false代表没有人用锁
private boolean isLocked=false;
//当前线程
Thread lockedBy=null;
//加锁数量计数
Integer lockedCount=0;
//加锁
public synchronized void lock() throws InterruptedException {
//获取当前线程
Thread thread=Thread.currentThread();
//判断当前是否正在使用锁，如果正在使用则对比当前使用要使用锁的线程和之前使用锁的线程是否一致
//如果一致代表可以重入，继续使用锁，不会发生阻塞
//如果不一致代表当前不是一个线程，则等待
while (isLocked && thread!=lockedBy){
wait();
}
//占用锁
isLocked=true;
//计数+1
lockedCount++;
//赋值线程
lockedBy=thread;
}
//释放锁
public synchronized void unlock(){
//判断当前是否是用一个线程
if(Thread.currentThread()==this.lockedBy){
//锁使用计数器-1
lockedCount--;
//判断计数器是否为0，如果为0则释放锁，然后唤醒正在等待的线程
if(lockedCount==0){
isLocked=false;
notify();
}
}
}
}

public class ReadWriteLock {
//创建一个集合
static Map<String,String> map=new HashMap<String,String>();
//创建一个读写锁
static ReentrantReadWriteLock lock=new ReentrantReadWriteLock();
//获取读锁
static Lock readLock=lock.readLock();
//获取写锁
static Lock writeLock=lock.writeLock();
//写操作
public Object put(String key,String value){
writeLock.lock();
try {
System.out.println("Write正在执行写操作~");
Thread.sleep(100);
String put = map.put(key, value);
System.out.println("Write写操作执行完毕~");
return put;
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
writeLock.unlock();
}
return null;

}

//写操作
public Object get(String key){
readLock.lock();
try {
System.out.println("Read正在执行读操作~");
Thread.sleep(100);
String value = map.get(key);
System.out.println("Read读操作执行完毕~");
return value;
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
readLock.unlock();
}
return null;

}

public static void main(String[] args) {
ReadWriteLock lock=new ReadWriteLock();
for (int i = 0; i < 10; i++) {
int finalI = i;
new Thread(()->{
try {
//写操作
lock.put(finalI +"","value"+finalI);
//读操作
System.out.println(lock.get(finalI+""));
} catch (Exception e) {
e.printStackTrace();
}
}).start();
}

}
}