线程

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

构建一个线程

    //创建一个新线程 参数为实现了 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
        }
    }

java基础(10) -线程的更多相关文章

  1. 【Java基础】线程和并发机制

    前言 在Java中,线程是一个很关键的名词,也是很高频使用的一种资源.那么它的概念是什么呢,是如何定义的,用法又有哪些呢?为何说Android里只有一个主线程呢,什么是工作线程呢.线程又存在并发,并发 ...

  2. Java基础-多线程-③线程同步之synchronized

    使用线程同步解决多线程安全问题 上一篇 Java基础-多线程-②多线程的安全问题 中我们说到多线程可能引发的安全问题,原因在于多个线程共享了数据,且一个线程在操作(多为写操作)数据的过程中,另一个线程 ...

  3. Java基础篇——线程、并发编程知识点全面介绍(面试、学习的必备索引)

    原创不易,如需转载,请注明出处https://www.cnblogs.com/baixianlong/p/10739579.html,希望大家多多支持!!! 一.线程基础 1.线程与进程 线程是指进程 ...

  4. Java基础_线程的使用及创建线程的三种方法

    线程:线程是操作系统能够进行运算调度的最小单位.它被包含在进程之中,是进程中的实际运作单位.一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务. 进程:进 ...

  5. Java基础之线程——使用执行器(UsingExecutors)

    控制台程序. 在这个版本的银行示例中,把借款和贷款事务创建为在不同线程中执行的任务,它们把事务提交给职员.创建事务的任务是Callable<>任务,因为它们需要返回已为每个账户创建的借款或 ...

  6. Java基础10:全面解读Java异常

    更多内容请关注微信公众号[Java技术江湖] 这是一位阿里 Java 工程师的技术小站,作者黄小斜,专注 Java 相关技术:SSM.SpringBoot.MySQL.分布式.中间件.集群.Linux ...

  7. Java基础8-多线程;同步代码块

    作业解析 利用白富美接口案例,土豪征婚使用匿名内部类对象实现. interface White{ public void white(); } interface Rich{ public void ...

  8. Java基础-多线程-①线程的创建和启动

    简单阐释进程和线程 对于进程最直观的感受应该就是“windows任务管理器”中的进程管理: (计算机原理课上的记忆已经快要模糊了,简单理解一下):一个进程就是一个“执行中的程序”,是程序在计算机上的一 ...

  9. java基础25 线程的常用方法、线程安全问题、死锁现象

    一.线程的常用方法 1.Thread(String name):初始化线程的名字2. setName(String name):设置线程的名字3. getName():返回线程的名字4. sleep( ...

随机推荐

  1. 【JAVAWEB学习笔记】01_HTML

    案例一:网站信息显示页面1.什么是HTML?(Hyper Text Markup Language:超文本标记语言) 超文本:功能比普通文本更加强大 标记语言:使用一组标签对内容进行描述的一门语言(它 ...

  2. 18、面向对象基本原则及UML类图简介

    18.1.面向对象基本原则 18.1.1.面向抽象原则 抽象类特点: a.抽象类中可以有abstract方法,也可以有非abstract方法. b.抽象类不能用new运算符创建对象. c.如果一个非抽 ...

  3. java面向对象--类加载器及Class对象

    类加载器 jvm 和 类的关系 当调用 java命令运行一个java程序时,会启动一个java虚拟机进程.同一个jvm的所有线程.所有变量都处于同一个进程里,都使用该jvm进程的内存区. jvm进程终 ...

  4. Lists, Maps and Sets in Java

    ArrayList vs LinkedList vs Vector From the hierarchy diagram, they all implement List interface. The ...

  5. 基于java:读写一个英文的txt文件,记录单词个数,并输出十个出现最多的单词及出现的个数;

    import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; class W ...

  6. 测试工具——JMeter

    本学期新学的课程,软件测试,上机的实验用到了C++Test,QTP,还有JMeter.今天针对JMeter做一次总结,方便以后用到,知道步骤会更加方便. 首先,对Jmeter进行一个大致的了解,包括对 ...

  7. 一天搞定CSS: 清除浮动(float)--13

    上一节已经说明了为什么要清除浮动了.这里我们就来解决浮动产生的各种问题. 为什么要清楚浮动? 地址:http://blog.csdn.net/baidu_37107022/article/detail ...

  8. Java 9 揭秘(3. 创建你的第一个模块)

    文 by / 林本托 Tips 做一个终身学习的人. 在这个章节中,主要介绍以下内容: 如何编写模块化的Java程序 如何编译模块化程序 如何将模块的项目打包成模块化的JAR文件 如何运行模块化程序 ...

  9. 推荐五款Android 应用的自动化测试工具

    如今自动化测试已经应用到每天的测试中.这不足为奇,因为自动化测试在测试过程中节约了时间,还能避免包括人为因素造成的测试错误和遗漏. 自动化测试工具选择很多.一些是开源的,一些非常贵.一些自动化工具是几 ...

  10. 修改cms版权等等信息

    目的:为DedeCMS换上精美多样的提示信息窗口 用到的开源项目:DedeCMS,artdialog 步骤: 1.下载include.rar文件完成后,解压得到2个php文件和一个使用说明文件,将ph ...