JAVAsleep与wait区别

⑴ java中的sleep和wait的区别

java中的sleep和wait的区别如下：
1、所属的超类不同：sleep属于线程Thread类的方法，而wait属于Object方法
2、用法不同：
①sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。
②调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备
3、举例说明：
wait方法：
private static class Thread1 implements Runnable{
@Override
public void run(){
synchronized (TestD.class) {
System.out.println("enter thread1...");
System.out.println("thread1 is waiting...");
try {
//调用wait()方法，线程会放弃对象锁，进入等待此对象的等待锁定池
TestD.class.wait();
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("thread1 is going on ....");
System.out.println("thread1 is over!!!");
}
}
}
sleep方法用法：
private static class Thread2 implements Runnable{
@Override
public void run(){
synchronized (TestD.class) {
System.out.println("enter thread2....");
System.out.println("thread2 is sleep....");
//只有针对此对象调用notify()方法后本线程才进入对象锁定池准备获取对象锁进入运行状态。
TestD.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!!!");
}
}
}
运行结果：
enter thread1...
thread1 is waiting...
enter thread2....
thread2 is sleep....
thread2 is going on....
thread2 is over
thread1 is going on ....
thread1 is over

⑵ java中wait和sleep的区别

1.对于sleep()方法，是属于Thread类中的。而wait()方法，则是属于Object类中的。
2.最主要是sleep方法没有释放锁，而 wait 方法释放了锁，使得其他线程可以使用同步控制块或者方法。
3.wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用

4.sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常
5、sleep()是让某个线程暂停运行一段时间,其控制范围是由当前线程决定,也就是说,在线程里面决定；wait(),首先,这是由某个确定的对象来调用的,将这个对象理解成一个传话的人,当这个人在某个线程里面说"暂停!",

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

1、同步锁的对待不同：

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

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

2、用法的不同：

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

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

3、属于不同的类：

sleep（）的类是Thread。

wait（）的类是Object。

⑷ sleep和wait的区别

sleep和wait的区别：

1、sleep是Thread的静态方法，wait是Object的方法，任何对象实例都能调用。

2、sleep不会释放锁，它也不需要占用锁。wait会释放锁，但调用它的前提是当前线程占有锁（即代码要在synchronized中）。

3、它们都可以被interrupted方法中断。

具体来说：

Thread.Sleep(1000)意思是在未来的1000毫秒内本线程不参与CPU竞争，1000毫秒过去之后，这时候也许另外一个线程正在使用CPU，那么这时候操作系统是不会重新分配CPU的，直到那个线程挂起或结束。

即使这个时候恰巧轮到操作系统进行CPU分配，那么当前线程也不一定就是总优先级最高的那个，CPU还是可能被其他线程抢占去。另外值得一提的是Thread.Sleep(0)的作用，就是触发操作系统立刻重新进行一次CPU竞争，竞争的结果也许是当前线程仍然获得CPU控制权，也许会换成别的线程获得CPU控制权。

wait(1000)表示将锁释放1000毫秒，到时间后如果锁没有被其他线程占用，则再次得到锁，然后wait方法结束，执行后面的代码，如果锁被其他线程占用，则等待其他线程释放锁。

注意，设置了超时时间的wait方法一旦过了超时时间，并不需要其他线程执行notify也能自动解除阻塞，但是如果没设置超时时间的wait方法必须等待其他线程执行notify。

⑸ java sleep 和wait的区别

java中sleep和wait的区别主要有两点，第一sleep必须指定时间，而wait可以指定也可以不指定；第二在同步中，sleep释放cpu执行权，但是不释放锁，而wait释放cpu执行权和锁。
java中sleep和wait都是让线程休眠的方法，它们都是阻塞方法。在同步中，需要注意根据具体的需求来选择使用sleep和wait。

⑹ 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()的时候,那么我就可以煮饭了,这个被暂停的线程就会从暂停处

⑺ wait方法和sleep方法的区别

1. Java中sleep和wait的区别

① 这两个方法来自不同的类分别是，sleep来自Thread类，和wait来自Object类。

sleep是Thread的静态类方法，谁调用的谁去睡觉，即使在a线程里调用b的sleep方法，实际上还是a去睡觉，要让b线程睡觉要在b的代码中调用sleep。

② 锁: 最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。

sleep不出让系统资源；wait是进入线程等待池等待，出让系统资源，其他线程可以占用CPU。一般wait不会加时间限制，因为如果wait线程的运行资源不够，再出来也没用，要等待其他线程调用notify/notifyAll唤醒等待池中的所有线程，才会进入就绪队列等待OS分配系统资源。sleep(milliseconds)可以用时间指定使它自动唤醒过来，如果时间不到只能调用interrupt()强行打断。

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

③ 使用范围：wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用。

synchronized(x){
x.notify()
//或者wait()
}

2. Java中HashMap和HashTable的区别

① 历史原因: Hashtable是给予陈旧的Dictonary类的, HashMap是Java1.2引进的Map接口的一个实现

② HashMap允许空的键值对, 而HashTable不允许

③ HashTable同步，而HashMap异步，效率上比HashTable要高

3. 请简述在异常当中，throw和throws有什么区别

① throw代表动作，表示抛出一个异常的动作；throws代表一种状态，代表方法可能有异常抛出
② throw用在方法实现中，而throws用在方法声明中
③ throw只能用于抛出一种异常，而throws可以抛出多个异常

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

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

⑼ 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 中 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
讲了挺多。我也觉得啰嗦。但是应该通俗易懂吧。