第四章-多线程基础

每个线程：

  1. 拥有自己的计数器
  2. 自己的堆栈、局部变量
  3. 能够访问共享的内存变量

处理器在这些线程上高速切换，让使用这感到这些线程在同时执行。

1 - 为什么使用多线程

主要有以下几点：

更多的处理器核心

处理器的核心数量越来越多，以及超线程的运用，现在大多数计算机比之前更加擅长并行计算。处理器性能提升的方式，也向更多的核心发展。
线程是大多数操作系统调度的基本单元。一个线程在一个时刻，只能运行在一个处理器核心上。

更快的响应时间

一些较为复杂的业务代码，比如，一笔订单的创建，包括插入订单数据、生成订单快照、发送邮件通知卖家、记录销售数量等。用户从单机订购按钮开始，
就要等待这些操作全部完成才能看到订购成功的结果。

上面的场景中，使用多线程，将数据一致性不强的操作派发给其他线程处理（也可以是消息队列），如生成订单快照、发送邮件等。这样做的好处是响应
用户请求的线程能够尽快的处理完成。缩短了响应时间。

2 - 线程优先级

线程优先级：线程需要多或者少的分配一些处理器资源的线程属性。

  • 操作系统分出一个个时间片
  • 线程会分配到若干时间片
  • 当线程的时间片用完了就会发生线程调度，并等待下次分配
  • 线程分配到的时间片的多少也就决定了线程使用处理器资源的多少

优先级高的线程分配到的时间片数量要多于优先级低的线程。

3 - 线程中断

   public static void main(String[] args) throws InterruptedException {

        Thread sleepThread = new Thread(new SleepRunner(), "SleepThread");
        sleepThread.setDaemon(true);

        Thread busyThread = new Thread(new BusyRunner(), "BusyThread");
        busyThread.setDaemon(true);

        sleepThread.start();
        busyThread.start();

        // 休眠5秒  让两个线程充分运行
        TimeUnit.SECONDS.sleep(5);

        // 中断相当于线程的一个标志位
        // 表示一个运行中的线程, 是否被其他线程执行了中断操作
        // 其他线程通过调用线程的interrupt方法
        // 对线程进行中断操作
        sleepThread.interrupt();

        busyThread.interrupt();

        System.out.println("SleepThread interrupted is " + sleepThread.isInterrupted());

        System.out.println("BusyThread interrupted is " + busyThread.isInterrupted());

        // 防止两个线程立刻退出
        SleepUtils.second(30);

        busyThread.interrupted();
        System.out.println("BusyThread interrupted is " + busyThread.isInterrupted());

        SleepUtils.second(3);
        System.out.println("程序退出");

        /*
         * 这种通过标志位或者中断的方式能够使线程在终止时能够使线程有机会
         * 清理一些资源, 而不是武断的去停止, 这种终止线程的方式更加安全和优雅
         */

    }


    static class SleepRunner implements Runnable {

        @Override
        public void run() {
            while (true) {
                SleepUtils.second(3);
            }
        }
    }

    static class BusyRunner implements Runnable {

        @Override
        public void run() {
            while (true) {
               //System.out.println("ddd ");
            }
        }
    }

public static void main(String[] args) {

        Runner r = new Runner();

        Thread countThread = new Thread(r, "CountThread");

        countThread.start();

        // 休眠一秒钟 main线程对CountThread进行中断
        // CountThread能够感知中断而结束
        SleepUtils.second(1);
        countThread.interrupt();

        Runner two = new Runner();

        countThread = new Thread(two, "CountThread");

        countThread.start();

        SleepUtils.second(1);

        two.cancle();

    }


    static class Runner implements Runnable {

        private long i = 0;

        private volatile boolean on = true;

        @Override
        public void run() {

            while (on && !Thread.currentThread().isInterrupted()) {
                i++;
            }
            System.out.println("count: " + i);
        }

        public void cancle() {
            on = false;
        }

    }

public static void main(String[] args) {

        new Thread(new TimeWaiting(), "TimeWaitingThread").start();

        new Thread(new Waiting(), "WaitingThread").start();

        new Thread(new Blocked(), "BlockedThread-1").start();

        new Thread(new Blocked(), "BlockedThread-2").start();
    }


    static class TimeWaiting implements Runnable {

        @Override
        public void run() {
            while (true) {
                System.out.println(Thread.currentThread().getName());
                SleepUtils.second(100);
            }
        }
    }

    static class Waiting implements Runnable{

        @Override
        public void run() {
            while (true) {
                synchronized (Waiting.class) {
                    try {
                    System.out.println(Thread.currentThread().getName());
                        Waiting.class.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    static class Blocked implements Runnable {

        @Override
        public void run() {
            synchronized (Blocked.class) {
                while (true) {
                    System.out.println(Thread.currentThread().getName());
                    SleepUtils.second(100);
                }
            }
        }
    }

private static Object lock = new Object();

    private static boolean flag = true;

    public static void main(String[] args) {

        new Thread(new Wait(), "WaitThread").start();

        SleepUtils.second(1);

        new Thread(new Notify(), "NotifyThread").start();

    }


    static class Wait implements Runnable {

        @Override
        public void run() {

            synchronized (lock) {
                while (flag) {

                    String msg = Thread.currentThread() + " flag is true, wait @ " +
                            new SimpleDateFormat("HH:mm:ss:sss").format(new Date());

                    System.out.println(msg);

                    try {
                        /**
                         * wait()方法调用后, 该线程进入waitting状态, 只有等待另外的线程通知或被中断才会返回
                         * 并且会释放这个对象上的锁
                         * 线程状态由ROUNNING变成WAITTING, 并将当前线程放入lock的等待队列中, 然后释放lock上的锁
                         */
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    msg = Thread.currentThread() + " wait后的代码执行 @ " + new SimpleDateFormat("HH:mm:ss:sss").format(new Date());
                    System.out.println(msg);
                }

                String msg = Thread.currentThread() + " flag is false, running @ " +
                        new SimpleDateFormat("HH:mm:ss:sss").format(new Date());
                System.out.println(msg);
            }


        }
    }

    static class Notify implements Runnable {

        @Override
        public void run() {

            synchronized (lock) {

                System.out.println(Thread.currentThread() + " hold lock, notify @ " + new SimpleDateFormat("HH:mm:ss:sss").format(new Date()));

                lock.notifyAll();

                flag = false;

                SleepUtils.second(5);
            }

            synchronized (lock) {

                System.out.println(Thread.currentThread() + " hold lock again, sleep @ " + new SimpleDateFormat("HH:mm:ss:sss").format(new Date()));

                SleepUtils.second(5);
            }

        }
    }
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容

  • Spring Cloud
    Spring Cloud为开发人员提供了快速构建分布式系统中一些常见模式的工具（例如配置管理，服务发现，断路器，智...
    卡卡罗2017阅读 135,323评论 19赞 139
  • Java-Review-Note——4.多线程
    Java-Review-Note——4.多线程 标签： JavaStudy PS：本来是分开三篇的，后来想想还是整...
    coder_pig阅读 5,590评论 2赞 17
  • 我那隐隐透着哥特风的外婆家 之七
    七 乡村社交 外公外婆吃完饭，习惯向碗里倒点开水，晃一晃，再把水喝掉。说：“饭米粒不可以浪费咯，你俚是没经过困难时...
    宋雁楼_有时文艺阅读 2,571评论 0赞 0
  • 来自时光的自白
    我站在似水的流年里，时光流逝发出的哗哗声像海浪拍打沙滩的声音，每一个音节就是一个人的死亡和泯灭。 我看...
    墩墩不胖阅读 1,358评论 2赞 1
  • 赛跑
    时间和空气对每个人来说，都是公平和平等的。越是成功的人，越是对时间倍加珍惜和高效利用；越是成功的人，他们越努力，他...
    驼铃星阅读 1,735评论 0赞 0