1. class Demo extends Thread{
   
2.         public void run(){
   
3.                         for(int i=0;i<1000;i++){
   
4.                                 System.out.println("Demo");
   
5.                 }
   
6.         }
   
7. }
   
8. 
   
9. public class XianCheng{
   
10.         public static void main(String[] args){
    
11.                 Demo d  =  new Demo();
    
12.                 d.start();
    
13.                
    
14.                 for(int x=0;x<1000;x++){
    
15.                         System.out.println("Hello World!"+x);
    
16.                 }
    
17.         }
    
18. }

复制代码

一个cpu一次只能执行一个线程，如果是多个核的话，可以同时执行多条线性

1.Thread类的start()方法来启动一个线程,这时此线程是处于就绪状态，并没有运行,然后通过此Thread类调用方法run()来完成其运行操作的.  start方法就是创建新的线程，并且调用run方法。
2.Thread类的run()称为线程体，它包含了要执行的这个线程的内容，Run方法运行结束，此线程终止，而CPU再运行其它线程。
3.线程的同时执行其实是我们的感觉，由于线程间的切换很快让我们觉得是很多线程在同时运行一样。
4.之所以出现线程，就是为了更好的利用CPU，让她更加“精明”的干活.

这样改下就行了，for循环里加了sleep：

1. class Demo extends Thread{
   
2.         public void run(){
   
3.                         for(int i=0;i<1000;i++){
   
4.                                         try {
   
5.                                                                         Thread.sleep(50);
   
6.                                                                 } catch (InterruptedException e) {
   
7.                                                                         // TODO Auto-generated catch block
   
8.                                                                         e.printStackTrace();
   
9.                                                                 }
   
10.                                 System.out.println("Demo");
    
11.                 }
    
12.         }
    
13. }
    
14. 
    
15. public class XianCheng{
    
16.         public static void main(String[] args){
    
17.                 Demo d  =  new Demo();
    
18.                 d.start();
    
19.                
    
20.                 for(int x=0;x<1000;x++){
    
21.                         try {
    
22.                                                 Thread.sleep(50);
    
23.                                         } catch (InterruptedException e) {
    
24.                                                 // TODO Auto-generated catch block
    
25.                                                 e.printStackTrace();
    
26.                                         }
    
27.                         System.out.println("Hello World!"+x);
    
28.                 }
    
29.         }
    
30. }

复制代码

原因是如果机器不是多核的话，线程机制是靠为每个线程分配运行的时间块来实现的。简单的，比如每个线程每次分给50微秒的运行时间，所有线程轮流运行。
但其实线程有优先级的区别，如果有两个等待运行的线程优先级高的会被先分配时间块。
所以假设你的for循环在一个时间块里就运行完了的话，那就没有同时执行的效果，而在for里加一个sleep那代码肯定无法在一个时间块内运行完。
这样当分配某个线程的事件结束后这个线程就挂起，系统让另外一个线程运行，这样反复就有同时运行的效果了。