多线程编程第四章Lock的使用

使用ReentrantLock
lock.lock();//此方法相当于上锁
lock.unlock();//此方法相当于释放锁

Condition condition = lock.newCondition();
condition.await();//相当于wait()
condition.signal();//相当于nontify
condition.signalAll();//相当于nontifyAll

new ReentrantLock(true);//公平锁,基本呈有序
new ReentrantLock(false);//非公平锁,默认非公平锁

lock.getHoldCount();//lock锁定的个数
lock.getQueueLength();//获取正在获取线程数
lock.getWaitQueueLength(condition);//获取正在等待的线程数

lock.hasQueuedThread(threads[5]);//线程是否在等待锁定
lock.hasQueuedThreads();//是否有程序在等待锁定
lock.hasWaiters(condition);//是否有等待次锁定相关的condition，与lock.getWaitQueueLength(condition)配合

lock.isFair();//是否公平锁
lock.isHeldByCurrentThread();//当前线程是否保持锁定
lock.isLocked();//当前线程是否被任意线程锁定，与上一方法区别是，上一方法的锁定是自己的，如锁定A方法后执行B，此时在B方法中lock.isLocked()为true，而lock.isHeldByCurrentThread()为false

condition.awaitUninterruptibly();//用法和condition.await();一致，不过如果被thread.interrupt()打断时，此方法不跑错，而condition.await()会报java.lang.InterruptedException异常
condition.awaitUntil(long);//等待long时长之后再唤醒，而且锁释放，也可以被signal()、signalAll()唤醒

ReentrantReadWriteLock：读写锁，读读不斥，其他都互斥lock.readLock().lock()与lock.writeLock().lock();

代码：
使用condition顺序执行

package test2019.线程学习.lock.顺序执行;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class Service {

	public ReentrantLock lock = new ReentrantLock();

	public Condition conditionA = lock.newCondition();

	public Condition conditionB = lock.newCondition();

	public Condition conditionC = lock.newCondition();

	volatile private int nextPoint = 0;

	public void method1() {
		try {
			lock.lock();
			while (nextPoint % 3 != 0) {
				conditionA.await();
			}
			System.out.println("AAAAAAA");
			nextPoint++;
			conditionB.signalAll();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			lock.unlock();
		}

	}

	public void method2() {
		try {
			lock.lock();
			while (nextPoint % 3 != 1) {
				conditionB.await();
			}
			System.out.println("BBBBBBB");
			nextPoint++;
			conditionC.signalAll();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			lock.unlock();
		}

	}

	public void method3() {
		try {
			lock.lock();
			while (nextPoint % 3 != 2) {
				conditionC.await();
			}
			System.out.println("CCCCCCC");
			nextPoint++;
			conditionA.signalAll();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			lock.unlock();
		}

	}

	public static void main(String[] args) {
		Service service = new Service();
		Runnable runnable1 = new Runnable() {

			@Override
			public void run() {
				service.method1();
			}
		};
		Runnable runnable2 = new Runnable() {

			@Override
			public void run() {
				service.method2();
			}
		};
		Runnable runnable3 = new Runnable() {

			@Override
			public void run() {
				service.method3();
			}
		};
		for (int i = 0; i < 100; i++) {
			new Thread(runnable1).start();
			new Thread(runnable2).start();
			new Thread(runnable3).start();
		}
	}
}

ReentrantReadWriteLock

package test2019.线程学习.lock.读写锁;

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Service {

	public ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

	public void read() {
		try {
			lock.readLock().lock();
			System.out.println("我读了");
			Thread.sleep(1000);
			System.out.println("我读完了");
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			lock.readLock().unlock();
		}

	}

	public void write() {
		try {
			lock.writeLock().lock();
			System.out.println("我写了");
			Thread.sleep(2000);
			System.out.println("我写完了");
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			lock.writeLock().unlock();
		}

	}

	public static void main(String[] args) {
		Service service = new Service();
		Runnable runnableR = new Runnable() {

			@Override
			public void run() {
				service.read();
			}
		};
		Runnable runnableW = new Runnable() {

			@Override
			public void run() {
				service.write();
			}
		};
		for (int i = 0; i < 10; i++) {
			new Thread(runnableR).start();
		}

		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		for (int i = 0; i < 10; i++) {
			new Thread(runnableW).start();
		}
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		for (int i = 0; i < 10; i++) {
			new Thread(runnableR).start();
		}
	}
}