Java 多线程学习（1）——实现多线程的两种方式Thread/Runnable

重新系统的学习一下Java多线程部分。参考书籍为《java多线程编程核心技术》。

实现多线程的方式主要有两种，一种是继承Thread类，另一种是实现Runnable接口。
首先看一下Thread类的结构

public class Thread implements Runnable

Thread类实现了Runnable接口，它们之间具有多态关系。但继承Thread类创建多线程，不支持多继承。使用实现Runnable接口的方式，能够支持多继承。
不过这两种实现多线程方式的在工作时的性质是一样的，没有本质上的区别。

继承Thread类实现多线程

线程调用的随机性

使用多线程技术，代码的运行结果与代码执行顺序或调用顺序无关

public class Main {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        System.out.println("运行结束！");
    }
}
class MyThread extends Thread {
    @Override
    public void run() {
        super.run();
        System.out.println("MyThread");
    }
}

输出：

CPU执行哪个线程具有不确定性。

public class Main {
    public static void main(String[] args) {
        try {
            MyThread myThread = new MyThread();
            myThread.setName("MyThread");
            myThread.start();
            for (int flag = 0; flag < 10; flag++) {
                Thread.sleep((int) (Math.random() * 1000));
                System.out.println("main="+Thread.currentThread().getName());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class MyThread extends Thread {
    @Override
    public void run() {
        try {
            for (int flag = 0; flag < 10; flag++) {
                Thread.sleep((int) (Math.random() * 1000));
                System.out.println("run=" + Thread.currentThread().getName());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

输出：

Thread.java类中的start()方法通知“线程规划器”此线程已经准备就绪，等待调用线程对象的run()方法。
这个过程其实就是让系统安排一个时间来调用Thread中的run()方法，启动线程，具有异步执行的效果。
如果调用代码thread.run()，就是同步执行了，此时线程对象不交由“线程规划器”处理，而由main主线程来调用run()方法，也就是必须等run()方法中的代码执行完才会执行之后的代码。
对比如下：

public class Main {
    public static void main(String[] args) {
        try {
            MyThread myThread = new MyThread();
            myThread.setName("MyThread");
            myThread.run();//修改start()方法为run()方法
            for (int flag = 0; flag < 10; flag++) {
                Thread.sleep((int) (Math.random() * 1000));
                System.out.println("main="+Thread.currentThread().getName());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class MyThread extends Thread {
    @Override
    public void run() {
        try {
            for (int flag = 0; flag < 10; flag++) {
                Thread.sleep((int) (Math.random() * 1000));
                System.out.println("run=" + Thread.currentThread().getName());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

输出：

可以看出，代码是同步执行的。

start()方法的顺序不代表线程启动顺序

public class Main {
    public static void main(String[] args) {
        MyThread myThread1 = new MyThread(1);
        MyThread myThread2 = new MyThread(2);
        MyThread myThread3 = new MyThread(3);
        MyThread myThread4 = new MyThread(4);
        MyThread myThread5 = new MyThread(5);
        MyThread myThread6 = new MyThread(6);
        MyThread myThread7 = new MyThread(7);
        MyThread myThread8 = new MyThread(8);
        MyThread myThread9 = new MyThread(9);
        MyThread myThread10 = new MyThread(10);
        myThread1.start();
        myThread2.start();
        myThread3.start();
        myThread4.start();
        myThread5.start();
        myThread6.start();
        myThread7.start();
        myThread8.start();
        myThread9.start();
        myThread10.start();
    }
}
class MyThread extends Thread {
    private int i;
    public MyThread(int i) {
        super();
        this.i = i;
    }
    @Override
    public void run() {
        System.out.println(i);
    }
}

输出：

实现Runnable接口

public class Main {
    public static void main(String[] args) {
        Runnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
        System.out.println("运行结束！");
    }
}
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("运行中！");
    }
}

输出：