多线程

1.0  程序和进程　

　　　　【1】程序就是一堆静态的代码，存储在硬盘上。程序如果不运行，本质就是一个文件。

　　　　【2】程序一次运行产生进程，进程一直向前运行，直到进程结束。

　　　　【3】main线程和t1线程抢占CPU 执行。多线程在提高CPU利用率的同时，增加程序的复杂度。

2.0  多线程实现

　　　　Thread 类

public class MyThread extends Thread {

    @Override
    public void run() {
        System.out.println("我是多线程MyThread");
        for (int i = 0; i < 5; i++) {
            System.out.println("MyThread:" + i);
        }
    }
}

public class Test01 {
    public static void main(String[] args) {

        // main开始运行产生一个进程，该进程默认有个主(main)线程
        // 创建线程
        MyThread t1 = new MyThread();
        // 启动线程
        t1.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("main Thread:" + i);
        }

    }
}

　　实现Runnable接口

public class MyRun implements Runnable {

    @Override
    public void run() {
        System.out.println("我是MyRun");
        for (int i = 0; i < 5; i++) {
            System.out.println("my run:" + i);
        }
    }
}

public class Test02 {
    public static void main(String[] args) {
        
        MyRun run = new MyRun();
        Thread t1 = new Thread(run);
        t1.start();

        // main开始运行产生一个进程，该进程默认有个主(main)线程
        for (int i = 0; i < 5; i++) {
            System.out.println("main Thread:" + i);
        }
    }
}

 

3.0继承Thread和实现Runnable接口实现多线程的优缺点

　　　　[1] 继承Thread的线程类不能再继承其他类，实现Runnable接口的类还可以继承其他类。

　　　　[2] 实现Runnable接口的线程类，可以让多个线程共享线程实现类的资源。

总结:

　　　　多线程提高了cpu利用率，但程序的复杂度也随之增加。一旦线程开始执行，很难通过其他方式控制线程的轨迹。

　　　　多个线程抢占CPU导致线程的运行轨迹不确定。

4.0  线程的生命周期

【1】新生状态

用new关键字建立一个线程后，该线程对象就处于新生状态。

处于新生状态的线程有自己的内存空间，通过调用start()方法进入就绪状态。

 

【2】就绪状态

处于就绪状态线程具备了运行条件，但还没分配到CPU，处于线程就绪队列，等待系统为其分配CPU。

当系统选定一个等待执行的线程后，它就会从就绪状态进入执行状态，该动作称为“CPU调度”。

 

【3】运行状态

在运行状态的线程执行自己的run方法中代码,直到等待某资源而阻塞或完成任何而死亡。

如果在给定的时间片内没有执行结束，就会被系统给换下来回到等待执行状态。

 

【4】阻塞状态

处于运行状态的线程在某些情况下，如执行了sleep(睡眠)方法，或等待I/O设备等资源，将让出CPU并暂时停止自己运行，进入阻塞状态。

在阻塞状态的线程不能进入就绪队列。只有当引起阻塞的原因消除时，如睡眠时间已到，或等待的I/O设备空闲下来，线程便转入就绪状态，重新到就绪队列中排队等待，被系统选中后从原来停止的位置开始继续执行。

 

【5】死亡状态

死亡状态是线程生命周期中的最后一个阶段。线程死亡的原因有三个，一个是正常运行

的线程完成了它的全部工作；另一个是线程被强制性地终止，如通过stop方法来终止一个

线程【不推荐使用】；三是线程抛出未捕获的异常。

 

5.0   线程常用方法

       [1]线程优先级

        注意：线程优先级高，被cpu调度的概率大，不表示一定先运行。

public static void main(String[] args) {
        
        System.out.println(Thread.MIN_PRIORITY);
        System.out.println(Thread.MAX_PRIORITY);
        System.out.println(Thread.NORM_PRIORITY);
        
        //主线程的优先级（默认优先级）
        System.out.println(Thread.currentThread().getPriority());
        
        
        Thread01 t1 = new Thread01();
        // 设置线程的优先级
        t1.setPriority(Thread.MAX_PRIORITY);
        t1.start();
        
        
        Thread01 t2 = new Thread01();
        // 设置线程的优先级
        t2.setPriority(Thread.MIN_PRIORITY);
        t2.start();
        
        
    }

 

　　   [2]isAlive

　　　 判断线程是否处于活动状态　　

Thread01 t1 = new Thread01();
        System.out.println(t1.isAlive());
        // 设置线程的优先级
        t1.setPriority(Thread.MAX_PRIORITY);
        t1.start();
        System.out.println(t1.isAlive());

　　　注意：线程调用start之后就处于活动状态。

　　   [3]join

　　　调用该方法的线程强制执行，其它线程处于阻塞状态，该线程执行完毕后，其它线程再执行

　　　join称为线程的强制执行，有可能被外界中断产生InterruptedException 中断异常。

public class Test02 {
    public static void main(String[] args){
        
        Thread02 t = new Thread02("线程A");
        t.start();
        
        for (int i = 0; i < 5; i++) {
            
            if(i == 2) {
                try {
                    t.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            
            System.out.println(Thread.currentThread().getName() + "->" + i);
        }
    }
}

　　

         [4]sleep()

　　　在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）。休眠的线程进入阻塞状态。

public static void main(String[] args) {
        
        Thread03 t = new Thread03("线程A");
        t.start();
        
        Thread mainThread = Thread.currentThread();
        System.out.println(mainThread.getName()+"即将进入休眠");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        // 中断线程
        t.interrupt();
        
        System.out.println(mainThread.getName()+"休眠完成");
    }

　　     [5] yield()

　　　　当前线程给cpu调度器一个暗示，暗示其想礼让一次其拥有的cpu，CPU调度者也可以狐狸这次暗示。此时当前线程进入就绪状态。

public static void main(String[] args) {

        Thread mainThread = Thread.currentThread();

        Thread04 t = new Thread04("线程A");
        t.start();

        
        for (int i = 0; i < 5; i++) {
            if (i == 2) {
                // yield 使当前礼让一次
                Thread.yield();
            }
            System.out.println(mainThread.getName() + "->" + i);
        }
    }

　　　　

　　　　[5]线程的终止    interrupt()

　　　　目前而言，不推荐使用stop直接终止线程。用interrupt()方法去中断正在执行的线程，而在线程内部一定要写捕获中断的异常。通过异常处理机制正常结束线程。