java线程Lock的wait

如果lock在lock.lock();之后进入lock.wait();

那么所有的获取lock.lock();的代码都会被阻塞。

但是synchronized (lock) { lock.notifyAll(); }  这个代码可以被执行,且只有执行唤醒之后才能使得程序继续走。



看代码

class R1 implements Runnable {
public void run() {
try {
lock.lock();
System.out.println("r1-01\t" + Thread.currentThread().getName());
System.out.println("进入等待");
synchronized (lock) {
lock.wait();
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
System.out.println("over");
}
}


class R2 implements Runnable {
public void run() {
lock.lock();
System.out.println("r2-01\t" + Thread.currentThread().getName());
sleep(10);
synchronized (lock) {
lock.notifyAll();
}
}
}


如果先运行R1在运行R2

就无法结束程序,

如果吧R2的获取锁的代码注释掉就可以





但是使用了lock最好使用private static Condition canGet = lock.newCondition();去等待和唤醒

代码如下

public class MyLock_1 {
private static Lock lock = new ReentrantLock();// 锁对象
private static Condition canGet = lock.newCondition();
public int n1 = 1;
public int n2 = 1;


public void task() {
Thread[] t1 = new Thread[n1];
for (int i = 0; i < n1; i++) {
R1 r = new R1();
t1[i] = new Thread(r, "R1999-" + i);
t1[i].start();
}
sleep(2);
Thread[] t2 = new Thread[n2];
for (int i = 0; i < n2; i++) {
R2 r = new R2();
t2[i] = new Thread(r, "R2000-" + i);
t2[i].start();
}
}


public static void main(String[] args) {
MyLock_1 lock = new MyLock_1();
lock.task();
}






class R1 implements Runnable {
public void run() {
lock.lock();
try {
System.out.println("r1-01\t" + Thread.currentThread().getName());
sleep(5);
System.out.println("进入等待");
canGet.await();
System.out.println("离开等待--");
} catch (InterruptedException e) {
e.printStackTrace();

finally {
lock.unlock();
}
System.out.println("over");
}
}


class R2 implements Runnable {
public void run() {
lock.lock();
System.out.println("r2-01\t" + Thread.currentThread().getName());
canGet.signal();
lock.unlock();
System.out.println("r2-01\tover");
}
}


public void sleep(int sec) {
try {
Thread.sleep(100 * sec);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}






http://blog.csdn.net/ghsau/article/details/7481142

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java中的线程等待(wait)是一种用于线程间同步的机制。当一个线程调用对象的`wait()`方法时,它会释放该对象上的锁,并且进入等待状态,直到其他线程通过调用相同对象上的`notify()`或`notifyAll()`方法来唤醒它。 `wait()`方法必须在同步代码块或同步方法中使用,因为它要求线程先获得对象的锁才能调用。当线程调用`wait()`方法后,它会释放持有的锁,其他线程可以访问该对象并执行同步代码块或同步方法。当线程被唤醒后,它会重新尝试获得锁,并继续执行。 下面是一个简单的示例代码,演示了如何使用`wait()`和`notify()`方法实现线程等待: ```java class MyRunnable implements Runnable { private final Object lock; public MyRunnable(Object lock) { this.lock = lock; } @Override public void run() { synchronized (lock) { try { System.out.println("Thread waiting..."); lock.wait(); // 线程等待 System.out.println("Thread resumed!"); } catch (InterruptedException e) { e.printStackTrace(); } } } } public class Main { public static void main(String[] args) throws InterruptedException { Object lock = new Object(); Thread thread = new Thread(new MyRunnable(lock)); thread.start(); // 主线程等待一段时间后唤醒等待的线程 Thread.sleep(2000); synchronized (lock) { lock.notify(); // 唤醒等待的线程 } } } ``` 在这个示例中,线程通过调用`lock.wait()`方法进入等待状态,并且在主线程中通过调用`lock.notify()`方法将其唤醒。注意,`wait()`和`notify()`方法必须在同步代码块(这里是`synchronized (lock)`)中使用。 请注意,线程在被唤醒后,并不会立即执行,而是需要重新竞争锁资源。因此,在`notify()`方法调用之后,等待的线程可能不会立即继续执行,而是需要等待其他线程释放锁才能执行。 这是Java线程等待的基本概念和用法,希望对你有所帮助!如果有更多问题,请随时提问。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值