Java多线程详解与晋级（一）

Java线程的概念与原理

一、操作系统中线程和进程的概念

进程是指操作系统内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。

线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如java.exe进程中可以运行很多线程。线程总是属于某个进程，进程中的多个线程共享进程的内存。

简单来说，进程就是一个应用程序在操作系统上的一次执行过程，而线程是进程中的一次执行流程，进程包含多个线程在运行。

二、Java的线程

Thread类的实例只是一个对象，像Java中的其他任何一个对象一样，生死与堆上。

需要注意的，由于每个线程正在执行的方法可能不同，因此每个线程都会有一个自己的Java栈，互不干扰。

三、Java线程的创建与启动

(1) 继承Thread类

方式1 - 继承Thread类，让该类作为Thread线程体系中的一员。从继承的本质来说，不建议使用这种方法。

class SubThread extends  Thread {
    @Override
    public void run() {
        // ...代码
    }
}
SubThread sub = new SubThread();
sub.start(); // 启动线程

方式2 - 继承自Thread的匿名类，同样不建议使用

// 继承自Thread的局部匿名类
new Thread() {
    @Override
    public void run() {
        // 代码
    }
}.start();

(2) 实现Runnable接口

方式1

class SubThread implements  Runnable {
    @Override
    public void run() {
        // ...代码
    }
}
Thread t = new Thread(new SubThread());
t.start(); // 启动线程

方式2

new Thread(new Runnable() {
    @Override
    public void run() {
        // 代码
    }
}).start();

(3) 即继承Thread类，又实现Rrunnable接口

new Thread(new Runnable() {
    @Override
    public void run() {
        // 代码
        System.out.println("runnable run");
    }
}) {
    @Override
    public void run() {
        // 代码
        System.out.println("thread run");
    }
}.start();
// 结果 thread run

(4) 启动线程

想要启动线程就调用Thread对象上的start()方法，而不是run()方法。

在调用start()方法之前，线程还处于新生状态中，新生是指有一个Thread对象，但还没有一个真正的线程。

在调用start()方法之后，真正启动了一个线程（也同时创建了自己的栈），该线程状态从新生转为可运行状态，当该线程获取执行机会时，其目标run()方法将会运行。

四、线程的注意事项

1. 线程的名字，一个运行中的线程总是有名字的，名字有两个来源，一个是虚拟机自己给的名字，一个是你自己的定的名字。在没有指定线程名字的情况下，虚拟机总会为线程指定名字，并且主线程的名字总是mian，非主线程的名字为Thread-x。

   指定线程名99：线程99        // 通过Thrad的构造方法为线程赋予名称
   默认线程名：main
   默认线程名：Thread-0

2. 获取当前线程对象的方法是：Thread.currentThread();，获取名字的方法是：Thread.currentThread().getName();
3. 在下面的代码中，只能保证：每个线程都将启动，每个线程都将运行直到完成。一系列线程以某种顺序启动并不意味着将按该顺序执行。对于任何一组启动的线程来说，调度程序不能保证其执行次序，持续时间也无法保证。

   new Thread(new Runnable() {
       @Override
       public void run() {
           // 代码
       }
   }).start();
   
   new Thread(new Runnable() {
       @Override
       public void run() {
           // 代码
       }
   }).start();

4. 当线程目标run()方法结束时该线程完成。
5. 一旦线程启动，它就永远不能再重新启动。只有一个新的线程可以被启动，并且只能一次。一个可运行的线程或死线程可以被重新启动。
6. 线程的调度是JVM的一部分，在一个CPU的机器上上，实际上一次只能运行一个线程。一次只有一个线程栈执行。JVM线程调度程序决定实际运行哪个处于可运行状态的线程。

五、线程状态的转换

线程的状态转换是线程控制的基础。

线程状态总的可分为五大状态：分别是新生、死亡、可运行、运行、等待/阻塞。用一个图来描述如下：

1. 新生(new)：新创建了一个线程对象。
2. 可运行(runnable)：线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu 的使用权 。
3. 运行(running)：可运行状态(runnable)的线程获得了cpu 时间片（timeslice） ，执行程序代码。
4. 阻塞(block)：阻塞状态是指线程因为某种原因放弃了cpu 使用权，也即让出了cpu timeslice，暂时停止运行。直到线程进入可运行(runnable)状态，才有机会再次获得cpu timeslice 转到运行(running)状态。阻塞的情况分三种：
   

   (一). 等待阻塞：运行(running)的线程执行o.wait()方法，JVM会把该线程放入等待队列(waitting queue)中。

   (二). 同步阻塞：运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。

   (三). 其他阻塞：运行(running)的线程执行Thread.sleep(long ms)或t.join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入可运行(runnable)状态。

5. 死亡(dead)：线程run()、main() 方法执行结束，或者因异常退出了run()方法，则该线程结束生命周期。死亡的线程不可再次复生。

值得注意的：

1. 当调用obj.wait()方法时，会当前线程等待，而当前线程必须拥有锁（这不是废话么），此方法会导致自身的休眠（会释放掉此线程拥有的锁），并把自身（线程）放置到等待队列中。当此线程被唤醒时，会从对象的等待集中删除本线程，并重新进行线程调度。然后，该线程以常规方式与其他线程竞争，以获得在该对象上同步的权利；一旦获得对该对象的控制权，该对象上的所有其同步声明都将被恢复到以前的状态，这就是调用 wait 方法时的情况。然后，本线程从
   wait 方法的调用中返回。所以，从 wait 方法返回时，该对象和本线程的同步状态与调用 wait 方法时的情况完全相同。
2. 更应该注意的（很多初学者都会犯得错误），把wait()方法放在if()中，这样操作可能会导致安全问题，我们应该不断地该线程被提醒的条件进行测试，如果不满足该条件，则继续等待，换句话说，等待应该总是发生在循环中，如下面的示例：

   synchronized (obj) {
        while (<condition does not hold>)
        obj.wait(timeout);
        // Perform action appropriate to condition
     }

3. Thread.sleep();方法不会释放掉本线程所拥有的锁。同时，线程睡眠是帮助所有线程获得运行机会的最好方法；线程苏醒时，会回到可运行状态而不是运行状态