多线程基础一、线程实现

一、线程基础概念

1. 什么是线程？

线程可以理解成是在进程中独立运行的子任务。比如，QQ.exe 运行时有很多子任务同时在运行，视频线程、下载文件线程、发送消息线程等等。

多线程是异步的，所以 代码里面线程的顺序并不是线程的执行顺序，线程调用是随机的。

2. 线程的实现方式：A. 继承 Thread 类 B. 实现 Runnable 接口

从 Thread 源码来看，Thread 类也是实现了 Runnable 接口。这两种方式创建的线程在工作时性质一样的，只不过继承 Thread 不支持多继承，而实现 Runnable 则可以避免这个问题。

A. 继承 Thread 类

public class MyThread extends Thread {    @Override    public void run() {        super.run();        System.out.println("My Thread");    }}

B. 实现 Runnable 接口

/** * @ClassName MyThreadRunnable * @Description 实现 Runnable 接口 */public class MyThreadRunnable implements Runnable {    public void run() {        System.out.println("My Thread Runnable");    }}

/** * @ClassName Test2 * @Description 测试实现 Runnable 接口的线程 */public class Test2 {    public static void main(String[] args) {        MyThreadRunnable mtr = new MyThreadRunnable();        Thread thread = new Thread(mtr);        thread.start();        System.out.println("运行结束!");    }    /*    运行结果：    运行结束!    My Thread Runnable     */}

3. 线程是一个子任务，CPU以不确定的方式调用线程中的 run() 方法，所以线程 run() 方法的执行和 程序中代码顺序无关（后面会有线程状态可解释）。看下面的例子：

public class Test {    public static void main(String[] args) {        MyThread myThread = new MyThread();        myThread.start();        System.out.println("运行结束!");        /* 结果：         * 运行结束!         * My Thread         */    }}

下面再举一个例子（CPU以不确定的方式调用线程中的 run() 方法）：

/** * @ClassName MyThread * @Description 线程随机挂起 */public class MyThread extends Thread {    @Override    public void run() {        try {            for (int i = 0; i < 10; i++) {                int time = (int) (Math.random() * 1000);                Thread.sleep(time);                System.out.println("run=" + Thread.currentThread().getName());            }        } catch (InterruptedException e) {            e.printStackTrace();        }    }}

/** * @ClassName Test * @Description 测试线程被随机调用的特性，main线程也随机被挂起 */public class Test {    public static void main(String[] args) {        try {            MyThread thread = new MyThread();            thread.setName("myThread");            thread.start();            for (int i = 0; i < 10; i++) {                int time = (int) (Math.random() * 1000);                Thread.sleep(time);                System.out.println("main=" + Thread.currentThread().getName());            }        } catch (InterruptedException e) {            e.printStackTrace();        }    }    /*    运行结果：可见线程（main线程 和 MyThread线程）在被挂起后，再次被运行是随机的    run=myThread    main=main    run=myThread    main=main    main=main    main=main    run=myThread    run=myThread    run=myThread    main=main    run=myThread    main=main    run=myThread    run=myThread    main=main    run=myThread    run=myThread    main=main    main=main    main=main     */}

例子3（线程 run() 方法的执行和 程序中代码顺序无关）：

/** * @ClassName MyThread2 * @Description 测试start()代码顺序和线程被调用的顺序 */public class MyThread2 extends Thread {    private int i;    public MyThread2(int i) {        super();        this.i = i;    }    @Override    public void run() {        System.out.println(i);    }}

/** * @ClassName Test2 * @Description */public class Test2 {    public static void main(String[] args) {        MyThread2 my1 = new MyThread2(1);        MyThread2 my2 = new MyThread2(2);        MyThread2 my3 = new MyThread2(3);        MyThread2 my4 = new MyThread2(4);        MyThread2 my5 = new MyThread2(5);        MyThread2 my6 = new MyThread2(6);        MyThread2 my7 = new MyThread2(7);        MyThread2 my8 = new MyThread2(8);        MyThread2 my9 = new MyThread2(9);        MyThread2 my10 = new MyThread2(10);        my1.start();        my2.start();        my3.start();        my4.start();        my5.start();        my6.start();        my7.start();        my8.start();        my9.start();        my10.start();    }    /*    运行结果：可以看出，线程被调用的顺序并不是按照 start()方法的代码顺序来的    2    3    6    7    10    1    5    9    4    8     */}