关于java:java创建线程的三种方式

1. 继承 Thread 类以创立新线程

该办法将咱们本人定义的一个线程类继承自 Thread 类，并重写 run() 办法来重定义该线程所进行的操作。
线程类：

public class Thread1 extends Thread {
    // 重写办法重定义该线程进行的操作
    @Override
    public void run() {for (int i = 0; i < 10; i++) {System.out.println(Thread.currentThread().getName() + "执行" + i);
        }
    }
}

测试类：

public class Main {public static void main(String[] args) {
        // 启动线程
        new Thread1().start();
        for (int i = 0; i < 10; i++) {System.out.println(Thread.currentThread().getName() + "执行" + i);
        }
    }
}

后果：

main 执行 0
Thread- 0 执行 0
main 执行 1
Thread- 0 执行 1
main 执行 2
Thread- 0 执行 2
main 执行 3
Thread- 0 执行 3
main 执行 4
Thread- 0 执行 4
main 执行 5
main 执行 6
main 执行 7
main 执行 8
Thread- 0 执行 5
main 执行 9
Thread- 0 执行 6
Thread- 0 执行 7
Thread- 0 执行 8
Thread- 0 执行 9 

咱们自定义的线程和主线程交替凌乱地执行。

2. 实现 Runnable 以创立新线程

线程类：

public class Thread2 implements Runnable {
    // 重写 run 办法重定义线程执行的内容
    @Override
    public void run() {for (int i = 0; i < 10; i++) {System.out.println(Thread.currentThread().getName() + "执行" + i);
        }
    }
}

测试类：

public class Main {public static void main(String[] args) {new Thread(new Thread2()).start();
        for (int i = 0; i < 10; i++) {System.out.println(Thread.currentThread().getName() + "执行" + i);
        }
    }
}

留神这种状况的线程创立形式是将实现了 Runnable 接口的类填入到 Thread 办法的构造函数中来创立的，与第一种办法间接创立对应的继承自 Thread 类的子类的形式有所区别。
执行后果：

Thread- 0 执行 0
main 执行 0
Thread- 0 执行 1
main 执行 1
Thread- 0 执行 2
main 执行 2
Thread- 0 执行 3
main 执行 3
Thread- 0 执行 4
main 执行 4
Thread- 0 执行 5
main 执行 5
Thread- 0 执行 6
main 执行 6
main 执行 7
Thread- 0 执行 7
main 执行 8
Thread- 0 执行 8
main 执行 9
Thread- 0 执行 9 

3. 匿名外部类

本质上匿名外部类的办法就是实现 Runnable 接口，只不过这个类没有名字。
测试类：

public class Main {public static void main(String[] args) {
        // 以内部类的形式实现 Runnable 接口
        new Thread(new Runnable() {
            // 重写 run 办法来重定义线程执行的内容
            @Override
            public void run() {for (int i = 0; i < 10; i++) {System.out.println(Thread.currentThread().getName() + "执行" + i);
                }
            }
        }).start();   // 开启线程
        for (int i = 0; i < 10; i++) {System.out.println(Thread.currentThread().getName() + "执行" + i);
        }
    }
}

执行后果：

Thread- 0 执行 0
Thread- 0 执行 1
Thread- 0 执行 2
Thread- 0 执行 3
Thread- 0 执行 4
Thread- 0 执行 5
Thread- 0 执行 6
Thread- 0 执行 7
main 执行 0
Thread- 0 执行 8
main 执行 1
main 执行 2
main 执行 3
main 执行 4
main 执行 5
main 执行 6
main 执行 7
main 执行 8
main 执行 9
Thread- 0 执行 9 

4. 继承 Thread 类和实现 Runnable 接口的区别

次要的区别有亮点：
1. 因为 java 是单继承的机制，所以如果你抉择应用继承 Thread 类的形式实现多线程，则无奈再继承别的类实现对应的性能，而实现 Runnable 接口则不会有这样的问题。
2. 继承 Thread 类不适宜资源共享，而实现 Runnable 接口则适宜实现资源共享，上面举个例子进行阐明。
继承 Thread 类：

class MyThread extends Thread {
    private int count = 15;
    private String name;
    public MyThread(String name) {this.name = name;}
    @Override
    public void run() {for (int i = 0;i < 5;i++){System.out.println(name + "执行" + count);
            count--;
        }
    }
}

public class Main {public static void main(String[] args) {new MyThread("1").start();
        new MyThread("2").start();}
}

执行后果：

 1 执行  15
2 执行  15
2 执行  14
1 执行  14
2 执行  13
1 执行  13
2 执行  12
1 执行  12
2 执行  11
1 执行  11

实现 Runnable 接口：

class MyRunnable implements Runnable {
    private int count = 15;
    @Override
    public void run() {for (int i = 0; i < 5; i++) {System.out.println(Thread.currentThread().getName() + "执行" + count);
        count--;
        }
    }
}

public class Main {public static void main(String[] args) {MyRunnable myRunnable = new MyRunnable();
        // 上面两个开始的线程都来于同一个线程类，因而类中的属性能够共享
        new Thread(myRunnable, "3").start();
        new Thread(myRunnable, "4").start();}
}

执行后果：

 3 执行 15
4 执行 15
3 执行 14
3 执行 12
3 执行 11
3 执行 10
4 执行 13
4 执行 8
4 执行 7
4 执行 6 

从执行的后果就能够看出应用实现 Runnable 接口的办法能够是的多个线程共享同一个资源变得可能，因而在资源共享性上更胜一筹。