Java基础--多线程的两种实现方式及区别

继承方式实现多线程示例：

承方式实现多线程示例：

1. class Demo extends Thread {
   
2.         //重写Thread类中的run()方法，把线程的功能代码写在该方法中。
   
3.         public void run() {
   
4.                 for(int i = 0; i < 10; i++)
   
5.                         System.out.println("demo run--" + i);
   
6.         }
   
7. }
   
8. 
   
9. class ThreadDemo {
   
10.         public static void main(String[] args) {
    
11.                 Demo d = new Demo();//创建好一个线程。
    
12.                 d.start();//开启线程并执行该线程的run方法。
    
13.                 //d.run();//仅仅是对象调用方法。而线程创建了，并没有运行。
    
14.         
    
15.                 for(int i = 0; i < 10; i++)
    
16.                         System.out.println("Hello World!--" + i);
    
17.         }
    
18. }

1. /**
   
2. *        需求：简单的卖票程序，多个窗口同时买票
   
3. *        通过实现Runnable接口方式实现，此时多个线程共享变量ticket，确保了变化的票数为同一个值，且总数为100。
   
4. */
   
5. class Ticket implements Runnable {
   
6.         private int ticket = 100;
   
7.         @Override
   
8.         public void run() {
   
9.                 for(; ticket > 0; ticket--) {
   
10.                         System.out.println(Thread.currentThread().getName() + "---" + ticket);
    
11.                 }
    
12.         }
    
13. }
    
14. 
    
15. public class ThreadDemo2 {
    
16.         public static void main(String[] args) {
    
17.                 Ticket t = new Ticket();
    
18.                 Thread t1 = new Thread(t);
    
19.                 Thread t2 = new Thread(t);
    
20.                 Thread t3 = new Thread(t);
    
21.                 Thread t4 = new Thread(t);
    
22.                 
    
23.                 t1.start();
    
24.                 t2.start();
    
25.                 t3.start();
    
26.                 t4.start();
    
27.         }
    
28. }