精华内容
下载资源
问答
  • 其实很好理解,从设计的角度很容易分析出wait会释放锁的。 线程在运行的时候占用了计算机的共享资源,因为当前线程在使用它,然而当前线程进行了休眠例如 wait() 很浅显的道理,当前线程已经停止了,那意味着这个...

    我在网上看到很多人错误的理解,认为wait不会释放锁,然而它们并没有任何理由,仅凭自己的认知,然后很骄傲的和人讲,wait不会释放锁,你这是误人子弟。殊不知他自己才是误人子弟。


    我先讲一讲原理,然后用代码来证明它,让那些还认为wait不会释放锁的同志闭嘴。赶紧改错还来的及

    原理

    其实很好理解,从设计的角度很容易分析出wait是会释放锁的。

    线程在运行的时候占用了计算机的共享资源,因为当前线程在使用它,然而当前线程进行了休眠例如 wait() 很浅显的道理,当前线程已经停止了,那意味着这个资源空闲了下来。那么作为万恶的剥削者"程序员"肯定不会让这个资源空闲着,你们说对吧!!!

    因此很容易推断出wait()是会释放锁的,而锁的奥义就是控制指定的线程持有共享资源,既然线程都进行了等待,肯定是要需要释放锁的!!!


    贴代码前我先讲一下怎么用代码进行证明
    很简单,用两个线程同时用一把锁,其中一个线程先执行,并且进行wait(),如果释放了锁,那么是不是对于另外一个线程来说它就可以抢占到这个锁呢(因为它空闲下来了)

    而我的代码中为了让两个线程实现这种效果,我让一个线程等待一秒

    代码

    import java.util.concurrent.TimeUnit;
    
    public class Demo {
    
        public static void main(String[] args) {
            Object object=new Object();
    
            final Thread thread1 = new Thread(() -> {
                System.out.println("线程1开始");
                synchronized (object) {
                    try {
                        object.wait();// 进行阻塞,并且释放对象锁
                        System.out.println("====线程1");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("线程1结束");
            });
    
            final Thread thread2 = new Thread(() -> {
                System.out.println("线程2开始");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (object){
                    System.out.println("线程2=======");
                }
                System.out.println("线程2结束");
            });
            thread1.start();
            thread2.start();
        }
    }
    

    运行结果
    在这里插入图片描述
    从结果中很明显发现 wait()方法会让当前线程释放锁,而线程2等了1s后,因为线程1释放了锁,因此线程2就能抢占到。


    继续证明线程2的synchronized (object)在没有获取锁的情况下是会阻塞等待锁释放

    代码2

    import java.util.concurrent.TimeUnit;
    
    public class Demo {
    
        public static void main(String[] args) {
            Object object=new Object();
    
            final Thread thread1 = new Thread(() -> {
                System.out.println("线程1开始");
                synchronized (object) {
                    try {
                        TimeUnit.SECONDS.sleep(2000); // 等待足够长时间让我们足以观察到结果
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("====线程1");
      
                }
                System.out.println("线程1结束");
            });
    
            final Thread thread2 = new Thread(() -> {
                System.out.println("线程2开始");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
    
                synchronized (object){
                    System.out.println("线程2=======");// 输出这一句说明当前线程抢占到了锁
                }
                System.out.println("线程2结束");
            });
            thread1.start();
            thread2.start();
        }
    
    }
    

    在这里插入图片描述

    展开全文
  • } } } } } 运行结果 Thread-0****9 Thread-0****8 Thread-0****7 Thread-0****6 Thread-0****5 按理来说,线程1抢到锁,然后执行,到wait(),释放锁,应该CPU运行其他线程,为什么运行到这里就停了(没有完全运行...

    package thread;

    public class TestSleep implements Runnable {

    private int time = 10;

    private Object lock = new Object();

    public static void main(String[] args) {

    // TODO Auto-generated method stub

    TestSleep a = new TestSleep();

    Thread t1 = new Thread(a);

    Thread t2 = new Thread(a);

    t1.start();

    t2.start();

    }

    @Override

    public void run() {

    // TODO Auto-generated method stub

    synchronized (lock) {

    for (int i = 0; i 

    try {

    if (time == 5)

    lock.wait();//Thread.sleep(3000);

    //lock.notify();

    time--;

    System.out.println(Thread.currentThread().getName() + "****" + time);

    } catch (Exception e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    }

    }

    }

    }

    运行结果

    Thread-0****9

    Thread-0****8

    Thread-0****7

    Thread-0****6

    Thread-0****5

    按理来说,线程1抢到锁,然后执行,到wait(),释放锁,应该CPU会运行其他线程,为什么运行到这里就停了(没有完全运行完,没有真正停止)

    展开全文
  • obj1.wait(); lock2.lock(); } } // Use `finally` to make sure the lock is always released,even if an exception is thrown finally { // Exception might have been thrown before current thread could ...

    您可以使用比同步语句更灵活的Lock和Condition.

    对于您的示例,您可以将obj2替换为ReentrantLock:

    @H_403_8@Lock lock2 = new ReentrantLock();

    try {

    // Blocks until the lock is acquired,just like a `synchronized` statement

    lock2.lock();

    f1();

    synchronized (obj1) {

    f2();

    lock2.unlock();

    obj1.wait();

    lock2.lock();

    }

    }

    // Use `finally` to make sure the lock is always released,even if an exception is thrown

    finally {

    // Exception might have been thrown before current thread could acquire lock again,cannot

    // unlock then

    if (lock2.isHeldByCurrentThread()) {

    lock2.unlock();

    }

    }

    但是,这将允许另一个线程在当前线程开始等待obj1之前获取lock2.如果不希望这样,可以将obj1替换为Lock并等待obj2.

    展开全文
  • 首先,多线程中使用到两个延迟的函数,wait和sleep。wait是Object类中的方法,...最主要的是sleep方法调用之后,并没有释放锁。使得线程仍然可以同步控制。sleep不会让出系统资源;而wait是进入线程等待池中等待,...

    首先,多线程中会使用到两个延迟的函数,wait和sleep。

    wait是Object类中的方法,而sleep是Thread类中的方法。

    sleep是Thread类中的静态方法。无论是在a线程中调用b的sleep方法,还是b线程中调用a的sleep方法,谁调用,谁睡觉。

    最主要的是sleep方法调用之后,并没有释放锁。使得线程仍然可以同步控制。sleep不会让出系统资源;

    而wait是进入线程等待池中等待,让出系统资源。

    调用wait方法的线程,不会自己唤醒,需要线程调用 notify / notifyAll 方法唤醒等待池中的所有线程,才会进入就绪队列中等待系统分配资源。sleep方法会自动唤醒,如果时间不到,想要唤醒,可以使用interrupt方法强行打断。

    Thread.sleep(0) // 触发操作系统立刻重新进行一次CPU竞争。

    使用范围:

    sleep可以在任何地方使用。而wait,notify,notifyAll只能在同步控制方法或者同步控制块中使用。

    sleep必须捕获异常,而wait,notify,notifyAll的不需要捕获异常。

    lock关键字可以用来确保代码块完成运行,而不会被其他线程中断。它可以把一段代码定义为互斥段(critical section),互斥段在一个时刻内只允许一个线程进入执行,而其他线程必须等待。这是通过在代码块运行期间为给定对象获取互斥锁来实现的。例如下面增加任务时候就要用上lock函数。

    public void AddTask(Listdatas) {if (datas != null && datas.Count > 0) {

    lock (_taskQueueLock) {for (int i = 0; i < datas.Count; i++) {

    datas[i].Iaqi = GetIaqi(datas[i]);

    }

    _taskQueue.Enqueue(datas);

    }

    }

    }

    展开全文
  • 由于等待一个锁定线程只有在获得这把...3. 在执行同步代码块的过程中,执行了锁所属对象的wait()方法,这个线程会释放锁,进行对象的等待池。除了以上情况外,只要持有锁的此案吃还没有执行完同步代码块,就不会释放...
  • 转载自:https://www.cnblogs.com/yigechengxuyuan/p/8398647.html首先,多线程中使用到两个延迟的函数,wait和sleep。wait是Object类中的方法,而sleep是Thread类中的方法。sleep是Thread类中的静态方法。无论是...
  • wait是指在一个已经进入了同步锁的线程内,让自己暂时让出同步锁,以便其他正在等待此锁的线程可以得到同步锁并运行,只有其他线程调用了notify方法(notify并不释放锁,只是告诉调用过wait方法的线程可以去参与获得...
  • wait 加锁示例public class WaitDemo {private static Object locker = new Object();public static void main(String[] args) throws InterruptedException {WaitDemo waitDemo = new WaitDemo();// 启动新线程,...
  • wait是指在一个已经进入了同步锁的线程内,让自己暂时让出同步锁,以便其他正在等待此锁的线程可以得到同步锁并运行,只有其他线程调用了notify方法(notify并不释放锁,只是告诉调用过wait方法的线程可以去参与获得...
  • 从字节码上来看,看不出线程进入 wait 状态后,释放锁。你在这段代码里当然看不出来了,invokevirtual #2这句已经在栈中压入了wait方法,释放锁的代码肯定要去wait方法里看。那虚拟机是怎么实现的呢?你这个问题其实...
  • //bowl.wait(1000); // synchronized (chopsticks) { System.out.println(this.name+"吃饭拿筷子"); } } }else { synchronized (chopsticks) { System.out.println(this.name+...
  • wait在锁里面时,执行到wait之后 锁会被释放 当notify在锁里面时,执行到notify 时wait被唤醒,但是线程不释放锁 测试代码如下: package com.chapter03; class Service02 { public void testMethod(Object ...
  • I wrote this program to check if a thread t1 holding lock on two different objects :Lock.class and MyThread.class goes into waiting mode on MyThread.class instance using MyThread.class.wait().It does ...
  • 当线程进入同步方法时,它获取固有。同步方法中的线程被设置为的所有者并且处于RUNNABLE状态。尝试进入锁定方法的任何线程都将变为BLOCKED。当线程调用等待它释放当前对象(它保持所有与其他对象),而不是...
  • java线程join方法会释放锁吗,虽然join底层使用wait,wait是释放锁的 但当给对象加锁,wait释放的锁是对象的锁,可以认为释放锁 当给线程加锁,wait释放的锁是线程的锁,此时认为不释放锁 wait()和join()的...
  • wait 加锁示例 package boke; public class WaitDemo { private static Object locker = new Object(); public static void main(String[] args) throws InterruptedException { WaitDemo waitDemo = new ...
  • Sleep sleep是Thread类中的静态方法,调用sleep使得当前线程睡眠一段时间。睡眠状态开始时放弃对CPU的掌控,并在睡眠持续期间不再抢夺CPU计算资源...验证sleep期间不会释放锁资源: public static void main(String[]
  • wait释放保持在调用wait的对象上的监视器,但不释放任何其他监视器.The current thread must own this object’s monitor. The thread releases ownership of this monitor and waits […].换句话说,给出以下内容:...
  • I was under the impression that wait() releases all locks but I found this post which says"Invoking wait inside a synchronized method is a simple way to acquire the intrinsic lock"Please clarify I'm a...
  • 我刚开始深入研究多线程,一直认为Object.wait()/Condition.await()让当前线程阻塞的同时,也会释放当前线程对该condition对象的。在之前的一些测试代码中也显示wait后,线程上的释放了。但是我们经理却坚持...
  • # 首先从一个很有意思的问题开始:- 问 : Thread 的join() 方法是否会释放锁?- 答: !# 如果一切到这里就结束了,那可能也就没有这篇小记了,但是我的脑子却冒出了一些奇怪的想法:- 释放哪个对象的锁呢?- ...
  • 在区别之前,我们首先先了解一下关于对象,类的相关概念(当时查阅的详细地址:http://www.importnew.com/20444.html,该作者对类和对象进行了详细的举例分析)对象,类在java虚拟机中,每个对象和类在...
  • Java多线程里面join方法使被阻塞线程释放对象吗?问题描述如下:public class HelloJava {public static void main(String[] args) {Object oo = new Object();MyThread t1 = new MyThread("线程t1--", oo);...
  • java wait()notify释放锁

    2021-03-06 22:37:52
    1 调用obj.wait()立即释放锁,,以便其他线程可以执行obj.notify(),但是notify()不会立刻立刻释放sycronized(obj)中的obj锁,必须要等notify()所在线程执行完synchronized(obj)块中的所有代码才释放这把锁.//而...
  • 需要等到synchronized里面的代码块执行玩才释放锁。 案例 : 工厂共需要生产30个产品(产品1~产品30), 生产者每生产5个产品就通知消费者来消费,等到5件产品消费完了然后再通知生产者继续生产,直到30个...
  • 4.当前线程在同步代码块、同步方法中执行了线程对象的wait()方法,当前线程暂停,并释放锁。 不会释放锁的操作: 1.线程执行同步代码块或同步方法时,程序调用Thread. sleep()、Thread.yield()方法暂停当前线程的执行...
  • 简单测试可能显示在线程终止时未释放锁定:import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.LockSupport;import java.util.concurrent.locks.ReentrantLock;public class LockTest {...
  • wait 加锁示例public class WaitDemo {private static Object locker = new Object();public static void main(String[] args) throws InterruptedException {WaitDemo waitDemo = new WaitDemo();// 启动新线程,...
  • 1.sleep()方法在指定时间内让当前正在执行的线程暂停执行,但不会...线程会释放掉它所占有的“标志”,从而使别的线程有机会抢占该。当前线程必须拥有当前对象。如果当前线程不是此的拥有者,抛出IllegalM...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 161,964
精华内容 64,785
关键字:

wait会释放锁吗