yieldJava

㈠ java线程的sleep和yield的区别

1、sleep()
使当前线程（即调用该方法的线程）暂停执行一段时间，让其他线程有机会继续执行，但它并不释放对象锁。也就是说如果有synchronized同步快，其他线程仍然不能访问共享数据。注意该方法要捕捉异常。
例如有两个线程同时执行(没有synchronized)一个线程优先级为MAX_PRIORITY，另一个为MIN_PRIORITY，如果没有Sleep()方法，只有高优先级的线程执行完毕后，低优先级的线程才能够执行；但是高优先级的线程sleep(500)后，低优先级就有机会执行了。
总之，sleep()可以使低优先级的线程得到执行的机会，当然也可以让同优先级、高优先级的线程有执行的机会。

2、join()
join()方法使调用该方法的线程在此之前执行完毕，也就是等待该方法的线程执行完毕后再往下继续执行。注意该方法也需要捕捉异常。

3、yield()
该方法与sleep()类似，只是不能由用户指定暂停多长时间，并且yield（）方法只能让同优先级的线程有执行的机会。

4、wait()和notify()、notifyAll()

这三个方法用于协调多个线程对共享数据的存取，所以必须在synchronized语句块内使用。synchronized关键字用于保护共享数据，阻止其他线程对共享数据的存取，但是这样程序的流程就很不灵活了，如何才能在当前线程还没退出synchronized数据块时让其他线程也有机会访问共享数据呢？此时就用这三个方法来灵活控制。
wait()方法使当前线程暂停执行并释放对象锁标示，让其他线程可以进入synchronized数据块，当前线程被放入对象等待池中。当调用notify()方法后，将从对象的等待池中移走一个任意的线程并放到锁标志等待池中，只有锁标志等待池中线程能够获取锁标志；如果锁标志等待池中没有线程，则notify()不起作用。
notifyAll()则从对象等待池中移走所有等待那个对象的线程并放到锁标志等待池中

㈡ java中Thread中yield()这个方法

楼主你错误的理解了yiedld这个方法。
yiedld这个方法是让当前线程回到可执行状态，以便让具有相同优先级的线程进入执行状态，但不是绝对的。因为虚拟机可能会让该线程重新进入执行状态。
让线程暂时停止可以选择sleep方法。比如thread.sleep(1000),当前线程睡眠1秒。需要知道的是，1秒后，线程是回到可执行状态，并不是执行状态，什么时候执行那是由虚拟机来决定的。所以sleep(1000)并不是在睡眠1秒后立即执行。

㈢ Java中yield()方法怎么使用

Thread.yield( )方法：

使当前线程从执行状态（运行状态）变为可执行态（就绪状态）。cpu会从众多的可执行态里选择，也就是说，刚刚的那个线程还是有可能会被再次执行到的，并不是说一定会执行其他线程了。

㈣ java中yield()方法如何使用

Thread.yield()方法作用是：暂停当前正在执行的线程对象，并执行其他线程。

yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

结论：yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。
public class TestYield {

public static void main(String[] args) {

MyThread3 t1 = new MyThread3("t1");
MyThread3 t2 = new MyThread3("t2");
t1.start();
t2.start();
}
}

class MyThread3 extends Thread {

MyThread3(String s) {
super(s);
}

public void run() {
for(int i = 1;i <=100; i++) {
System.out.println(getName() + ":"+i);
if(i == 0)
yield();
}
}
}

㈤ java yield的用法

Tread.yield();到这一步就是让步 让别的线程执行 别的线程也执行这句话 然后再让步 另一个线程执行 所以下面这句话 执行不到 是不是这样？

㈥ java中的yield中文应该翻译成什么意思

这个方法是线程方法，当一个线程抢到执行权后，执行到yield（）方法后，就会放弃执行权，其他线程就可以拿到执行权 了。

java实现的一个stack类，其中的Thread.yield()语句没看太明白。
1) pop()中，为什么要yield()之后再执行point--?
2) push()中，为什么要在yield()之后再执行buffer[point]的赋值？
源代码如下：
class Stack {
private String name;
private String[] buffer=new String[100];
int point=-1;

public Stack(String name){this.name=name;}
public String getName(){return name;}

public synchronized int getPoint(){return point;}

public synchronized String pop() {
this.notifyAll();

while(point==-1){
System.out.println(Thread.currentThread().getName()+": wait");
try{
this.wait();
}catch(InterruptedException e){throw new RuntimeException(e);}
}

String goods = buffer[point];
buffer[point]=null;
Thread.yield();
point--;
return goods;
}
public synchronized void push(String goods) {
this.notifyAll();

while(point==buffer.length-1){
System.out.println(Thread.currentThread().getName()+": wait");
try{
this.wait();
}catch(InterruptedException e){throw new RuntimeException(e);}
}
point++;
Thread.yield();
buffer[point]=goods;
}
}问题补充：

我明白Thread.yield()是为了同步，我的问题是yield()在这里为什么能保证同步？

或者说，不使用yield()会出现哪些不同步的问题呢？

帮我分析一下，比如说说，没有yield（）的情况下，一个线程在pop，有可能另外一个线程对它造成什么样的不同步？

程序太长，放不下，我放到HI上了，地址如下，多谢各位DX了。。。。

㈦ java中join( )和yield方法有什么区别和联系

yield：理论上，yield意味着放手，放弃，投降。一个调用yield()方法的线程告诉虚拟机它乐意让其他线程占用自己的位置。这表明该线程没有在做一些紧急的事情。注意，这仅是一个暗示，并不能保证不会产生任何影响。注意：它是一个静态的原生(native)方法；它告诉当前正在执行的线程把运行机会交给线程池中拥有相同优先级的线程；

它不能保证使得当前正在运行的线程迅速转换到可运行的状态；它仅能使一个线程从运行状态转到可运行状态，而不是等待或阻塞状态。

join：线程实例的方法join()方法可以使得一个线程在另一个线程结束后再执行。如果join()方法在一个线程实例上调用，当前运行着的线程将阻塞直到这个线程实例完成了执行。

packagetest;
publicclassYieldExample{
publicstaticvoidmain(String[]args){
Threadprocer=newProcer();
Threadconsumer=newConsumer();
procer.setPriority(Thread.MIN_PRIORITY);
consumer.setPriority(Thread.MAX_PRIORITY);
procer.start();
consumer.start();
}
}
classProcerextendsThread{
publicvoidrun(){
for(inti=0;i<5;i++){
System.out.println("IamProcer:ProcedItem"+i);
Thread.yield();
}
}
}
classConsumerextendsThread{
publicvoidrun(){
for(inti=0;i<5;i++){
System.out.println("IamConsumer:ConsumedItem"+i);
Thread.yield();
}
}
}

packagetest;
publicclassJoinExample{
publicstaticvoidmain(String[]args)throwsInterruptedException{
Threadt=newThread(newRunnable(){
publicvoidrun(){
System.out.println("Firsttaskstarted");
System.out.println("Sleepingfor2seconds");
try
{
Thread.sleep(2000);
}catch(InterruptedExceptione){
e.printStackTrace();
}
System.out.println("Firsttaskcompleted");
}
});
Threadt1=newThread(newRunnable(){
publicvoidrun(){
System.out.println("Secondtaskcompleted");
}
});
t.start();
t.join();
t1.start();
}
}

㈧ java线程中的yield()

Thread.yield();
Sun
api
明确指出
“暂停当前正在执行的线程对象，并执行其他线程。
”
所以yield()是让当前线程暂停(由于没有说明执行其他线程的时间，很有可能，执行了其他同优先级的线程后马上又回到该线程了。)，以便让具有相同优先级的线程进入执行状态，但不是绝对的。因为虚拟机可能会让该线程重新进入执行状态。
“比如说说，没有yield()的情况下，一个线程在pop，有可能另外一个线程对它造成什么样的不同步?”
那要看你另一个线程的代码了，如果另一个线程和pop是同步的，那么用了yield另一个线程执行完后才执行point--;return
goods;不用如果另一个线程用到了point，他的值可能已经是自减也可能是没自减的。。。

㈨ 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中Wait，Sleep和Yield方法的区别

sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用 sleep不会释放对象锁。
wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态
yield( )方法使当前线程从执行状态（运行状态）变为可执行态（就绪状态）。cpu会从众多的可执行态里选择，也就是说，当前也就是刚刚的那个线程还是有可能会被再次执行到的，并不是说一定会执行其他线程而该线程在下一次中不会执行到了。