线程

　　线程是系统调用的最基本单位，多个线程组成进程。电脑中真正执行的线程，我们看到的是进程。

一：定义

　　进程的定义：进程是由一个或多个线程组成。

　　线程的定义：CPU调度和分配的最基本单位。

二：多线程

　　定义：在同一个进程中，同时运行多个线程来完成不同的工作。

　　原理：CPU不能同时运行多个线程，在一个时间点系统只能运行一个线程。但是在CPU之中线程之间是高速切换的，人是感觉不到的。所以直观上的感觉是同步执行的。

三：多线程的优点

　　01.充分利用CPU的资源 　　02.提升用户的体验

四：代码实现多线程

　　实现步骤：必须继承Thread 或者实现Runnable接口，然后重写run() 方法，在main方法中实例化Thread对象，调用线程类的start()方法启动线程；

五：线程的分类

       用户线程： User Thread :默认我们创建的线程就是！
       守护线程： Daemon Thread: 为其他线程提供服务的！ GC线程需要我们手动，setDaemon(true)方法设置。

　　注意事项：
　　　　01.默认我们创建的线程就是用户线程！通过Thread类中的setDaemon（true）可以转换成守护线程。
　　　　02.只要有用户线程存在，程序就不会终止，所有的用户线程都执行完毕了， 程序会结束所有的守护线程！JVM停止工作！
　　　　03.setDaemon（true）必须在start（）之前
　　　　04.守护线程永远不要访问资源！！！因为守护线程随时都可能销毁！

public class DaemonThread implements Runnable {

    @Override
    public void run() {
        BufferedWriter bw = null;
        Writer out = null;
        File file = new File("e:/heihei.txt");
        try {
            System.out.println("进入了 run()");
            Thread.sleep(1000); // 保证main先执行完毕
            // 获取输出流对象
            out = new FileWriter(file);
            bw = new BufferedWriter(out);
            bw.write("守护线程不可能写进去内容！！看不到我！");
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            try {
                bw.close();
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Thread thread = new Thread(new DaemonThread(), "守护线程");
        // 变成 守护线程
        // thread.setDaemon(true);
        thread.start();
        System.out.println("用户线程===》main结束");
    }
}

　　01.继承Thread类

/**
 * 自己定义的多线程类
 * 
 * 01.必须继承Thread
 * 02.然后重写run() ====>普通的方法
 * 03.启动线程调用线程类的start()
 */
public class MyThread extends Thread {

    /**
     * 重写了Thread类中的 run()
     */
    @Override
    public void run() {
        for (int i = 1; i <= 20; i++) {
            System.out.println(Thread.currentThread().getName() + "在执行==》" + i);
        }
    }

    public static void main(String[] args) {
        // 创建出来了2个线程对象 然后分别执行 run（）
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        // 分别给两个线程 设置名字
        t1.setName("线程1");
        t2.setName("线程2");
        /*
         * t1.run(); t2.run(); 直接调用run()其实就是执行普通方法，那么第一个run（）没执行完毕，第二个无法执行
         */
        // 真正的启动线程,但是线程没有执行！ 明明是调用的start(),却是显示的run()方法内容！
        // 线程的真正执行是run()
        t1.start();
        t2.start();

    }

}

　　02.实现Runnable接口

public class MyRunnable implements Runnable {
    /**
     * 重写了Runnable类中的 run()
     */
    @Override
    public void run() {
        for (int i = 1; i <= 20; i++) {
            System.out.println(Thread.currentThread().getName() + "在执行==》" + i);
        }
    }

    public static void main(String[] args) {
        // 创建两个线程对象
        Thread t1 = new Thread(new MyRunnable(), "线程1");
        Thread t2 = new Thread(new MyRunnable(), "线程2");
        // 启动线程
        t1.start();
        t2.start();
    }

}

　　03.实现Callable接口

（一）线程的生命周期　　 

　　　01.新生状态　  　 MyThread t1=new MyThread(); 　
　　　　　　　　 　　　Thread t2 = new Thread(new RunnableImp());

　　　02.就绪状态   　　调用start（）方法，线程就绪，等待分配CPU资源。

　　　03.运行状态　   　CPU分配时间片给run方法，线程开始执行run方法线程体代码

　　    04.阻塞状态 　　 sleep() , 休眠（不释放资源）　wait() ,等待（释放系统资源）    yield() , 礼让（静态方法，不一定成功。）                                                                                join()，强制执行至结束线程体代码，才会释放资源。

　　　05.死亡状态　　 run()执行完毕正常死亡 ，或者是run()执行过程中，出现了异常（java.lang.IllegalThreadStateException）终止运行，线程死亡。

（二）关于start（）方法，与run（）方法的区别：

　　　01.start方法是是Thread中的方法，调用后会启动线程至就绪状态，底层会调用run方法。继承Runnable接口没有该方法。

　　　02.run方法是普通的方法，调用run方法是调用普通方法，不会启动多线程。方法体称之为线程体，当CPU分配时间片给线程时，线程才处于运行状态。

（三）线程的调度方法

　　01.设置线程的优先级（有一定的概率调节线程的抢占资源的能力）

/**
 * 
 * 线程的优先级 Priority
 * 默认值是5
 * 取值范围是  1-10
 * 优先级越高 代表获取CPU资源的概率越高！ 并不代表一定高或者一定执行！
 * 
 */
public class PriorityThread implements Runnable {
    @Override
    public void run() {
        for (int i = 1; i <= 20; i++) {
            System.out
                    .println(Thread.currentThread().getName() + "======>" + i);
        }
    }

    public static void main(String[] args) {
        // 创建两个线程类对象
        Thread t1 = new Thread(new PriorityThread(), "线程1");
        Thread t2 = new Thread(new PriorityThread(), "线程2");
        System.out.println("t1默认的优先级===》" + t1.getPriority());
        System.out.println("t2默认的优先级===》" + t2.getPriority());
        // 设置t2的优先级为10 只是一种概率问题 并不能保证 每次都是t2先执行
        t2.setPriority(10);
        // 启动线程
        t1.start();
        t2.start();
    }
}

　　02.强制加入join（）方法（一定会先执行完毕调用方法的线程）

/**
 * 2.Join   加入新线程
 *  让新的线程加入进来，新线程执行完毕之后，其他线程才能执行！
 */
public class JoinThread implements Runnable {

    @Override
    public void run() {
        for (int i = 1; i <= 50; i++) {
            System.out
                    .println(Thread.currentThread().getName() + "======>" + i);
        }
    }

    // 测试方法
    public static void main(String[] args) {

        Thread t1 = new Thread(new JoinThread(), "新线程1");
        // 启动新线程
        t1.start();
        for (int i = 1; i <= 20; i++) { // 主线程的输出
            System.out
                    .println(Thread.currentThread().getName() + "======>" + i);
            if (i == 5) {
                try {
                    System.out.println("T1线程 强制 加入");
                    t1.join(); // 阻止main线程
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

   　03.sleep(long  ms)  Thread类中静态方法，会抛出InterruptedException异常 　

/**
 * Sleep  线程的休眠     不会释放资源
 * 
 * sleep(long  ms)  Thread类中方法 
       01.线程的休眠，会占着CPU资源不放！其他的线程都无法获取CPU资源！必须等待！
       02.long ms指的是在多长时间之后，进入 就绪状态
     
   wait()是Object类中的方法！
            线程wait()的时候，会释放占用的CPU资源！
        01.其他的线程无需等待！
        02.必须使用notify唤醒才能进入 就绪状态
 */
public class SleepThread implements Runnable {
    @Override
    public void run() {
        for (int i = 1; i <= 20; i++) {
            System.out
                    .println(Thread.currentThread().getName() + "======>" + i);
            try {
                Thread.sleep(1000);// 线程休眠一秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        // 创建线程类对象
        Thread t = new Thread(new SleepThread(), "休眠的线程");
        // 线程启动
        t.start();
    }
}

  　04.sleep 与 wait 方法的区别

　　　　sleep(long ms) Thread类中方法 （ms表示等待的毫秒数）
　　　　　　01.线程的休眠，会占着CPU资源不放，其他的线程都无法获取CPU资源。必须等待！
　　　　　　02.long ms指的是在多长时间之后，进入就绪状态；

　　　　wait()是Object类中的方法！　线程wait()的时候，会释放占用的CPU资源！
　　　　　　01.其他的线程无需等待！
　　　　　　02.必须使用notify（）唤醒才能进入就绪状态；

　　05.yield();礼让方法（不一定有效）

public class YieldThread implements Runnable {

    @Override
    public void run() {
        for (int i = 1; i <= 50; i++) {
            System.out
                    .println(Thread.currentThread().getName() + "======>" + i);
        }
    }

    public static void main(String[] args) {
        // 创建线程对象
        Thread t = new Thread(new YieldThread(), "老幼病残线程");
        // 启动线程
        t.start();
        for (int i = 1; i <= 50; i++) {
            System.out
                    .println(Thread.currentThread().getName() + "======>" + i);
            if (i % 5 == 0) {
                System.out.println("======main开始礼让了======");
                Thread.currentThread().yield(); // 礼让
            }
        }
    }
}

　　06.设置中断状态。（只是一种标签，不影响线程的运行）

/**
 * 设置线程的 中断状态   Interrupt
    01.interrupt :      只是设置线程的中断状态，不是终止线程！ 线程还会继续执行！
    02.isInterrupted:来判断线程是否是 中断状态！
    03.interrupted：清除中断状态    interrupted();
    04.执行了wait或者sleep，会默认清除中断状态
 */
public class InterruptThread implements Runnable {
    @Override
    public void run() {
        // 判断线程是否是中断状态
        if (Thread.currentThread().isInterrupted()) {
            System.out.println("当前线程是 中断状态！");
        } else {
            for (int i = 1; i <= 50; i++) {
                System.out.println("线程的状态是===》"
                        + Thread.currentThread().isInterrupted());
                System.out.println(Thread.currentThread().getName() + "======>"
                        + i);
                if (i == 25) {
                    Thread.currentThread().interrupt(); // 线程的中断状态
                }
                if (i == 40) {
                    Thread.currentThread().interrupted(); // 清除 线程的中断状态
                }
            }
        }
    }

    public static void main(String[] args) {
        // 创建线程对象
        Thread t = new Thread(new InterruptThread(), "中断线程");
        // 启动线程
        t.start();
    }

}