Java 笔记 多线程 （三）-- Runable接口

可爱的静静

多线程 Runable接口
创建线程有两种方式：

1.      继承Thread类并覆盖run方法

2.      实现接口Runnable

第二种方式是（实现Runnable接口）
实现接口步骤：
1.        定义类实现接口
2.        覆盖Runnable 接口中的run方法(也是把创建好的线程想要执行的代码放在run)
3.        通过Thread类创建线程对象
4.        将Runnable接口的子类对象作为实际参数传递给Thread类的构造方法
      实现Runnable接口的子类对象传递给Thread类的结构方法，让Thread类去执行指定对象的run方法
         这个结构方法是
Thread(Runnable target)
                 分配新的 Thread 对象。
5.调用Thread类的start方法开启线程并调用Runnable接口子类的run 方法
//定义类实现接口并且覆盖run方法
例子：售票系统

1. package UI;
   
2. 
   
3. import java.lang.Thread;
   
4. 
   
5. public class sport {
   
6.         public static void main(String[] args) {
   
7.                          Ticket  t=new Ticket();
   
8.                          Thread a=new Thread();
   
9.                         a.        start();
   
10.                          Thread b=new Thread(t);
    
11.                         b.        start();
    
12.                         Thread c=new Thread(t);
    
13.                         c.        start();
    
14.                         }
    
15.         }
    
16. 
    
17. class Ticket implements Runnable//实现接口 原来的方法是class Ticket extends Thread
    
18. {
    
19.    private int ticket=100;
    
20.    public void run(){
    
21.    while(true){
    
22. if(ticket>0)
    
23. System.out.println(Thread.currentThread().getName()+"…sale:"+ticket--);
    
24. }
    
25.    }
    
26. }

复制代码

Thread a=new Thread(); a.start () 这个只是启动了Thread的run方法是：
void        run()
          如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。

所以没有输出什么

因为Thread类有个结构方法：
Thread(Runnable target)
                 分配新的 Thread 对象。

所以可以把 实现Runnable接口的子类对象传递给Thread类的结构方法，让Thread类去执行指定对象的run方法


如果是方法一继承Thread这个方法的话代码是这样的

1. package UI;
   
2. 
   
3. import java.lang.Thread;
   
4. 
   
5. public class sport {
   
6.         public static void main(String[] args) {
   
7.                          Ticket  a=new Ticket();
   
8.                         a.        start();
   
9.                          Ticket b=new Ticket();
   
10.                         b.        start();
    
11.                         
    
12.                         }
    
13.         }
    
14. 
    
15. class Ticket  extends Thread
    
16. {
    
17.    private int ticket=100;
    
18.    public void run(){
    
19.    while(true){
    
20. if(ticket>0)
    
21. System.out.println(Thread.currentThread().getName()+"…sale:"+ticket--);
    
22. }
    
23.    }
    
24. }
    
25. 
    

复制代码

方法一和方法二的区别：
1.        实现方式是可以实现接口还可以继承其他类，但是继承Thread就不能继承其他类
避免了单继承的局限性，多数用实现Runnable
例如：看图1和图二   hahahah

2.        存放方式不同
用Thread 实现的代码存放在 Thread类的子类run方法中
实现Runnable实现的代码存放在 Runnable 接口的子类方法中

Thread类其实也实现了Runnable接口 就业是为了确定把实现代码存在run方法中

上面的两个代码都是买票系统，然后输出卖到第几张，两个代码执行后 不同的是同样式售票的 而且初始值都是100 但是结果是
实现Runnable 即使是开启多条线程一起卖票的，但只卖出100
继承Thread 方式的是 多条线程一起卖 ，卖出的票一共是200
因为 实现Runnable方法只传了一个对象t 继承Thread只有两个对象，两个对象都有ticket=100