多线程的概念，如何创建以及线程状态。

多线程的概念

现代操作系统都可以执行多任务，即操作系统轮流让多个任务交替执行（在我们使用者看起来，像是在同时执行多个任务一样）。

进程

计算机中一个任务称为一个进程，一些进程内部还需要执行多个子任务，成为线程。比如我们在浏览网页的时候，网页上除了静态文字，还有动态广告等等。

一个进程可以包含一个或多个线程，但至少有一个线程。线程是操作系统调度的最小任务单位，该怎么调度就由操作系统完全决定。

实现多任务的方法

1.多进程模式：每个进程有只有一个线程；

2.多线程模式：一个进程有多个线程；

3.多进程+多线程模式：高复杂度。

多进程与多线程比较

1.创建进程的开销大于创建线程的开销；

2.进程间通信比线程间通信要慢；

3.多进程稳定性比多线程稳定性高。

Java的多线程

一个java程序实际上是一个jvm程序；jvm使用一个主线程来执行main方法；main方法中可以启动多个线程。

多线程具有的特点：

读写共享数据；

经常需要同步；

编程复杂度高，调试难度大。

如何创建新线程？

方法：两种

1.创建MyThread类，从Thread类派生，覆写run()方法，创建MyThread实例，调用start()方法。

public class MyThread estends Thread{
    public void run(){
        System.out.println();
    }
}

public class Main{
    public static void main(String[] args){
        Thread t = new MyThread();
        t.start();
    }
}

2.如果一个类已经从某个类派生，无法从Thread继承：实现Runnable接口，覆写run()方法，在main()方法中创建Runnable实例，创建Thread实例并传入Runnable实例，用Thread实例调用start()启动线程。

public class MyThread implements Runnable{
    @Override
    public void run(){
        System.out.printlv("run");
    }
}

public class Main{
    public static void main(String[] args){
        Runnable r = new MyThread();
        Thread t = new Thread(r);
        t.start();
    }
}

分析以下代码： 

public static void main(String[] args) throws InterruptedException {
        System.out.println("main线程开始打印");
        Thread.sleep(1000);
        Thread thread = new Thread(){
            public void run() {
                System.out.println("threa线程开始打印");
                System.out.println("threa线程结束打印");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        thread.start();
        System.out.println("main线程结束打印");
        Thread.sleep(1000);
}

我们只能确定会先打印出："main线程开始打印"至于，"main线程结束打印" 的位置，我们无法预先知道，因为线程如何调度是由操作系统决定的。当thrad调用的start()方法，就开启了main线程之外的线程。此时，两个线程开始同时运行。

注意点

1.直接调用run()方法是无效的；2.必须调用start()方法才能启动新线程

public class Thread implements Runnable{
    public synchronized void start(){
        start0();
    }
}
...
//jvm虚拟机内部的C代码实现
private native void start0();

要点：

1. java用Thread对象表示一个线程，通过调用start()方法来启动一个线程
2. 一个线程对象只能调用一次start()方法
3. 线程的执行代码是run()方法
4. 线程调度由操作系统决定，程序无法决定
5. Threa.sleep()方法可以把当前线程暂停一段时间。

 

线程的状态

创建 New，运行中 Runnable（调用start()方法），被阻塞 Blocked，等待 Waiting，计时等待 Timed Waiting，已终止Terminated。

线程终止原因：

1. 正常终止：run方法内执行到return语句
2. 意外终止：未捕获的异常导致的终止
3. 不推荐：对某个线程的Thread实例调用stop方法强制终止。

等待方法：join

class HelloThread extends Thread {
    String name;
    public HelloThread(String name){
        this.name = name;
    }
    @Override
    public void run(){
        System.out.println("Hello:"+name+"!");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
public class MyThread{
    public static void main(String[] args) throws InterruptedException {
        Thread myThread = new HelloThread("aaa");
        System.out.println("开始打印");
        myThread.start();
        //等待myThread线程执行结束
        myThread.join();
        System.out.println("结束打印");
    }
}

通过以上代码可以发现，在"开始打印"，以及"Hello:aaa!"，打印结束之后，等待了3秒，"结束打印"才会在控制台输出。

即main方法在等待新的线程结束，才继续执行。