线程第一章

使用多线程的情况：

1. 一个程序同时执行多个任务；
2. 单线程可以完成，单多线程效率高。

并发原理：
线程调度将时间划分为很多时间片段，尽可能均匀分配给每一个线程，获取时间片段的线程将被CPU运行，其余线程全部等待。微观上是“走走停停”，宏观上都在运行，这种现象叫“并发”。

线程调度
给线程分配时间片段

线程的生命周期（摘自：http://blog.csdn.net/mayouarebest8621/article/details/6755036）

线程是一个动态执行的过程，它也有一个从产生到死亡的过程。

生命周期的五种状态

新建（new Thread）
当创建Thread类的一个实例（对象）时，此线程进入新建状态（未被启动）。
例如：Thread t1=new Thread();

就绪（runnable）相当于注册
线程已经被启动，正在等待被分配给CPU时间片，也就是说此时线程正在就绪队列中排队等候得到CPU资源。例如：t1.start();

运行（running）
线程获得CPU资源正在执行任务（run()方法），此时除非此线程自动放弃CPU资源或者有优先级更高的线程进入，线程将一直运行到结束。

死亡（dead）将被GC回收
当线程执行完毕或被其它线程杀死，线程就进入死亡状态，这时线程不可能再进入就绪状态等待执行。

自然终止：正常运行run()方法后终止

异常终止：调用stop()方法让一个线程终止运行

堵塞（blocked）不能运行，不能回到就绪状态
由于某种原因导致正在运行的线程让出CPU并暂停自己的执行，即进入堵塞状态。

正在睡眠：用sleep(long t) 方法可使线程进入睡眠方式。一个睡眠着的线程在指定的时间过去可进入就绪状态。

正在等待：调用wait()方法。（调用motify()方法回到就绪状态）

被另一个线程所阻塞：调用suspend()方法。（调用resume()方法恢复）

创建线程（New Thread）1

**同步运行：有先后顺序的运行方式
**异步运行：各干各的，多个线程并发运行的效果。

//代码示例
public class CreateAThread {
    public static void main(String[] args) {
        Thread t1 = new MyThread1();
        Thread t2 = new MyThread2();
        /**
         * start方法将线程纳入线程调度
         * 此时线程进入就绪(runable)状态，等待线程
         * 调度分配时间片段。
         */
        t1.start();
        t2.start();

    }

}
//过于局限，重用性太差
class MyThread1 extends Thread{
    public void run(){
        for(int i = 0; i < 1000; i++){
            System.out.println("你是谁啊");
        }
    }
}

class MyThread2 extends Thread{
    public void run(){
        for(int i = 0; i < 1000; i++){
            System.out.println("我是去年买了个表的");
        }
    }
}

解耦与耦合

耦合：强制绑定。
解耦：接触耦合关系。
线程就是线程，任务就是任务。
Spring框架
程序松散绑定

创建线程（New Thread）2

package day01;
/**
 * 介绍创建线程的第二种方法：定义线程体Runnable
 * @author Administrator
 *
 */
public class CreatedAThread_02 {

    public static void main(String[] args) {
        Runnable runn1 = new MyRunnable1();
        Runnable runn2 = new MyRunnable2();

        Thread t1 = new Thread(runn1);

        Thread t2 = new Thread(runn2);

        t1.start();
        t2.start();
    }

}
//灵活，重用性好，需要干的活直接实现接口
class MyRunnable1 implements Runnable{
    public void run(){
        for(int i = 0 ;i < 1000;i++){
            System.out.println("你丫谁啊");
        }
    }
}

class MyRunnable2 implements Runnable{
    public void run(){
        for(int i = 0 ;i < 1000;i++){
            System.out.println("老子去年买了表的");
        }
    }
}

温故知新：匿名内部类
故名思义，就是没有名字的内部类。
只能(需)使用一次。用于简化代码。

创建线程（New Thread）3

package day01;
/**使用匿名内部类的形式创建线程
 */
public class CreatedThread_03 {

    public static void main(String[] args) {
        //1
        Thread t1 = new Thread(){
            public void run(){
                for(int i = 0;i < 1000;i++){
                    System.out.println("你丫谁啊");
                }
            }
        };
        //2
        Runnable runn = new Runnable(){
            public void run(){
                for(int i = 0 ;i < 1000;i++){
                    System.out.println("老子查水表的");
                }
            }
        };
        Thread t2 = new Thread(runn);
        t1.start();
        t2.start();
    }
}