锁的释放操作
当前线程的同步方法、同步代码块执行结束
当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。
当前线程在同步代码块、同步方法中出现了未处理的Error或Exception,导致异常结束
当前线程在同步代码块、同步方法中执行了线程对象的wait()方法,当前线程暂停,并释放锁。
不解锁的操作
线程执行同步代码块或同步方法时,程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行
线程执行同步代码块时,其他线程调用了该线程的suspend()方法将该线程挂起,该线程不会释放锁(同步监视器)。
应尽量避免使用suspend()和resume()来控制线程
线程的死锁问题:
l 死锁
Ø 不同的线程分别占用对方需要的同步资源不放弃,都在等待对方放弃自己需要的同步资源,就形成了线程的死锁
l 解决方法
Ø 专门的算法、原则
Ø 尽量减少同步资源的定义
既然可以上锁,那么假如有2个线程,一个线程想先锁对象1,再锁对象2,恰好另外有一个线程先锁对象2,再锁对象1
在这个过程中,当线程1把对象1锁好以后,就想去锁对象2,但是不巧,线程2已经把对象2锁住了,也正在尝试去锁对象1
什么时候结束呢?只有线程1把2个对象都锁上并把方法执行完,并且线程2把2个对象也都锁上并且把方法执行完毕,那么就会结束,但是,谁都不肯放掉已经锁上的对象,所以就没有结果,这种情况就叫做线程的死锁。
线程的通信
l wait()与 notify() 和 notifyAll()
Ø wait():令当前线程挂起并放弃CPU、同步资源,使别的线程可访问并修改共享资源,而当前线程排队等候再次对资源的访问
Ø notify():唤醒正在排队等待同步资源的线程中优先级最高者结束等待
Ø notifyAll ():唤醒正在排队等待资源的所有线程结束等待.
l Java.lang.Object提供的这三个方法只有在synchronized方法或synchronized代码块中才能使用,否则会报java.lang.IllegalMonitorStateException异常
Wait方法
在当前线程中调用方法: 对象名.wait()
使当前线程进入等待(某对象)状态,直到另一线程对该对象发出 notify (或notifyAll) 为止。
调用方法的必要条件:当前线程必须具有对该对象的监控权(加锁)
调用此方法后,当前线程将释放对象监控权 ,然后进入等待
在当前线程被notify后,要重新获得监控权,然后从断点处继续代码的执行。
notify()/notifyAll()
在当前线程中调用方法: 对象名.notify()
功能:唤醒等待该对象监控权的一个线程。
调用方法的必要条件:当前线程必须具有对该对象的监控权(加锁)
线程交替打印案例
class Communication implements Runnable{
int i = 1;
public void run() {
while (true) {
synchronized (this) {
notify();
if (i <= 100) {
System.out.println(Thread.currentThread().getName() + ":"
+ i++);
}
else break;
try {
wait();} catch (InterruptedException e) {
}
}
}
}
}
生产者(Productor)将产品交给店员(Clerk),而消费者(Customer)从店员处取走产品,店员一次只能持有固定数量的产品(比如:20),如果生产者试图生产更多的产品,店员会叫生产者停一下,如果店中有空位放产品了再通知生产者继续生产;如果店中没有产品了,店员会告诉消费者等一下,如果店中有产品了再通知消费者来取走产品。
这里可能出现两个问题:
生产者比消费者快时,消费者会漏掉一些数据没有取到。
消费者比生产者快时,消费者会取相同的数据。public class TestProduct {
public static void main(String[] args) {
Clerk clerk = new Clerk();
Thread productorThread = new Thread(new Productor(clerk));
Thread consumerThread = new Thread(new Consumer(clerk));
productorThread.start();
consumerThread.start();
}
}
class Clerk{ //售货员
private int product = 0;
public synchronized void addProduct(){
if(product >= 20){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}else{
product++;
System.out.println("生产者生产了第"+product+"个产品");
notifyAll();
}
}
public synchronized void getProduct(){
if(this.product <= 0){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}else{
System.out.println("消费者取走了第"+product+"个产品");
product--;
notifyAll();
}
}
}
class Productor implements Runnable{ //生产者
Clerk clerk;
public Productor(Clerk clerk){
this.clerk = clerk;
}
public void run(){
System.out.println("生产者开始生产产品");
while(true){
try {
Thread.sleep((int)Math.random()*1000);
} catch (InterruptedException e) {
}
clerk.addProduct();
}
}
}
class Consumer implements Runnable{ //消费者
Clerk clerk;
public Consumer(Clerk clerk){
this.clerk = clerk;
}
public void run(){
System.out.println("消费者开始取走产品");
while(true){
try {
Thread.sleep((int)Math.random()*1000);
} catch (InterruptedException e) {
}
clerk.getProduct();
}
}
}
将同步synchronized替换成了显示的Lock操作
将Object中的wait/nitify/notifyAll方法替换成为Condition对象(await/signal/signalAll)
可以通过Lock.newCondition(),进行获取
一个锁可以绑定多个condition对象,避免了因同步嵌套导致死锁问题的发生