java 锁实现_自己实现java锁

雨点打透心脏的1/2处 2022-11-11 14:54 149阅读 0赞

importjava.lang.reflect.Field;importjava.util.concurrent.locks.LockSupport;importjava.util.concurrent.locks.ReentrantLock;importsun.misc.Unsafe;/\*\*\* 简单的重入锁

\*@version1.0

\*@authorjimmyyong

\*\*/

public classSimpleReentrantLock \{private volatile staticUnsafe unsafe;/\*\*state内存地址给cas操作用的\*/

private volatile static longstateoffset;private volatile static longheadoffset;private volatile static longtailoffset;private volatile static longwaitoffset;/\*\*锁的状态，不为0表示有线程占有锁\*/

public volatile intstate;public volatile Node head = newNode();public volatile Node tail =head;

SimpleReentrantLock()\{

\}/\*\*\* 获取锁，可重入

\*@returntrue：获取锁成功 false：获取锁失败\*/

public voidlock()\{//if(!tryAcquire(1))

acquire(1);

\}/\*\*\* 释放锁，可重入

\*@returntrue：获取锁成功 false：获取锁失败\*/

public booleanunlock()\{for(;;)\{if(setCASWait(head,2, 0))\{if(state-1 == 0)\{

Node next=head.next;if(next != null)\{if(next.next != null)\{

head.next=next.next;

unsafe.unpark(next.thread);

state=state-1;

setCASWait(head,0, 2);return true;

\}/\*\*\* 获取锁

\*@parami

\*@return

\*/

public void acquire(inti)\{for(;;)\{try\{if(tryAcquire(1))\{return;

Node node= newNode();

node.thread=Thread.currentThread();if(addQueue(node))\{

setCASWait(head,1, 2);return;

LockSupport.park();

\}finally\{//\*\*\*\*

\}/\*\*\* 尝试获取锁

\*@param增量数字

\*@return获取锁是否成功\*/

public boolean tryAcquire(inti)\{if(setCASState(0,i))\{return true;

\}return false;

\}/\*\*\* 添加等待队列

\*@paramnode

\*@return

\*/

public booleanaddQueue(Node node)\{for(;;)\{if(setCASWait(head,2, 1))\{if(tryAcquire(1))\{return true;

Node oldtail=tail;if(setCASTail(oldtail, node))\{

oldtail.next= node; //竞技条件

setCASWait(head,1, 2);return false;

\}/\*\*\* 操作堆外内存

\*@return

\*/

public staticUnsafe getUnsafe()\{

Field f1;try\{

f1= Unsafe.class.getDeclaredField("theUnsafe");

f1.setAccessible(true);return (Unsafe) f1.get(null);

\}catch(NoSuchFieldException e) \{

e.printStackTrace();

\}catch(SecurityException e) \{

e.printStackTrace();

\}catch(IllegalArgumentException e) \{

e.printStackTrace();

\}catch(IllegalAccessException e) \{

e.printStackTrace();

\}return null;

\}/\*\*\* cas赋值state

\*@paramexche 判断值

\*@paramupdate 更新值

\*@returntrue：表示修改成功，false修改失败\*/

public boolean setCASState(int exche,intupdate)\{return unsafe.compareAndSwapInt(this, stateoffset, exche, update);

\}/\*\*\* cas赋值head

\*@paramexche 判断值

\*@paramupdate 更新值

\*@returntrue：表示修改成功，false修改失败\*/

public booleansetCASHead(Node exche,Node update)\{return unsafe.compareAndSwapObject(this, headoffset, exche, update);

\}/\*\*\* cas赋值tail

\*@paramexche 判断值

\*@paramupdate 更新值

\*@returntrue：表示修改成功，false修改失败\*/

public booleansetCASTail(Node exche,Node update)\{return unsafe.compareAndSwapObject(this, tailoffset, exche, update);

\}/\*\*\* cas赋值tail

\*@paramexche 判断值

\*@paramupdate 更新值

\*@returntrue：表示修改成功，false修改失败\*/

public boolean setCASWait(Node obj,int exche,intupdate)\{returnunsafe.compareAndSwapInt(obj, waitoffset, exche, update);

\}/\*\*给内存地址赋值\*/

static\{

unsafe=getUnsafe();try\{

stateoffset= unsafe.objectFieldOffset(SimpleReentrantLock.class.getField("state"));

headoffset= unsafe.objectFieldOffset(SimpleReentrantLock.class.getField("head"));

tailoffset= unsafe.objectFieldOffset(SimpleReentrantLock.class.getField("tail"));

waitoffset= unsafe.objectFieldOffset(Node.class.getField("wait"));

\}catch(NoSuchFieldException e) \{

e.printStackTrace();

\}catch(SecurityException e) \{

e.printStackTrace();

\}static classNode\{/\*\*1表示可释放锁 2都可以 3表示可获取锁\*/

public volatile int wait = 2;volatileNode next;volatileThread thread;

\}public static void main(String\[\] args) throwsInterruptedException \{final SimpleReentrantLock lock = newSimpleReentrantLock();

Thread thread1= new Thread(newRunnable() \{public voidrun() \{

lock.lock();try\{

Thread.sleep(10000);

\}catch(InterruptedException e) \{//TODO Auto-generated catch block

e.printStackTrace();

System.out.println("xieyong1");

lock.unlock();

\});

Thread thread2= new Thread(newRunnable() \{public voidrun() \{

lock.lock();

System.out.println("xieyong2");

lock.unlock();

\});

thread1.setName("xieyong1");

thread2.setName("xieyong2");

thread1.start();

thread2.start();//thread4.start();

java 锁实现_自己实现java锁

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Java实现自旋锁、独占锁和共享锁

相关简单实现自己的显示锁

相关 java 锁实现_自己实现java锁

相关 Redis分布式锁java实现

相关 Java模拟ReentrantLock实现自己的显示锁BooleanLock

相关 Java锁实现

相关 Java优雅的实现锁和超时锁

相关自己实现自旋锁

相关 java实现redis分布式锁

相关 java乐观锁实现案例