并发编程：自定义并发类：8、自定义Lock类

目录

Lock

一、主程序

二、自定义Lock类

三、实现同步器（服务于自定义的Lock）

四、使用了自定义Lock的任务

五、执行结果

---

Lock

允许程序员保护一段关键代码，以便一次只有一个线程可以执行该代码块。

• lock():当访问临界区时，可以调用此操作。如果有另外的线程要访问该临界区，那么另外的线程会被阻塞，直到它们由锁唤醒才可以访问临界区。
• unlock():在临界区末尾调用该方法，以允许其他线程访问临界区。

一、主程序

package xyz.jangle.thread.test.n8_9.lock;

import java.util.concurrent.TimeUnit;

/**
 * 8.9、自定义Lock类
 * 
 * @author jangle
 * @email jangle@jangle.xyz
 * @time 2020年10月7日 下午7:33:31
 * 
 */
public class M {

	public static void main(String[] args) {
		var lock = new MyLock();
		for (int i = 0; i < 10; i++) {
			var task = new Task(lock, "Task-" + i);
			var thread = new Thread(task);
			thread.start();
		}
		// 用tryLock尝试获取锁，每一秒一次，直到成功
		boolean value;
		do {
			try {
				value = lock.tryLock(1, TimeUnit.SECONDS);
				if (!value) {
					System.out.println("M: 尝试获取锁");
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
				value = false;
			}
		} while (!value);
		System.out.println("M: 成功获得锁");
		lock.unlock();
		System.out.println("M: 程序结束");

	}
}

二、自定义Lock类

package xyz.jangle.thread.test.n8_9.lock;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

/**
 * @author jangle
 * @email jangle@jangle.xyz
 * @time 2020年10月7日 下午7:42:38
 * 
 */
public class MyLock implements Lock {

	private final AbstractQueuedSynchronizer sync;

	public MyLock() {
		super();
		sync = new MyAbstractQueuedSynchronizer();
	}

	@Override
	public void lock() {
		sync.acquire(1);
	}

	@Override
	public void lockInterruptibly() throws InterruptedException {
		sync.acquireInterruptibly(1);
	}

	@Override
	public boolean tryLock() {
		try {
			return sync.tryAcquireNanos(1, 1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
			Thread.currentThread().interrupt();
			return false;
		}
	}

	@Override
	public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
		return sync.tryAcquireNanos(1, TimeUnit.NANOSECONDS.convert(time, unit));
	}

	@Override
	public void unlock() {
		sync.release(1);
	}

	@Override
	public Condition newCondition() {
		return sync.new ConditionObject();
	}

}

三、实现同步器（服务于自定义的Lock）

package xyz.jangle.thread.test.n8_9.lock;

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;

/**
 *  	实现同步器
 * @author jangle
 * @email jangle@jangle.xyz
 * @time 2020年10月7日 下午7:37:11
 * 
 */
@SuppressWarnings("serial")
public class MyAbstractQueuedSynchronizer extends AbstractQueuedSynchronizer {

	private final AtomicInteger state;

	public MyAbstractQueuedSynchronizer() {
		super();
		state = new AtomicInteger(0);
	}

	@Override
	protected boolean tryAcquire(int arg) {
		return state.compareAndSet(0, 1);
	}

	@Override
	protected boolean tryRelease(int arg) {
		return state.compareAndSet(1, 0);
	}

}

四、使用了自定义Lock的任务

package xyz.jangle.thread.test.n8_9.lock;

import java.util.concurrent.TimeUnit;

/**
 *  使用自定义Lock的任务
 * @author jangle
 * @email jangle@jangle.xyz
 * @time 2020年10月8日 上午9:20:41
 * 
 */
public class Task implements Runnable {

	private final MyLock lock;

	private final String name;

	public Task(MyLock lock, String name) {
		super();
		this.lock = lock;
		this.name = name;
	}

	@Override
	public void run() {
		lock.lock();
		System.out.println("Task:" + name + " 开始加锁");
		try {
			TimeUnit.SECONDS.sleep(2);
			System.out.println("Task:" + name + "释放锁");
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
}

五、执行结果

Task:Task-0 开始加锁
M: 尝试获取锁
Task:Task-0释放锁
Task:Task-6 开始加锁
M: 尝试获取锁
M: 尝试获取锁
Task:Task-6释放锁
Task:Task-7 开始加锁
M: 尝试获取锁
M: 尝试获取锁
Task:Task-7释放锁
Task:Task-4 开始加锁
M: 尝试获取锁
M: 尝试获取锁
Task:Task-4释放锁
Task:Task-3 开始加锁
M: 尝试获取锁
M: 尝试获取锁
Task:Task-3释放锁
Task:Task-1 开始加锁
M: 尝试获取锁
M: 尝试获取锁
Task:Task-1释放锁
Task:Task-8 开始加锁
M: 尝试获取锁
M: 尝试获取锁
Task:Task-8释放锁
Task:Task-2 开始加锁
M: 尝试获取锁
M: 尝试获取锁
Task:Task-2释放锁
Task:Task-9 开始加锁
M: 尝试获取锁
M: 尝试获取锁
Task:Task-9释放锁
Task:Task-5 开始加锁
M: 尝试获取锁
M: 尝试获取锁
Task:Task-5释放锁
M: 成功获得锁
M: 程序结束