java两种简单姿势的多线程

多线程：多件事情一起处理。

第一种: extend Therad 继承

//启动类
public class Main {
    static int count = 20;
    public static void main(String[] args) {
        ThreadA threadA = new ThreadA();//直接实例化一个线程A类    并用start()启动
        threadA.start();
        ThreadB threadB = new ThreadB();//直接实例化一个线程B类    并用start()启动
        threadB.start();
        //---------------------------------------
        //自己本身还在运行
        for(int i=0;i<5;i++){
            System.out.println("本身:"+ Main.count--);
            try {
                Thread.sleep(150);  //休眠200毫秒    方便观察结果
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
//线程A类
class ThreadA extends Thread {
    public void run() {
        //循环输出公共变量   并减一
        for(int i=0;i<5;i++){
            System.out.println("线程AAA:"+ Main.count--);
            try {
                sleep(200);  //休眠200毫秒    方便观察结果
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
//线程B类
class ThreadB extends Thread {
    public void run() {
        //循环输出公共变量   并减一
        for(int i=0;i<5;i++){
            System.out.println("线程BBBBBB:"+ Main.count--);
            try {
                sleep(100);  //休眠100毫秒    方便观察结果
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
#输出结果
本身:20
线程BBBBBBB:18
线程AAA:19
线程BBBBBBB:17
本身:16
线程AAA:15
线程BBBBBBB:15
本身:14
线程BBBBBBB:13
线程BBBBBBB:12
线程AAA:12
本身:11
本身:10
线程AAA:9
线程AAA:8

第二种: implements Runnable 实现。因为java是单继承，所以当类已经继承过其他类时，使用第二种实现多线程的方式

public class MainA {
    static int count = 20;
    public static void main(String[] args) {
        //实例化线程AA
        ThreadAA threadAA = new ThreadAA();
        //实例化线程类  并把线程AA当做参数传入
        Thread threadA = new Thread(threadAA);
        //启动线程AA
        threadA.start();
        //----------------------------------------
        //实例化线程BB
        ThreadBB threadBB = new ThreadBB();
        //实例化线程类  并把线程B当做参数传入
        Thread threadB = new Thread(threadBB);
        //启动线程BB
        threadB.start();
       //---------------------------------------
        //自己本身还在运行
        for(int i=0;i<5;i++){
            System.out.println("本身:"+ Main.count--);
            try {
                Thread.sleep(150);  //休眠200毫秒    方便观察结果
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
//实现 Runnable
class ThreadAA implements Runnable{
    public void run() {
        for(int i=0;i<5;i++){
            System.out.println("线程AAA:"+ Main.count--);
            try {
                Thread.sleep(200);  //休眠200毫秒    方便观察结果
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
//实现 Runnable
class ThreadBB implements Runnable{
    public void run() {
        for(int i=0;i<5;i++){
            System.out.println("线程BBBBBBB:"+ Main.count--);
            try {
                Thread.sleep(100);  //休眠100毫秒    方便观察结果
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
#输出结果
本身:20
线程BBBBBBB:18
线程AAA:19
线程BBBBBBB:17
本身:16
线程AAA:15
线程BBBBBBB:15
本身:14
线程BBBBBBB:13
线程BBBBBBB:12
线程AAA:12
本身:11
本身:10
线程AAA:9
线程AAA:8