1. public class Test0001 {
   
2.         /**
   
3.          * 创建线程的第一种方式：继承Thread类。 步骤： 1.定义类的继承Thread. 2.复写Thread类中的run方法。
   
4.          * 3.调用线程的start方法， 该方法两个作用：启动线程，调用run方法。
   
5.          */
   
6.         public static void main(String[] args) {
   
7.                 TheadTest theadTest = new TheadTest();
   
8.                 theadTest.start();
   
9.                 // 主线程
   
10.                 for (int i = 0; i < 4000; i++) {
    
11.                         System.out.println(Thread.currentThread().getName() + i);
    
12.                 }
    
13.         }
    
14. }
    
15. class TheadTest extends Thread {
    
16.         // 副线程
    
17.         public void run() {
    
18.                 for (int i = 0; i < 4000; i++) {
    
19.                         System.out.println(Thread.currentThread().getName() + i);
    
20. 
    
21.                 }
    
22. 
    
23.         }
    
24. }

复制代码

1. /**
   
2. * 创建线程的第二种方式:实现Runnable接口 步骤： 1，定义类实现Runable接口 2，覆盖Runnable接口中的Run方法。
   
3. * 3，通过Thread类建立线程对象 4，将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数
   
4. * */
   
5. public class Test0002 {
   
6.         public static void main(String[] args) {
   
7.                 ThredTest t = new ThredTest();
   
8.                 Thread t1 = new Thread(t);
   
9.                 Thread t2 = new Thread(t);
   
10.                 Thread t3 = new Thread(t);
    
11.                 t1.start();
    
12.                 t2.start();
    
13.                 t3.start();
    
14. 
    
15.         }
    
16. }
    
17. class ThredTest implements Runnable {
    
18.         private static int sick = 50;
    
19. 
    
20.         public void run() {
    
21.                 while (true) {
    
22.                         if (sick > 0) {
    
23.                                 System.out.println(Thread.currentThread().getName() + "卖票"
    
24.                                                 + sick--);
    
25.                         }
    
26.                 }
    
27.         }
    
28. }
    

复制代码

一般选用第二种来使用，灵活可以在类中继续继承别的类来实现其他方法！