Java基础-创建线程的三种方法

1.继承Thread类

1）定义Thread类的子类，并重写run方法，run方法就是线程要执行的任务，将其称为执行体。

2）创建Thread类子类的对象，即创建了线程对象。

3）调用线程对象的start()方法来启动该线程。

此方法需要覆盖掉其中的run()方法。

 1 public class MyThread extends Thread {
 2     
 3     public MyThread(){}
 4 
 5     // set name
 6     public MyThread(String name){
 7         super(name);
 8     }
 9 
10     @Override
11     public void run(){
12         System.out.println(Thread.currentThread().getName());
13     }
14 }

2.创建实现runnable接口的类对象

1）定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。

2）创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象

3）调用线程对象的start()方法来启动该线程

   与Thread方法相比较，1）Runnable方法更加灵活，避免了单继承的局限性：Thread方法不能继承其他类。实现Runnable接口后，还可以继续继承其他类

　　　　　　　　　　　2）增强了程序的扩展性，降低了程序的耦合性：实现了设置线程任务和开启线程进行了分离(解耦)，实现类中，重写了run方法

　　　　　　　　　　　3）如果要访问当前线程，则必须使用Thread.currentThread()方法，而继承方法只需要使用this方法即可访问当前线程

 1 class RunnableImpl implements Runnable {
 2 
 3     @Override
 4     public void run() {
 5         for (int i = 0; i < 20; i++){
 6             System.out.println(Thread.currentThread().getName()+"-->"+i);
 7         }
 8     }
 9 }
10 
11 public class Test04 {
12     public static void main(String[] args) {
13         RunnableImpl run = new RunnableImpl();
14         Thread t = new Thread(run);
15         t.start();
16 
17         for (int i = 0;i < 20;i++){
18             System.out.println(Thread.currentThread().getName() + "-->"+i);
19         }
20     }
21 }

3.匿名内部类实现创建Thread

 1 public class InnerClassThread {
 2     public static void main(String[] args) {
 3         
 4         // InnerClass implement 
 5         new Thread(){
 6             @Override
 7             public void run(){
 8                 for (int i=0; i < 20;i++){
 9                     System.out.println(Thread.currentThread().getName()+"-->"+"Ben");
10                 }
11             }
12         }.start();
13 
14         Runnable r = new Runnable() { // Polymorphism
15             @Override
16             public void run() {
17                 for (int i = 0;i<20;i++){
18                     System.out.println(Thread.currentThread().getName()+"-->"+"Allen");
19                 }
20             }
21         };
22         new Thread(r).start();
23 
24         // InnerClass implement use interface Runnable
25         new Thread(new Runnable() {
26             @Override
27             public void run() {
28                 for(int i = 0;i < 20;i++){
29                     System.out.println(Thread.currentThread().getName() + "-->"+"Amy");
30                 }
31             }
32         }).start();
33     }
34 }