多线程 一（概念）

1） 线程和进程的区别

进程是指一个内存中运行的应用程序，每个进程都有自己独立的内存空间，在一个进行中可以启动多个线程，windows的exe程序就是一个进程；

线程是指进程中的一个执行流程，线程总是属于一个线程，进程中的多个线程共享进程的内存；

2） 使用场景

多线程是并发执行的，而不是串行执行，如程序中有两个子系统需要并发执行，就可以使用多线程

并不是线程创建的越多，执行效率越高，当创建了太多的线程，cpu进行上下文切换的开销会比执行程序的时间要长，效率会降低；

3） 线程的生命周期

1、新状态：线程对象已经创建，还没有在其上调用start()方法。
2、可运行状态：当线程有资格运行，但调度程序还没有把它选定为运行线程时线程所处的状态。当start()方法调用时，线程首先进入可运行状态。在线程运行之后或者从阻塞、等待或睡眠状态回来后，也返回到可运行状态。
3、运行状态：线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一一种方式。
4、等待/阻塞/睡眠状态：这是线程有资格运行时它所处的状态。实际上这个三状态组合为一种，其共同点是：线程仍旧是活的，但是当前没有条件运行。换句话说，它是可运行的，但是如果某件事件出现，他可能返回到可运行状态。
5、死亡态：当线程的run()方法完成时就认为它死去。这个线程对象也许是活的，但是，它已经不是一个单独执行的线程。线程一旦死亡，就不能复生。 如果在一个死去的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常。

4） 线程的分类

用户线程和守护线程

当所有用户线程执行完毕的时候，JVM自动关闭；守护线程独立于JVM，是由操作系统或者用户自己创建的；

5） 执行线程的过程

a. new 一个线程对象，此时只是在内存中存在一个java对象，该线程处于新建状态

b. 调用start() 方法，该线程从新建状态变为可运行状态

c. 当该线程获取运行机会（cpu分配时间片）时，会运行run() 方法，run() 方法结束时线程完成

6） 线程启动次序

public class DoSomething implements Runnable {
    private String name;
    
    public DoSomething(String name) {
        super();
        this.name = name;
    }


    @Override
    public void run() {
        for (int i=0;i<100;i++) {
            System.out.println(this.name + ":" + i);
        }
    }


    public String getName() {
        return name;
    }


    public void setName(String name) {
        this.name = name;
    }
    
    public static void main(String[] args) {
        Thread t1 = new Thread(new DoSomething("thread1"));
        Thread t2 = new Thread(new DoSomething("thread2"));
        
        t1.start();
        t2.start();
    }

}

上面的代码只能保证：每个线程都将启动，每个线程都将运行知道完成；但是在代码中，按次序启动线程，不能保证线程将按这种次序执行，持续时间也无法保证；

线程调度是JVM的一部分，如果机器只有一个CPU，实际一次只能运行一个线程，JVM线程调度程序决定运行哪个处于可运行状态的线程；

7） 线程栈模型

程序在main方法调用method() 方法时，会把method方法放到栈顶，直到method方法执行返回，从栈A中取出，继续执行main方法。当执行到t.start()以后，程序多出一个分

支，栈A和栈B并行执行

8） 线程的状态切换

a. sleep方法：运行态-> 睡眠-> 可运行状态： 写在线程的run()方法中，表示当前线程执行时，进行睡眠，当线程执行到sleep()方法以后，则其他可运行态的线程获得了运行的机会，由JVM线程调度器决定运行其他的线程；

b. yield方法： 运行态->可运行态，让相同优先级的线程之间适当的轮转执行，但让步的当前线程可能会被线程调度器再度选中；

c. join方法：

public class TestJoin implements Runnable {

    @Override
    public void run() {
        for (int i=0;i<10;i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("sub thread");
        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        System.out.println("main start");
        
        Thread t = new Thread(new TestJoin());
        t.start();
        t.join();
        
        System.out.println("main end.");
    }

}

将线程B加入到线程A的尾部，在A执行完毕之前，B不能执行；代码中，main线程相当于线程B，t相当于线程A，运行结果：

main start
sub thread
sub thread
sub thread
sub thread
sub thread
sub thread
sub thread
sub thread
sub thread
sub thread
main end.

join保证当前线程停止执行（当前线程即在哪个线程内部调用了join），直到当前线程所加入的线程（线程t）完成为止；

9） 线程优先级

线程存在优先级，即1-10，JVM线程调度程序就是基于优先级的抢先调度机制，但是这个方法是不可靠的；