class CirOut implements Runnable
{
public void run()
{
  
  for(int x = 0; x < 100; x++)
  {
   System.out.println(Thread.currentThread().getName()+"------"+x);
   Thread.yield();
  }

}
}
class ThreadTest
{
public static void main(String[] args)
{
  CirOut cir = new CirOut();
  Thread t1 = new Thread(cir);
  Thread t2 = new Thread(cir);
  
  t1.start();
  
  t2.start();
  
}
}
yield方法临时释放执行权  执行其他线程  那按照这么说就应该是0线程和1线程交替执行的怎么还会出现这种情况 连着执行两次0线程

学习学习！

       首先你要知道Thread.yield()方法的作用，在我看来，此方法被执行后执行当前线程丧失执行权，并没有丧失执行资格，那么线程一样具有抢占CPU执行权的。可以理解成，当前线程的状态从执行状态转换到了就绪状态，线程仍然具有被执行的资格。
      既然线程具有执行资格，那么你程序中的t1、t2两条线程具体是哪个线程能抢占到CPU的执行权，是不确定，这个得是CPU说了算，CPU切换到哪个线程，就执行哪个线程。
       若想达到LZ初期想要的效果，可以试试修改t1、t2线程的优先级，setPriority(线程优先级)。一个线程设置最高优先级，另一个设置最低优先级。可以一试，不过运行的效果可能跟LZ想要的效果又不一样。这个也可以解释，即使修改了线程的优先级，也只能说明该线程比另一线程具有较多的执行机会，而不是说明该线程一定会比另一线程先执行。同样，可以理解为，线程的执行，要看CPU切换到哪个就运行哪个！
附上示例代码：

1. class TestYield extends Thread
   
2. {
   
3.         public TestYield()
   
4.         {
   
5.         
   
6.         }
   
7.         public TestYield(String name)
   
8.         {
   
9.                 super(name);
   
10.         }
    
11.         public void run()
    
12.         {
    
13.                 for(int i=0;i<50;i++)
    
14.                 {
    
15.                         System.out.println(getName()+" "+i);
    
16.                         if(i==20)
    
17.                                 Thread.yield();    //使用yield方法让当前线程让步
    
18.                 }
    
19.         }
    
20.         public static void main(String[] args)
    
21.         {
    
22.                 //启动两条并发线程
    
23.                 TestYield ty1=new TestYield("高级");
    
24.                 ty1.setPriority(Thread.MAX_PRIORITY);   //将ty1设置成最高优先级
    
25.                 ty1.start();
    
26.                 TestYield ty2=new TestYield("低级");    //将ty2设置成最低优先级
    
27.                 ty2.setPriority(Thread.MIN_PRIORITY);
    
28.                 ty2.start();
    
29.         }
    
30. }

复制代码

这个是随机的,每次运行都不一样的结果的,如果你想按顺序走,那就进行加锁

那不是绝对的，那些得看线程获得 执行权。

了解一下cpu运算机制，就好理解了

释放执行权，并没有释放执行资格，线程0释放了执行权，仍有执行资格，然后和线程1共同夺取执行权，谁获取到执行权（只是个随机问题），就执行哪个线程，出现上面情况，是线程0释放执行权，再和线程1夺取执行权时，又获到了执行权，又执行了一遍线程0，多运行几遍，会出现线程0，1交替执行的结果；