Object wait、notify和notifyAll

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/Dopamy_BusyMonkey/article/details/88045708

1、三个方法都只能在同步方法或同步块中使用，这里首先做一个锁和解锁类：

public class TestObjectLock {

	public void lock() throws InterruptedException {
		synchronized (this) {
			System.out.println(Thread.currentThread().getName() + "[线程加锁开始]");
			wait();
			System.out.println(Thread.currentThread().getName() + "[线程加锁结束]");
		}
	}
	
	public void unlock() {
		synchronized (this) {
			System.out.println(Thread.currentThread().getName() + "[线程解锁开始]");
			notify();
			System.out.println(Thread.currentThread().getName() + "[线程解锁结束]");
		}
	}
}

2、开三个加锁线程，和一个解锁线程分别把锁对象实例传入形参：

public class ThreadLock implements Runnable {
	
	private TestObjectLock objLock = null;
	
	public ThreadLock(TestObjectLock objLock) {
		this.objLock = objLock;
	}

	@Override
	public void run() {
		try {
			this.objLock.lock();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

}

public class ThreadUnLock implements Runnable {

	private TestObjectLock objLock = null;
	
	public ThreadUnLock(TestObjectLock objLock) {
		this.objLock = objLock;
	}

	@Override
	public void run() {
		try {
			this.objLock.unlock();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

public class MainTest {

	public static void main(String[] args) throws InterruptedException {
		
		TestObjectLock objLock = new TestObjectLock();
		ThreadLock threadLock = new ThreadLock(objLock);
		ThreadUnLock threadUnLock = new ThreadUnLock(objLock);
		
		Thread threadLock1 = new Thread(threadLock);
		Thread threadLock2 = new Thread(threadLock);
		Thread threadLock3 = new Thread(threadLock);
		threadLock1.start();
		threadLock2.start();
		threadLock3.start();
		Thread.sleep(5000);
		
		Thread threadUnLock1 = new Thread(threadUnLock);
		threadUnLock1.start();
		
		
	}

}

3、这里解锁用的是notify，三个线程对同一个对象加锁，但是只通知其中一个线程解锁，因为synchronized使用的是公平锁，所以先等待的线程先解锁

4、如果将notify改为notifyAll，则将通知三个线程都解锁

注意：debug的时候控制线程调试

5、增加条件通知指定线程解锁：

Condition的await和signal必须在Lock之间使用，并且使用ReentrantLock可以选择使用公平锁和非公平锁

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

public class TestObjectLock {

	public void lock(Lock lock, Condition condition) throws InterruptedException {
		try {
			lock.lock();
			System.out.println(Thread.currentThread().getName() + "[线程加锁开始]");
			condition.await();
			System.out.println(Thread.currentThread().getName() + "[线程加锁结束]");
		} finally {
			lock.unlock();
		}
	}
	
	public void unlock(Lock lock, Condition condition) {
		try {
			lock.lock();
			System.out.println(Thread.currentThread().getName() + "[线程解锁开始]");
			condition.signal();
			System.out.println(Thread.currentThread().getName() + "[线程解锁结束]");
		} finally {
			lock.unlock();
		}
	}
}

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

public class ThreadLock implements Runnable {
	
	private TestObjectLock objLock = null;
	private Condition condition = null;
	private Lock lock = null;
	
	public ThreadLock(TestObjectLock objLock, Condition condition, Lock lock) {
		this.objLock = objLock;
		this.condition = condition;
		this.lock = lock;
	}

	@Override
	public void run() {
		try {
			this.objLock.lock(this.lock, this.condition);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

}

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

public class ThreadUnLock implements Runnable {

	private TestObjectLock objLock = null;
	private Condition condition = null;
	private Lock lock = null;
	
	public ThreadUnLock(TestObjectLock objLock, Condition condition, Lock lock) {
		this.objLock = objLock;
		this.condition = condition;
		this.lock = lock;
	}

	@Override
	public void run() {
		try {
			this.objLock.unlock(this.lock, this.condition);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

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

public class MainTest {

	public static void main(String[] args) throws InterruptedException {
		Lock lock = new ReentrantLock();
		Condition conditionA = lock.newCondition();
		Condition conditionB = lock.newCondition();
		
		TestObjectLock objLock = new TestObjectLock();
		ThreadLock threadLockA = new ThreadLock(objLock, conditionA, lock);
		ThreadLock threadLockB = new ThreadLock(objLock, conditionB, lock);
		ThreadUnLock threadUnLock = new ThreadUnLock(objLock, conditionB,lock);
		
		Thread threadLock1 = new Thread(threadLockA);
		Thread threadLock2 = new Thread(threadLockA);
		Thread threadLock3 = new Thread(threadLockB);
		threadLock1.start();
		threadLock2.start();
		threadLock3.start();
		Thread.sleep(5000);
		
		Thread threadUnLock1 = new Thread(threadUnLock);
		threadUnLock1.start();
		
		
	}

}