扩展Java.lang.Thread类
实现java.lang.Runnable接口
Thread和Runnable的区别
线程状态转换
线程调度

进程：每个进程都有独立的代码和数据空间(进程上下文)，进程间的切换比较大，一个进行包含1-n个线程。(进程是资源分配的最小单位)
线程：同一类线程共享代码和数据空间，每个线程都有独立的运行栈和程序计数器(PC)，线程切换开销小。(线程是CPU调度的最小单位)
线程和进程的五个阶段：创建、就绪、运行、阻塞、停止。
多进程是指操作系统同事运行多个任务(程序)。
多线程是指同一程序中有多个顺序流在执行。

在Java中要想实现多线程，有两种手段，一个是继承Thread类，一个是实现Runnable接口，(其实还有第三种，实现Callable接口，并与Future、线程池结合使用)。

扩展java.lang.Thread类

public class ThreadTest extends Thread{
    private Strign name;
    public ThreadTest(String name){
        this.name = name;
    }
    @Override
    public void run(){
        for(int i=0;i<5;i++){
            System.out.println(name+"运行："+i);
            try{
                sleep((int)Math.random() * 10);
            }catch(InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}
public class Main{
    public static void main(String[]args){
        ThreadTest xc1 = new ThreadTest("A");
        ThreadTest xc2 = new ThreadTest("B");
        xc1.start();
        xc2.start();
    }
}

注意：start()方法的调用并不是立即执行多线程代码，而是使得该线程变成可运行状态(Runnable)，什么时候运行是操作系统决定的。
从执行结果来看，多线程程序是乱序执行。
因此，只有乱执行的代码才有必要设计多线程。

Thread.sleep()方法调用目的是不让当前线程独自霸占该进行所获取的CPU资源，以留出一定时间给其他线程执行的机会。
实际上所有的多线程代码执行顺序都是不确定的，每次执行的结果都是随机的。
但是start方法重复调用的话，会出现java.lang.IllegalThreadStateException异常。

ThreadTest xc1 = new ThreadTest("A");
ThreadTest xc2 = xc1;
xc1.start();
xc2.start();

输出：

Exception in thread "main" java.lang.IllegalThreadStateException
    at java.lang.Thread.start(Unknown Source)
    at com.multithread.learning.Main.main(Main.java:31)

实现java.lang.Runnable接口

采用Runnable也是非常常见的一种,我们只需要重写Run方法即可。

class Thread2 implements Runnable{  
    private String name;  

    public Thread2(String name) {  
        this.name=name;  
    }  

    @Override  
    public void run() {  
          for (int i = 0; i < 5; i++) {  
                System.out.println(name + "运行  :  " + i);  
                try {  
                    Thread.sleep((int) Math.random() * 10);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
    }  
}  
public class Main {  
    public static void main(String[] args) {  
        new Thread(new Thread2("C")).start();  
        new Thread(new Thread2("D")).start();  
    }  
}

说明：
run方法是多线程程序的一个约定，所有的多线程代码都在run方法里面，Thread类实际上是实现了Runnable接口的类。
在启动多线程的时候，需要先通过Thread类的构造方法,Thread(Runnable target)构造出对象，然后调用Thread对象的start()方法来运行多线程代码。
实际上所有的线程都是通过运行Thread的start方法来运行的，因此，不管是扩展Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。

Thread和Runnable的区别

如果一个类继承Thread，则不适合资源共享，如果实现了Runnable接口，很容易实现资源共享。
总结：
实现Runnable接口比继承Thread类所具有的优势：
- 适合多个相同的程序代码的线程去处理同一个资源
- 可以避免java中的单继承的限制
- 增加程序的健壮性，代码可以被多个线程共享，代码和数据独立
- 线程池只能放入实现Runnable或Callable类线程，不能直接放入继承Thread的类。
- main方法其实也是一个线程。
- java中每次程序启动至少启动两个线程，一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都启动了一个JVM，每个JVM就是在操作系统中启动了一个进程。

线程状态转换

如下：

新建状态(New)
就绪状态(Runnable)：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可用权，等待获取CPU的使用权。
运行状态(Running)：就绪状态的线程获取了CPU，执行程序代码。
阻塞状态(Blocked)：阻塞状态是因为线程因为某种原因放弃CPU使用权，停止运行。直到线程进入就绪状态，才有机会转到运行状态，阻塞情况分为三种：

(1)等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。
(2)同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，JVM就会把线程放入锁池中。
(3)其他阻塞：运行的线程执行sleep()方法或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态，当sleep()状态超时时、json()等待线程终结或者超时、或者I/O处理完毕时，线程重新载入就绪状态。(注意,sleep是不会释放持有的锁的)
5.死亡状态：线程执行完了或者因异常而退出了run()方法，该线程结束生命周期。

线程调度

线程的调度：
1.调整线程优先级：Java线程有优先级，优先级高的线程会获得较多的运行机会。
Java线程的优先级用整数表示，取值范围是1~10，Thread类有以下三个静态常量：

static int MAX_PRIORITY：线程可以具有的最高优先级，取值为10
static int MIN_PRIORITY：线程可以具有的最低优先级，取值为1
static int NORM_PRIORITY：取值为5

Thread类的setPriority()和getPriority()方法分别是用来设置和获取线程的优先级。
每个线程都有默认的优先级，主线程的默认优先级为Thread.NORM_PRIORITY。线程的优先级有继承关系，比如A线程中创建了B线程，那么B将和A具有相同的优先级，JVM提供了10线程优先级，但与常见的操作系统不能很好的映射，如果希望程序移植到各个操作系统，应该仅仅使用Thread类有一下三个静态常量作为优先级，这样保证同样的优先级采用了同样的调度方式。
2. 线程睡眠：Thread.sleep(long millis)方法，是线程转到阻塞状态，millis参数设定的睡眠时间，当睡眠结束后，就转为就绪(Runnable)状态。sleep()平台移植性好。
3. 线程等待：Object类中的这个wait方法，导致当前的线程等待，直到其他线程调用此对象的notify()方法或者notifyAll()唤醒方法，这两个唤醒方法也是Object类中的方法，行为等价于调用wait(0)一样。
4. 线程让步：Thread.yield()方法，暂停当前正在执行的线程对象，把执行机会让给相同或者更高优先级的线程。
5. 线程加入：join方法，等待其他线程终止，在当前线程中调用另一个线程的join方法，则当前线程转入阻塞状态，直到另一个进程运行结束，当前线程再由阻塞转为就绪状态。
6. 线程唤醒：Object类中的notify()方法，唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程，选择是任意性的，并对实现做出决定时发生，线程通过调用其中一个wati方法，在对象的监视器上等待，直到当前线程档期此对象上的锁，才能继续执行被唤醒的线程，被唤醒的线程将以常规的方式与该对象上主动同步的其他所有线程进行竞争，例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。类似的方法还有一个notifyAll方法，唤醒此对象监视器上等待的所有线程。
注意：Thread中suspend和resume这俩方法已经在JDK1.5中废除了，因为死锁倾向！

Java多线程编程学习

扩展java.lang.Thread类

实现java.lang.Runnable接口

Thread和Runnable的区别

线程状态转换

线程调度

猜你喜欢