java线程总结（1/5）

前言

闲来无事正值面试，看面试中有线程之问题，特此总结一番。

正文

一.线程和进程的区别：
1.每个进程都有独立的代码和数据空间(进程上下文)，进程间的切换会有较大的开销。
2.线程可以看成时轻量级的进程，同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换的开销小。
3.线程和进程最根本的区别在于：进程作为资源分配的单位，线程是调度和执行的单位。

二.多进程: 在操作系统中能同时运行多个任务(程序)。
三.多线程: 在同一应用程序中有多个顺序流同时执行。

四.概念：

1.线程是进程的一部分，所以线程有的时候被称为是轻权进程或者轻量级进程。
2.一个没有线程的进程是可以被看作单线程的，如果一个进程内拥有多个进程，进程的执行过程不是一条线（线程）的，而是多条线（线程）共同完成的。
3.系统在运行的时候会为每个进程分配不同的内存区域，但是不会为线程分配内存（线程所使用的资源是它所属的进程的资源），线程组只能共享资源。那就是 说，出了CPU之外（线程在运行的时候要占用CPU资源），计算机内部的软硬件资源的分配与线程无关，线程只能共享它所属进程的资源。

五.进程与程序的区别：
1.程序是一组指令的集合，它是静态的实体，没有执行的含义。而进程是一个动态的实体，有自己的生命周期。

2.一般说来，一个进程肯定与一个程序相对应，并且只有一个，但是一个程序可以有多个进程，或者一个进程都没有。

3.除此之外，进程还有并发性和交往性。简单地说，进程是程序的一部分，程序运行的时候会产生进程。

六.JAVA中如何实现多线程：
1.通过继承Thread类实现多线程：
a.在Java中负责线程的这个功能的是Java.lang.Thread 这个类
b.可以通过创建Thread 的实例来创建新的线程。
c.每个线程都是通过某个特定Thread对象所对应的方法run( )来完成其操作的，方法run( )称为线程体。
d.通过调用Thead类的start()方法来启动一个线程。

这种方式的缺点：那就是如果我们的类已经从一个类继承（如小程序必须继承自 Applet 类），则无法再继承Thread 类。

package com.horizon.action;

public class TestThread extends Thread {

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

    public static void main(String[] args) {
        TestThread t1 = new TestThread();
        t1.start();
        TestThread t2 = new TestThread();
        t2.start();
    }

}

2.通过Runnable接口实现多线程：
优点：可以同时实现继承。实现Runnable接口方式要通用一些。

package com.horizon.action;

public class TestThread2 implements Runnable {

    int threadId;

    public TestThread2(int id) {
        super();
        this.threadId = id;
    }

    public static void main(String[] args) {
        Thread thread1 = new Thread(new TestThread2(1));
        thread1.start();
        Thread thread2 = new Thread(new TestThread2(2));
        thread2.start();
    }

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

七.线程状态和sleep/yield/join/stop/destroy方法（）

新生状态：
用new关键字和Thread类或其子类建立一个线程对象后，该线程对象就处于新生状态。处于新生状态的线程有自己的内存空间，通过调用start方法进入就绪状态（runnable）。
就绪状态（runnable）：
处于就绪状态的线程已经具备了运行条件，但还没有分配到CPU，处于线程就绪队列，等待系统为其分配CPU。等待状态并不是执行状态，当系统选定一个等待执行的Thread对象后，它就会从等待执行状态进入执行状态，系统挑选的动作称之为“cpu调度”。一旦获得CPU，线程就进入运行状态并自动调用自己的run方法。
运行状态：
在运行状态的线程执行自己的run方法中代码，直到调用其他方法而终止、或等待某资源而阻塞或完成任务而死亡。如果在给定的时间片内没有执行结束，就会被系统给换下来回到等待执行状态。
死亡状态：
死亡状态是线程生命周期中的最后一个阶段。

线程死亡的原因有两个：一个是正常运行的线程完成了它的全部工作；另一个是线程被强制性地终止，如(通过执行stop或destroy方法来终止一个线程{不推荐使用这两个方法。前者会产生异常，后者是强制终止，不会释放锁，另外程序报错也会导致锁的释放}) 
Method stop() & destroy() in the class Thread is   deprecated。

当一个线程进入死亡状态以后，就不能再回到其它状态了。 让一个Thread对象重新执行一次的唯一方法，就是重新产生一个Thread对象。

A.终止线程的典型方法(重要)：

package com.horizon.action;

public class TestThreadCiycle implements Runnable {

    String name;
    boolean live = true;

    public TestThreadCiycle(String name) {
        super();
        this.name = name;
    }

    public void run() {
        int i = 0;
        while (live) {
            System.out.println(name + (i++));
        }
    }

    public void terminate() {
        live = false;
    }

    public static void main(String[] args) {
        TestThreadCiycle ttc = new TestThreadCiycle("线程A:");
        Thread t1 = new Thread(ttc); // 新生状态
        t1.start(); // 就绪状态
        for (int i = 0; i < 1000; i++) {
            System.out.println(i);
        }
        ttc.terminate();
        System.out.println("ttc stop!");
    }

}

阻塞状态：
处于运行状态的线程在某些情况下，如执行了sleep（睡眠）方法，或等待I/O设备等资源，将让出CPU并暂时停止自己的运行，进入阻塞状态。
1. 在阻塞状态的线程不能进入就绪队列。只有当引起阻塞的原因消除时，如睡眠时间已到，或等待的I/O设备空闲下来，线程便转入就绪状态，重新到就绪队列中排队等待，被系统选中后从原来停止的位置开始继续运行。

有三种方法可以暂停Threads执行：
1. sleep方法：Sleep时别的线程也不可以访问锁定对象。
2. yield方法: 让出CPU的使用权，从运行态直接进入就绪态。让CPU重新挑选哪一个线程进入运行状态。
3. join方法: 当某个线程等待另一个线程执行结束后，才继续执行时，使用join方法。使调用该方法的线程在此之前执行完毕，也就是等待调用该方法的线程执行完毕后再往下继续执行。

package com.horizon.action;

public class TestThreadState {

    public static void main(String[] args) {
        // 使用继承方式实现多线程
//         StateThread thread1 = new StateThread();
//         thread1.start();
//         StateThread thread2 = new StateThread();
//         thread2.start();

        System.out.println("爸爸和儿子买烟故事");

        Thread father = new Thread(new FatherThread());
        father.start();
    }

}

class StateThread extends Thread {
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(this.getName() + ":" + i);
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Thread.yield();
        }
    }
}

class FatherThread implements Runnable {
    public void run() {
        System.out.println("爸爸想抽烟，发现烟抽完了");
        System.out.println("爸爸让儿子去买包红塔山");
        Thread son = new Thread(new SonThread());
        son.start();
        System.out.println("爸爸等儿子买烟回来");
        try {
            son.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("爸爸出门去找儿子跑哪去了");
            System.exit(1);// 结束JVM。如果是0则表示正常结束；如果是非0则表示非正常结束
        }
        System.out.println("爸爸高兴的接过烟开始抽，并把零钱给了儿子");
    }
}

class SonThread implements Runnable {
    public void run() {
        System.out.println("儿子出门去买烟");
        System.out.println("儿子买烟需要10分钟");
        try {
            for (int i = 1; i <= 10; i++) {
                System.out.println("第" + i + "分钟");
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("儿子买烟回来了");
    }
}