线程的3种实现方式和线程生命周期

1.进程:系统进行资源分配和调用独立单元.每个进程都有自己独立内存空间和系统资源.
        (正在运行的程序)
        CPU时间片:进程中独立内存空间和系统资源.

2.线程:是进程中一条执行线路,每个线程都要执行一个任务.线程是共享进程中系统资源和内存空间.
        同一个进程中多个线程是竟争关系,互抢资源.

3.进程与线程的关系:一个进程可以1个到多个线程,但是一个线程只能属于一个进程.

4.实现线程:
    4.1:继承Thread类,重写run().
        eg:/**
 * 线程类
 * @author sx
 * @version 2019年12月4日
 */
public class MyThread extends Thread{
    /**
     * 任务方法
     */
    @Override
    public void run() {
        for (int i = 1; i <=10; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

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

4.2:实现Runnable接口,实现run()
    eg:/**
 * 任务类
 * @author sx
 * @version 2019年12月4日
 */
public class MyRunnable implements Runnable{
    /**
     * 任务方法
     */
    @Override
    public void run() {
        for (int i = 1; i <=10; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

public static void main(String[] args) {
        //创建任务对象
        MyRunnable r1=new MyRunnable();
        MyRunnable r2=new MyRunnable();
        
        //将任务对象创建线程对象
        Thread t1=new Thread(r1,"线程A");
        Thread t2=new Thread(r2,"线程B");
        
        //启动线程
        t1.start();
        t2.start();
    }
4.3:(一般不用)实现Callable接口,重写call()方法.

5.继承Thread VS 实现Runnable接口的方式实现多线程
    5.1:代码简洁性:继承thread方式实现多线程,代码更简洁; 实现Runnable接口的方式实现多线                        程代码较麻烦点.
    5.2:可扩展性:继承thread方式的线程类不能再继承其他的类,只能实现其他接口,可扩展性较                    差;实现Runnable接口的任务类还可以继承其他的类,实现其他的接口,可扩展性                    较好.
    5.3:资源的共享性:继承thread方式实现多个线程执行同一任务,只能将这个任务资源定为静态                        的,可这样一来,虚内存,所以继承thread方式资源的共享性较差;实现                            Runnable接口的方式实现多个线程执行同一任务,只需要这多个线程共用一个任务对象就可以,所以实现Runnable接口的方式资源的共享性较好.

6.给线程取名:
    6.1:用系统默认分配的名称
    6.2:给线程取名:线程对象.setName("线程名");
    6.3:用构造方法给线程取名:
        /**
     * 用构造方法给线程取名
     * @param name
     */
    public MyThread(String name) {
        super(name);
    }

7.线程休眠:暂停当前的线程,让其在休眠时间内不参加资源的抢夺.
    语法:线程对象.sleep(毫秒); 
        Thread.sleep(毫秒);
    eg:public static void main(String[] args) throws InterruptedException {
        for (int i = 3; i >0; i--) {
            System.out.println(i);
            //让当前线程休眠一秒现输出
            Thread.sleep(5000);
        }
    }

8.线程优先级:优先级越高的线程抢占资源的概率越高,不一定能抢到;优先级越低的线程抢占资源的概率越低,但不一定能抢不到.   等级有1-10  
最低1  中间5  最大10
        语法:在启动线程之前设置线程优先级:线程对象.setPriority(int newPriority)
        public static void main(String[] args) {
        //创建两个线程对象
        MyThread t1=new MyThread();
        MyThread t2=new MyThread();
        
        //设置线程的名称
        t1.setName("线程A");
        t2.setName("线程B");
        
        //设置线程优先级
        t1.setPriority(Thread.MIN_PRIORITY);
        t2.setPriority(Thread.MAX_PRIORITY);
        
        //启动线程
        t1.start();
        t2.start();
    }

9.线程合并:让两条或以上的线程合并为一条线程,合并过来的线程优先执行完,再执行本来的线程.
    语法:线程对象.join();
    9.1:子线程合并到主线程中:
        eg:public static void main(String[] args) throws InterruptedException {
        //创建子线程
        MyThread1 t1=new MyThread1();
        //给线程取名
        t1.setName("子线程");
        //启动子线程
        t1.start();
        
        for (int i = 1; i <=100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
            //当主线程运行到10时候,让子线程合并过来
            if (i==10) {
                t1.join();
            }
        }
    }

    9.2:子线程A合并到子线程B中
        eg:public class MyThread2 extends Thread{
    //声明线程对象,方便传值
    Thread t;
    
    /**
     * 任务方法
     */
    @Override
    public void run() {
        for (int i = 1; i <=100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
            //当子线程B运行10时候,让子线程A合并过来
            if (i==10&&Thread.currentThread().getName().equals("子线程B")) {
                try {
                    t.join();//让子线程A合并过来
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
}

            public static void main(String[] args) throws InterruptedException {
        //创建子线程
        MyThread2 t1=new MyThread2();
        MyThread2 t2=new MyThread2();
        //给线程取名
        t1.setName("子线程A");
        t2.setName("子线程B");
        
        //调用子线程B的属性赋值
        t2.t=t1;
        
        //启动子线程
        t1.start();
        t2.start();
    }

10.线程礼让:让当前的线程暂停一下,再执行.
        语法:线程对象.yield();
            Thread.yield();
    eg:/**
 * 线程类
 * @author sx
 * @version 2019年12月4日
 */
public class MyThread extends Thread{
    /**
     * 任务方法
     */
    @Override
    public void run() {
        for (int i = 1; i <=100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
            //线程B每输出一次就礼让一次A
            if (Thread.currentThread().getName().equals("子线程B")) {
                Thread.yield();
            }
        }
    }
}

11.守护线程(后台线程,精灵线程):守护线程用来守护非守护线程,如果所有非守护线程死亡了,守护线程自动死亡.eg:垃圾回收线程就是守护线程.
        语法:必须要在线程启动之前设置:线程对象.setDaemon(true); 
        eg:public static void main(String[] args) {
        //创建线程对象
        MyThread t1=new MyThread();
        //设置线程名称 
        t1.setName("守护线程");
        //设置当前的子线程为守护线程
        t1.setDaemon(true);
        //启动线程
        t1.start();
        
        for (int i = 1; i <=100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }

12.线程生命周期
    12.1:新建状态(新生状态):当线程刚被创建时,线程就处于新建状态.
    12.2:就绪状态:当线程调用start()后或阻塞线程的时间到了或被唤醒了,它就处理就绪状态.
    12.3:运行状态:当就绪状态的线程抢到CPU时间片,调用run(),它就处理运行状态.
    12.4:阻塞状态:当运行的线程调用sleep(),wait()方法时,线程就处于阻塞.
    12.5:死亡状态:当线程的任务执行完了或当线程异常终止了,再无法运行时就叫死亡状态.