java线程03

最新推荐文章于 2025-04-15 04:00:00 发布

fishbooks

最新推荐文章于 2025-04-15 04:00:00 发布

阅读量230

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/fishbooks/article/details/51803273

锁的释放操作

当前线程的同步方法、同步代码块执行结束

当前线程在同步代码块、同步方法中遇到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对象，避免了因同步嵌套导致死锁问题的发生