java基础(10) -线程

线程

相当于轻量级进程，线程在程序中是独立的、并发的执行路径，每个线程有它自己的堆栈、自己的程序计数器和自己的局部变量。但是，与分隔的进程相比，进程中的线程之间的隔离程度要小。它们共享内存、文件句柄和其它每个进程应有的状态。

构建一个线程

    //创建一个新线程 参数为实现了 Runnable 接口的类实例
    Thread t = new Thread(run);
    //启动线程
    t.start();

线程终止

• run方法完成自动退出
• 一个没有捕获的异常终止了run方法而意外死亡
• stop方法 已弃用
• interrupt方法，重设中断状态,发出中断请求,如果该线程被sleep调用阻塞会抛出异常InterruptedException

线程状态

• New 创建
• Runnable 可运行
• Blocked 被阻塞
• Waiting 等待
• Timed waiting 计时等待
• Terminated 被终止

抢占式调度

一个进程处于Runnable状态，也可能没有运行，取决于操作系统给时间提供的运行时间

线程让步

暂停当前正在执行的线程对象,让其他线程先执行,
实际中无法保证yield()达到让步目的,
因为让步的线程还有可能被线程调度程序再次选中。

守护线程

    t.setDaemon(true);

注意:

不要直接调用run方法，这样不能启动新线程,当设计多线程应用程序的时候，一定不要依赖于线程的优先级,因为线程调度优先级操作是没有保障的，只能把线程优先级作用作为一种提高程序效率的方法，但是要保证程序不依赖这种操作。

demo

    public class MyRunnable implements Runnable {
        public String name = null;

        @Override
        public void run() {
            for(int i =0;i<100;i++){
    //          try {
    //              Thread.sleep(3);
    //          } catch (InterruptedException e) {
    //              e.printStackTrace();
    //          }
                System.out.println(i + name);
            }
        }

        public static void main(String[] args) {
            MyRunnable run = new MyRunnable();
            run.name = "aaaa";
            MyRunnable run2 = new MyRunnable();
            run2.name = "bbbbb";
            Thread t = new Thread(run);
            Thread t2 = new Thread(run2);
            /**
             * 设置优先级 1~10
             * Thread.MAX_PRIORITY
             * Thread.NORM_PRIORIT
             * Thread.MIN_PRIORITY
             */
            t.setPriority(8);
            /**
             * 设置一个线程异常处理器
             */
            t.setUncaughtExceptionHandler(new MyErrorHandler());
            /**
             * 启动线程
             */
            t.start();

            /**
             * 等调用join的线程执行完成再执行下面接着的线程
             */
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            /**
             * 设为守护线程 要在线程启动前调用
             */
            t2.setDaemon(true);
            t2.start();

            //用以判断当前线程是否为中断状态
            Thread.currentThread().isInterrupted();

            /**
             * 线程让步
             *      暂停当前正在执行的线程对象,让其他线程先执行,
             *      实际中无法保证yield()达到让步目的,
             *      因为让步的线程还有可能被线程调度程序再次选中。
             */
            Thread.yield();
        }
    }

    //异常处理器
    public class MyErrorHandler implements UncaughtExceptionHandler {
          /**
           * 这里可以做任何针对异常的处理,比如记录日志等等
           */
          public void uncaughtException(Thread a, Throwable e) {
            System.out.println("This is:" + a.getName() + ",Message:"
                + e.getMessage());
            e.printStackTrace();
          }
    }

同步

    /**
        当多个线程操作同一个对象时，容易出现数据异常状态，
        具体原因是当一个线程获取了所需要的参数，准备赋值时等待，
        另外一个线程也获取了所需要的参数进行了赋值
        这时第一个赋值被唤醒，其值会覆盖第二个线程的值
    */
    public class HeroProperties {
        public int mana = 1000;
        public void useSkill(){
            mana -= 10;
            System.out.println("剩余蓝:" + mana);
        }
    }

    public class SyncRunnable implements Runnable{
        public SyncRunnable(HeroProperties hero){
            this.hero = hero;
        }
        public HeroProperties hero;

        @Override
        public void run() {
            hero.useSkill();
        }
        public static void main(String[] args) {
            HeroProperties hero = new HeroProperties();
            for(int i=0;i<1000;i++){
                SyncRunnable r  = new SyncRunnable(hero);
                Thread t = new Thread(r);
                t.start();
            }
        }
    }
    /*
        打印的结果：出现重复数据
        剩余蓝:980
        剩余蓝:960
        剩余蓝:970
        剩余蓝:980
        剩余蓝:940
        剩余蓝:950
        剩余蓝:930
        剩余蓝:920
        ...
        剩余蓝:-100
        剩余蓝:-110
    */

锁对象-ReentrantLock

使用锁对象 使赋值的代码块变为同步

    /**
        创建锁
        Lock lock = new ReentrantLock();
        锁
        lock.lock();
        解锁
        lock.unLock();
    */

    public class HeroProperties {
        public int mana = 1000;
        public Lock lock = new ReentrantLock();
        public void useSkill(){
            //锁
            lock.lock();
            mana -= 10;
            System.out.println("剩余蓝:" + mana);
            //解锁
            lock.unlock();
        }
    }
    /*
        打印结果没有出现重复值
        剩余蓝:990
        剩余蓝:980
        剩余蓝:970
        剩余蓝:960
        剩余蓝:950
        剩余蓝:940
        剩余蓝:930
        剩余蓝:920
        ...
        剩余蓝:-100
        剩余蓝:-110

    */

条件锁-Condition

此时值出现负数是异常的,mana要大于0才能使用skill，要添加一个条件使mana小于0时进行等待mana的恢复，恢复之后再继续使用skill,此时就要使用条件锁，不符合条件是线程进入等待，又不会造成死锁。

    /**
        Lock lock = new ReentrantLock();
        Condition cd = lock.newCondition();
        //该条件不满足时调用await，线程进入等待
        cd.await();

        //其他线程执行完之后 激活所有等待的线程
        cd.signalAll();
        //激活随机一条线程
        cd.signal();
    */

    /**
        Lock lock = new ReentrantLock();
        Condition cd = lock.newCondition();
        //该条件不满足时调用await，线程进入等待
        cd.await();

        //其他线程执行完之后 激活所有等待的线程
        cd.signalAll();
        //激活随机一条线程
        cd.signal();
    */

    public class HeroProperties {
        public int mana = 100;
        public Lock lock = new ReentrantLock();
        public Condition cd = lock.newCondition();
        public void useSkill() throws InterruptedException{
            lock.lock();
            //自然恢复的蓝量
            mana+=1;
            System.out.println(Thread.currentThread() +"尝试使用技能---------"+ "蓝量:"+mana);
            if(mana<10) {
                System.out.println(Thread.currentThread() +"ZZZZZZZZZZZZ"+"线程睡眠");
                cd.await();
            }
            //有可能是被唤醒的线程
            if(mana<10) {
                //尝试唤醒的时候不一定能直接运行，也有可能被其他线程执行了操作导致该线程操作失败
                System.out.println(Thread.currentThread() +"随机唤醒的线程不符合条件");
            }else{
                //蓝条刚好只剩下一次的时候吃药
                boolean isUseItem = (mana==10);

                System.out.println(Thread.currentThread() + "蓝量:" + mana);
                mana -= 10;
                System.out.println(Thread.currentThread() + "使用技能后剩余蓝:" + mana);

                if(isUseItem) {
                    mana += 30;
                    System.out.println("吃药恢复30");
                }
                if(mana>=10) {
                    //唤醒所有线程
                    //cd.signalAll();
                    //随机唤醒一个线程
                    cd.signal();
                }
            }
            lock.unlock();
        }
    }

synchronized

可以在方法名添加 synchronized 关键字实现同步

    /**
     * wait()       线程进入等待
     * notify()     随机唤醒一个线程
     * notifyAll()  唤醒所有线程
     */
    public synchronized void useSkill(){
        //do something
        //wait();
    }

同步阻塞，synchronized一个对象组成一个代码块，该代码块就能实现同步

    Object lock = new Object()
    public void useSkill(){
        synchronized(obj){
            //do something
        }
    }