javawaitsleep

① java里面的wait方法（object类中的）和sleep（）方法有什么本质上的区别，详解1··

首先，sleep()是Thread类中的方法，而wait()则是Object类中的方法。

sleep()方法导致了程序暂停，但是他的监控状态依然保持着，当指定的时间到了又会自动恢复运行状态。在调用sleep()方法的过程中，线程不会释放对象锁。
wait()方法会导致线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备获取对象锁进入运行状态。

以下以代码为例讲解：
package test;
public class WaitAndSleep {

public static void main(String[] args) {
new Thread(new Thread1()).start();
try {
Thread.sleep(5000);
} catch (Exception e) {
e.printStackTrace();
}
new Thread(new Thread2()).start();
}

private static class Thread1 implements Runnable {
@Override
public void run() {
synchronized (WaitAndSleep.class) {

System.out.println("thread1 is waiting...");
try {
// 调用wait()方法，线程会放弃对象锁，进入等待此对象的等待锁定池
WaitAndSleep.class.wait();
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("thread1 is going on ....");
System.out.println("thread1 is over!!!");
}
}
}

private static class Thread2 implements Runnable {
@Override
public void run() {
synchronized (WaitAndSleep.class) {
System.out.println("enter thread2....");
System.out.println("thread2 is sleep....");
// 只有针对此对象调用notify()方法后本线程才进入对象锁定池准备获取对象锁进入运行状态。
WaitAndSleep.class.notify();
// ==================
// 区别
// 如果我们把代码：TestD.class.notify();给注释掉，即TestD.class调用了wait()方法，但是没有调用notify()
// 方法，则线程永远处于挂起状态。
try {
// sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，
// 但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。
// 在调用sleep()方法的过程中，线程不会释放对象锁。
Thread.sleep(5000);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("thread2 is going on....");
System.out.println("thread2 is over!!!");
}
}
}
}

运行结果：
thread1 is waiting...
enter thread2....
thread2 is sleep....
thread2 is going on....
thread2 is over!!!
thread1 is going on ....
thread1 is over!!!

如果我们把代码：WaitAndSleep.class.notify();给注释掉
运行结果：
thread1 is waiting...
enter thread2....
thread2 is sleep....
thread2 is going on....
thread2 is over!!!
程序一直处于挂起状态，无法结束

② 2020-09-15：java里的wait()和sleep()的区别有哪些

1: 方法所在类不同 wait是object类中的方法 sleep是Thread类中的方法
2: wait方法释放锁 sleep不释放锁
3: wait方法会使得线程进入线程等待池中 需要使用notify方法唤醒,sleep方法在指定的时间过后则自动苏醒

③ java wait和sleep的区别

第一种解释：

功能差不多,都用来进行线程控制,他们最大本质的区别是:sleep()不释放同步锁,wait()释放同步缩.

还有用法的上的不同是:sleep(milliseconds)可以用时间指定来使他自动醒过来,如果时间不到你只能调用interreput()来强行打断;wait()可以用notify()直接唤起.

第二种解释：

sleep是Thread类的静态方法。sleep的作用是让线程休眠制定的时间，在时间到达时恢复，也就是说sleep将在接到时间到达事件事恢复线程执行，例如：

try{
System.out.println("I'm going to bed");
Thread.sleep(1000);
System.out.println("I wake up");
}
catch(IntrruptedException e) {
}

wait是Object的方法，也就是说可以对任意一个对象调用wait方法，调用wait方法将会将调用者的线程挂起，直到其他线程调用同一个对象的notify方法才会重新激活调用者，例如：

//Thread 1

try{
obj.wait();//suspend thread until obj.notify() is called
}
catch(InterrputedException e) {
}

第三种解释：

这两者的施加者是有本质区别的.
sleep()是让某个线程暂停运行一段时间,其控制范围是由当前线程决定,也就是说,在线程里面决定.好比如说,我要做的事情是 "点火->烧水->煮面",而当我点完火之后我不立即烧水,我要休息一段时间再烧.对于运行的主动权是由我的流程来控制.

而wait(),首先,这是由某个确定的对象来调用的,将这个对象理解成一个传话的人,当这个人在某个线程里面说"暂停!",也是
thisOBJ.wait(),这里的暂停是阻塞,还是"点火->烧水->煮饭",thisOBJ就好比一个监督我的人站在我旁边,本来该线
程应该执行1后执行2,再执行3,而在2处被那个对象喊暂停,那么我就会一直等在这里而不执行3,但这个流程并没有结束,我一直想去煮饭,但还没被允许,

直到那个对象在某个地方说"通知暂停的线程启动!",也就是thisOBJ.notify()的时候,那么我就可以煮饭了,这个被暂停的线程就会从暂停处

④ java 中 sleep 和 wait 的区别

首先：sleep是通过线程来调用的。它是Thread身上的方法。而wait是Object身上的方法。
所以调用的时候需要用object来调用。
其次：原理不同。当前线程在同步代码块中，调用sleep之后，当前线程并没有释放锁。意味着
其他线程如果竞争这个锁。就要等待。
而当前线程在同步代码块中调用obj.wait之后。当前线程已经释放锁了。意味着其他对象，如果竞争
这个锁。不需要等待。
说这么多，不如上代码。场景：两个线程同时竞争一个资源。使用同步代码块。
①竞争同一个obj对象，使用sleep。
publicclassTestSleep{
publicstaticvoidmain(String[]args)throwsException{
		finalObjectobj=newObject();
		finalThreadt1=newThread(){
			@Override
			publicvoidrun(){
				synchronized(obj){
					try{
						Thread.sleep(1000);
					}catch(InterruptedExceptione){
						e.printStackTrace();
					}
					System.out.println("1");
				}
			}
		};
		finalThreadt2=newThread(){
			@Override
			publicvoidrun(){
				synchronized(obj){
					System.out.println("2");
				}
			}
		};
		t1.start();
		Thread.sleep(100);//确保t1先执行。先抢到obj的控制权。
		t2.start();
	}
}
分析：创建一个obj。两条线程。Thread.sleep(100);确保让t1先执行到run方法。所以t1会
先抢到obj的资源，给它上锁。需要睡000ms，并不释放obj锁。此时t2已经跑起来，走到run方法同步代码块。
发现obj已经被t1抢到了。所以t2只能等t1释放obj锁。而t1什么时候释放obj锁？t1的同步代码
块执行完释放。什么时候执行完？打印1的时候执行完。t1释放锁之后。t2得到锁。因为这里只有两条
线程竞争obj锁。所以接下来就打印2。
最终结果是先打印1再打印2。

再看另个一例子：
②竞争同一个obj对象，使用wait。
publicclassTestWaint{
publicstaticvoidmain(String[]args)throwsException{
		finalObjectobj=newObject();
		finalThreadt1=newThread(){
			@Override
			publicvoidrun(){
				synchronized(obj){
					try{
						obj.wait();
					}catch(InterruptedExceptione){
						e.printStackTrace();
					}
					System.out.println("1");
				}
			}
		};
		finalThreadt2=newThread(){
			@Override
			publicvoidrun(){
				synchronized(obj){
					System.out.println("2");
					obj.notify();
				}
			}
		};
		t1.start();
		Thread.sleep(100);//确保t1先执行。
		t2.start();
	}
}

分析：创建一个obj。两条线程。Thread.sleep(100);确保让t1先执行到run方法。所以t1会
先抢到obj的资源，给它上锁。然而接下来t1中调用了obj.wait();这个代码，表示t1放弃对obj
的拥有权。也就是释放锁。（释放了之后它需要等待。而不是往下执行，等待什么？等待别人唤醒。
因为wait和notify方法相对。必须要有一个线程调用obj.nofity();时，t1才有可能再次苏醒。否则永远等待。）
t1释放锁，进入等待。意味着t2不用等到t1的同步代码块结束，就可以获取到obj的控制权。
所以t2就给obj上锁了。所以t2先打印2。然后调用了obj.nofity();此时t2已经结束。
由于没有其他线程和t1竞争。此时t1苏醒，再次获获得obj的控制权。往下走，t1线程结束。
所以：先打印2再打印1
讲了挺多。我也觉得啰嗦。但是应该通俗易懂吧。

⑤ java中sleep和wait的区别

它们最大本质的区别是:sleep()不释放同步锁,wait()释放同步锁.
还有用法的上的不同是:sleep(milliseconds)可以用时间指定来使他自动醒过来,如果时间不到你只能调用interreput()来强行打断;wait()可以用notify()直接唤起.

sleep和wait的区别还有：
1。这两个方法来自不同的类分别是Thread和Object
2。最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
3。wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在
任何地方使用
synchronized(x){
x.notify()
//或者wait()
}
4。sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常

⑥ Java中Wait，Sleep和Yield方法的区别

共同点：
1. 他们都是在多线程的环境下，都可以在程序的调用处阻塞指定的毫秒数，并返回。
2. wait()和sleep()都可以通过interrupt()方法 打断线程的暂停状态 ，从而使线程立刻抛出InterruptedException。
如果线程A希望立即结束线程B，则可以对线程B对应的Thread实例调用interrupt方法。如果此刻线程B正在wait/sleep/join，则线程B会立刻抛出InterruptedException，在catch() {} 中直接return即可安全地结束线程。
需要注意的是，InterruptedException是线程自己从内部抛出的，并不是interrupt()方法抛出的。对某一线程调用 interrupt()时，如果该线程正在执行普通的代码，那么该线程根本就不会抛出InterruptedException。但是，一旦该线程进入到 wait()/sleep()/join()后，就会立刻抛出InterruptedException 。
不同点：
1. Thread类的方法：sleep(),yield()等
Object的方法：wait()和notify()等
2. 每个对象都有一个锁来控制同步访问。Synchronized关键字可以和对象的锁交互，来实现线程的同步。
sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
3. wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用
4. sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常

⑦ java sleep（） 和 wait（） 有什么区别

1、同步锁的对待不同：

sleep（）后，程序并不会不释放同步锁。

wait（）后，程序会释放同步锁。

2、用法的不同：

sleep（）可以用时间指定来使他自动醒过来。如果时间不到你只能调用interreput()来强行打断。

wait（）可以用notify()直接唤起。

3、属于不同的类：

sleep（）的类是Thread。

wait（）的类是Object。

⑧ java中的sleep和wait的区别

sleep()和wait()的区别

Java中的多线程是一种抢占式的机制而不是分时机制。线程主要有以下几种状态：可运行，运行，阻塞，死亡。抢占式机制指的是有多个线程处于可运行状态，但是只有一个线程在运行。
当有多个线程访问共享数据的时候，就需要对线程进行同步。线程中的几个主要方法的比较：
Thread类的方法：sleep(),yield()等
Object的方法：wait()和notify()等
每个对象都有一个机锁来控制同步访问。Synchronized关键字可以和对象的机锁交互，来实现线程的同步。
由于sleep()方法是Thread类的方法，因此它不能改变对象的机锁。所以当在一个Synchronized方法中调用sleep（）时，线程虽然休眠了，但是对象的机锁没有被释放，其他线程仍然无法访问这个对象。而wait()方法则会在线程休眠的同时释放掉机锁，其他线程可以访问该对象。
Yield()方法是停止当前线程，让同等优先权的线程运行。如果没有同等优先权的线程，那么Yield()方法将不会起作用。
一个线程结束的标志是：run()方法结束。
一个机锁被释放的标志是：synchronized块或方法结束。
Wait()方法和notify()方法：当一个线程执行到wait()方法时(线程休眠且释放机锁)，它就进入到一个和该对象相关的等待池中，同时失去了对象的机锁。当它被一个notify()方法唤醒时，等待池中的线程就被放到了锁池中。该线程从锁池中获得机锁，然后回到wait()前的中断现场。
join()方法使当前线程停下来等待，直至另一个调用join方法的线程终止。
值得注意的是：线程的在被激活后不一定马上就运行，而是进入到可运行线程的队列中。
共同点： 他们都是在多线程的环境下，都可以在程序的调用处阻塞指定的毫秒数，并返回。
不同点： Thread.sleep(long)可以不在synchronized的块下调用，而且使用Thread.sleep()不会丢失当前线程对任何对象的同步锁(monitor);
object.wait(long)必须在synchronized的块下来使用，调用了之后失去对object的monitor, 这样做的好处是它不影响其它的线程对object进行操作。
举个Java.util.Timer的例子来说明。

private void mainLoop() {
while (true) {
....
synchronized(queue) {
.....
if (!taskFired) // Task hasn't yet fired; wait
queue.wait(executionTime - currentTime);
}
}
在这里为什么要使用queue.wait()，而不是Thread.sleep(), 是因为暂时放弃queue的对象锁，可以让允许其它的线程执行一些同步操作。如：
private void sched(TimerTask task, long time, long period) {
synchronized(queue) {
...
queue.add(task);
}
}
但是正如上篇文章讲到的，使用queue.wait(long)的前提条件是sched()动作执行的时间很短，否则如果很长，那么queue.wait()不能够按时醒来。

(2)
前面讲了wait/notify机制，Thread还有一个sleep()静态方法，它也能使线程暂停一段时间。sleep与wait的不同点是：sleep并不释放锁，并且sleep的暂停和wait暂停是不一样的。obj.wait会使线程进入obj对象的等待集合中并等待唤醒。
但是wait()和sleep()都可以通过interrupt()方法打断线程的暂停状态，从而使线程立刻抛出InterruptedException。
如果线程A希望立即结束线程B，则可以对线程B对应的Thread实例调用interrupt方法。如果此刻线程B正在wait/sleep/join，则线程B会立刻抛出InterruptedException，在catch() {} 中直接return即可安全地结束线程。
需要注意的是，InterruptedException是线程自己从内部抛出的，并不是interrupt()方法抛出的。对某一线程调用interrupt()时，如果该线程正在执行普通的代码，那么该线程根本就不会抛出InterruptedException。但是，一旦该线程进入到wait()/sleep()/join()后，就会立刻抛出InterruptedException。

sleep()、suspend()、resume()方法不推荐使用，推荐使用wait()、notify()、notifyAll()。
sleep()方法是使线程停止一段时间的方法。在sleep 时间间隔期满后，线程不一定立即恢复执行。这是因为在那个时刻，其它线程可能正在运行而且没有被调度为放弃执行，除非
(a)“醒来”的线程具有更高的优先级。
(b)正在运行的线程因为其它原因而阻塞。
wait()是线程交互时，如果线程对一个同步对象x 发出一个wait()调用，该线程会暂停执行，被调对象进入等待状态，直到被唤醒或等待时间到。
当调用wait()后，线程会释放掉它所占有的“锁标志”，从而使线程所在对象中的其它synchronized数据可被别的线程使用。
waite()和notify()因为会对对象的“锁标志”进行操作，所以它们必须在synchronized函数或synchronizedblock中进行调用。如果在non-synchronized函数或non-synchronizedblock中进行调用，虽然能编译通过，但在运行时会发生IllegalMonitorStateException的异常。

⑨ java的sleep()和wait()

wait()、notify()、notifyAll()这三个方法是Object中的方法，跟锁类似。
当t1没有获取这个object时wait，其他线程释放object后叫notify，然后t1立即继续执行。

sleep()跟上面这三个不一样，是Thread中的方法，不需要等待资源被释放，sleep有一个时间传参，想让线程等待多会儿就等待多会儿，不需要其他线程唤醒。例如：
try{
t1.sleep(1000); //t1等待1秒后继续执行下面的内容
}catch(Exception e){}