精华内容
下载资源
问答
  • Qt多线程正确用法

    万次阅读 多人点赞 2016-10-11 09:04:59
    QThread的常见特性: run()是线程的入口,就像main()对于应用程序的作用。QThread中对run()的默认实现调用了exec(),从而创建一个...简单用代码描述如下: int QThread::exec() { //... QEventLoop eventLoop; i

    QThread的常见特性:

    run()是线程的入口,就像main()对于应用程序的作用。QThread中对run()的默认实现调用了exec(),从而创建一个QEventLoop对象,由其处理该线程事件队列(每一个线程都有一个属于自己的事件队列)中的事件。简单用代码描述如下:

     

    int QThread::exec()
    {
    //...
        QEventLoop eventLoop;
        int returnCode = eventLoop.exec();
    //...
        return returnCode;
    }
     
    int QEventLoop::exec(ProcessEventsFlags flags)
    {
    //...
        while (!d->exit) {
            while (!posted_event_queue_is_empty) {
                process_next_posted_event();
            }
        }
    //...
    }

    由此可见,exec()在其内部不断做着循环遍历事件队列的工作,调用QThread的quit()或exit()方法使停止工作,尽量不要使用terminate(),该方法过于粗暴,造成资源不能释放,甚至互斥锁还处于加锁状态。

    1.旧的使用方式:

    #include "QThread"
    #include "QMutexLocker"
    #include "QMutex"
    class Thread:public QThread
    {
        Q_OBJECT
    public:
        Thread();
        void stop();
    private:
        bool m_stopFlag;
        QMutex mutex;
    protected:
        void run();
    };
    Thread::Thread()
    {
        m_stopFlag = false;
    }
     
    void Thread::stop()
    {
        QMutexLocker locker(&mutex);
        m_stopFlag = true;
    }
     
    void Thread::run()
    {
        while(1){
            {
                QMutexLocker locker(&mutex);
                if(m_stopFlag)
                    break;
            }
            qDebug()<<"This is in thread["<<currentThreadId()<<"]."<<(int)currentThread();
            sleep(2);
        }
        m_stopFlag = false;
    }
    int main(int argc, char *argv[])
    {
        QCoreApplication a(argc, argv);
        qDebug()<<"From main thread: "<<QThread::currentThreadId();
     
        Thread t;
        QObject::connect(&t, SIGNAL(finished()), &a, SLOT(quit()));
        t.start();
        return a.exec();
    }

    这是qt4.6及之前的使用方法,这种方式本没有什么错误,可以处理我们的绝大多数需求。Thread对象本身工作在主线程下,即使调用的t.stop()方法,它也是工作在主线程下,只有run()范围内的代码工作在次线程中。

    class WorkerThread : public QThread
    {
        Q_OBJECT
    
        void run() Q_DECL_OVERRIDE {
            QString result;
            emit resultReady(result);
        }
    
    signals:
        void resultReady(const QString &s);
    };
    
    void MyObject::startWorkInAThread()
    {
        WorkerThread *workerThread = new WorkerThread(this);
        connect(workerThread, &WorkerThread::resultReady, this, &MyObject::handleResults);
        connect(workerThread, &WorkerThread::finished, workerThread, &QObject::deleteLater);
        workerThread->start();
    }

    从Qt4.8起,可以释放运行刚刚结束的线程对象,通过连接finished()信号到QObject::deleteLater()。

    2.推荐的使用方式:

    #include <QtCore>
    class Worker : public QObject
    {
        Q_OBJECT
    private slots:
        void onTimeout()
        {
            qDebug()<<"Worker::onTimeout get called from?: "<<QThread::currentThreadId();
        }
    };
    #include "main.moc"
    int main(int argc, char *argv[])
    {
        QCoreApplication a(argc, argv);
        qDebug()<<"From main thread: "<<QThread::currentThreadId();
     
        QThread t;
        QTimer timer;
        Worker worker;
     
        QObject::connect(&timer, SIGNAL(timeout()), &worker, SLOT(onTimeout()));
        timer.start(1000);
     
        worker.moveToThread(&t);
     
        t.start();
     
        return a.exec();
    }

    这是Qt4.7及以后版本推荐的工作方式。其主要特点就是利用Qt的事件驱动特性,将需要在次线程中处理的业务放在独立的模块(类)中,由主线程创建完该对象后,将其移交给指定的线程,且可以将多个类似的对象移交给同一个线程。在这个例子中,信号由主线程的QTimer对象发出,之后Qt会将关联的事件放到worker所属线程的事件队列。由于队列连接的作用,在不同线程间连接信号和槽是很安全的。
    说说connect最后一个参数,连接类型:
    1)自动连接(AutoConnection),默认的连接方式,如果信号与槽,也就是发送者与接受者在同一线程,等同于直接连接;如果发送者与接受者处在不同线程,等同于队列连接。

    2)直接连接(DirectConnection),当信号发射时,槽函数立即直接调用。无论槽函数所属对象在哪个线程,槽函数总在发送者所在线程执行。

     

    3)队列连接(QueuedConnection),当控制权回到接受者所在线程的事件循环时,槽函数被调用。槽函数在接受者所在线程执行。

    class Worker : public QObject
    {
        Q_OBJECT
    
    public slots:
        void doWork(const QString meter) {
            // ...
            emit resultReady(result);
        }
        void stopWork(){
            //...
        }
    signals:
        void resultReady(const QString &result);
    };
    
    class Controller : public QObject
    {
        Q_OBJECT
    
        QThread workerThread;
    
    public:
        Controller() {
            Worker *worker = new Worker;
            worker->moveToThread(&workerThread);
            connect(workerThread, &QThread::finished, worker, &QObject::deleteLater);
            connect(this, &Controller::operate, worker, &Worker::doWork);
            connect(this, &Controller::kill, worker, &Worker::stopWork);
            connect(worker, &Worker::resultReady, this, &Controller::handleResults);
            workerThread.start();
        }
        ~Controller() {
            workerThread.quit();
            workerThread.wait();
        }
    
    public slots:
        void handleResults(const QString &);
    
    signals:
        void operate(const QString &);
        void kill();
    };

    使用新方式,子线程中的槽都在子线程中运行,主线程中的槽都在主线程中运行,信号和槽默认使用自动连接(AutoConnection)。值得注意的是,如果槽doWork中有耗时操作,比如说while循环,主线程的信号kill子线程是不会响应的,除非使用直接连接(DirectConnection),connect(this, &Controller::kill, worker, &Worker::stopWork, Qt::DirectConnection);,此时,槽stopWork工作于主线程。

    3.GUI界面假死的处理
    在GUI程序中,主线程也叫GUI线程,因为它是唯一被允许执行GUI相关操作的线程。对于一些耗时的操作,如果放在主线程中,就是出现界面无法响应的问题。这种问题的解决一种方式是,把这些耗时操作放到次线程中,还有一种比较简单的方法:在处理耗时操作中频繁调用QApplication::processEvents()。这个函数告诉Qt去处理那些还没有被处理的各类事件,然后再把控制权返还给调用者。

    QElapsedTimer et;
    et.start();
    while(et.elapsed()<300)
        QCoreApplication::processEvents();


    参考链接:https://my.oschina.net/u/200628/blog/187865
    参考链接:http://blog.sina.com.cn/s/blog_a6fb6cc90101hohu.html
    原创不易,转载请标明出处:https://blog.csdn.net/caoshangpa/article/details/52784860

     

    展开全文
  • 线程正确打开方式

    千次阅读 2020-08-27 19:08:23
    线程作为操作系统调度的最小单元,多个线程能够同时执行,这将 显著提升程序性能,在多核环境中表现得更加明显。但是,过多地创建线程和对线程的不当管 理也容易造成问题。本章将着重介绍Java并发编程的基础知识,从...

    在这里插入图片描述

    前言

    线程简介

    Java从诞生开始就明智地选择了内置对多线程的支持,这使得Java语言相比同一时期的 其他语言具有明显的优势。线程作为操作系统调度的最小单元,多个线程能够同时执行,这将 显著提升程序性能,在多核环境中表现得更加明显。但是,过多地创建线程和对线程的不当管 理也容易造成问题。本章将着重介绍Java并发编程的基础知识,从启动一个线程到线程间不同 的通信方式,最后通过简单的线程池示例以及应用(简单的Web服务器)来串联本章所介绍的 内容。

    什么是线程

    现代操作系统在运行一个程序时,会为其创建一个进程。例如,启动一个Java程序,操作 系统就会创建一个Java进程。现代操作系统调度的最小单元是线程,也叫轻量级进程(Light Weight Process),在一个进程里可以创建多个线程,这些线程都拥有各自的计数器、堆栈和局 部变量等属性,并且能够访问共享的内存变量。处理器在这些线程上高速切换,让使用者感觉 到这些线程在同时执行。 一个Java程序从main()方法开始执行,然后按照既定的代码逻辑执行,看似没有其他线程 参与,但实际上Java程序天生就是多线程程序,因为执行main()方法的是一个名称为main的线 程。下面使用JMX来查看一个普通的Java程序包含哪些线程,如下代码所示。

      public class MultiThread {
            public static void main(String[] args) { 
            	// 获取Java线程管理MXBean 
                ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean(); 
                // 不需要获取同步的monitor和synchronizer信息,仅获取线程和线程堆栈信息
                ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false, false);
                 // 遍历线程信息,仅打印线程ID和线程名称信息
                for (ThreadInfo threadInfo : threadInfos) {
                    System.out.println("[" + threadInfo.getThreadId() + "] " + threadInfo.getThreadName());
                }
            }
        }
    

    输出如下所示(输出内容可能不同)。

    [6] Monitor Ctrl-Break
    [5] Attach Listener //负责接收到外部的命令,如:java -version、jmap、jstack等等。如果该线程在jvm启动的时候没有初始化,那么,则会在用户第一次执行jvm命令时启动
    [4] Signal Dispatcher // 分发处理发送给JVM信号的线程 前面我们提到第一个Attach Listener线程的职责是接收外部jvm命令,当命令接收成功后,会交给signal dispather线程去进行分发到各个不同的模块处理命令,并且返回处理结果。signal dispather线程也是在第一次接收外部jvm命令时,进行初始化工作。
    [3] Finalizer // 调用对象finalize方法的线程这个线程也是在main线程之后创建的,其优先级为10,主要用于在垃圾收集前,调用对象的finalize()方法;
    关于Finalizer线程的几点:

      1. 只有当开始一轮垃圾收集时,才会开始调用finalize()方法;因此并不是所有对象的finalize()方法都会被执行;
      2. 该线程也是daemon线程,因此如果虚拟机中没有其他非daemon线程,不管该线程有没有执行完finalize()方法,JVM也会退出;
      3. JVM在垃圾收集时会将失去引用的对象包装成Finalizer对象(Reference的实现),并放入ReferenceQueue,由Finalizer线程来处理;最后将该Finalizer对象的引用置为null,由垃圾收集器来回收;
      4. JVM为什么要单独用一个线程来执行finalize()方法呢?如果JVM的垃圾收集线程自己来做,很有可能由于在finalize()方法中误操作导致GC线程停止或不可控,这对GC线程来说是一种灾难;
    

    [2] Reference Handler // 清除Reference的线程 VM在创建main线程后就创建Reference Handler线程,其优先级最高,为10,它主要用于处理引用对象本身(软引用、弱引用、虚引用)的垃圾回收问题。
    [1] main //main线程,用户程序入口

    可以看到,一个Java程序的运行不仅仅是main()方法的运行,而是main线程和多个其他线 程的同时运行。

    为什么要使用多线程

    执行一个简单的“Hello,World!”,却启动了那么多的“无关”线程,是不是把简单的问题复 杂化了?当然不是,因为正确使用多线程,总是能够给开发人员带来显著的好处,而使用多线 程的原因主要有以下几点。
    (1)更多的处理器核心
    随着处理器上的核心数量越来越多,以及超线程技术的广泛运用,现在大多数计算机都 比以往更加擅长并行计算,而处理器性能的提升方式,也从更高的主频向更多的核心发展。如 何利用好处理器上的多个核心也成了现在的主要问题。 线程是大多数操作系统调度的基本单元,一个程序作为一个进程来运行,程序运行过程 中能够创建多个线程,而一个线程在一个时刻只能运行在一个处理器核心上。试想一下,一个 单线程程序在运行时只能使用一个处理器核心,那么再多的处理器核心加入也无法显著提升 该程序的执行效率。相反,如果该程序使用多线程技术,将计算逻辑分配到多个处理器核心 上,就会显著减少程序的处理时间,并且随着更多处理器核心的加入而变得更有效率。
    (2)更快的响应时间
    有时我们会编写一些较为复杂的代码(这里的复杂不是说复杂的算法,而是复杂的业务逻 辑),例如,一笔订单的创建,它包括插入订单数据、生成订单快照、发送邮件通知卖家和记录 货品销售数量等。用户从单击“订购”按钮开始,就要等待这些操作全部完成才能看到订购成 功的结果。但是这么多业务操作,如何能够让其更快地完成呢? 在上面的场景中,可以使用多线程技术,即将数据一致性不强的操作派发给其他线程处 理(也可以使用消息队列),如生成订单快照、发送邮件等。这样做的好处是响应用户请求的线 程能够尽可能快地处理完成,缩短了响应时间,提升了用户体验。
    (3)更好的编程模型
    Java为多线程编程提供了良好、考究并且一致的编程模型,使开发人员能够更加专注于问 题的解决,即为所遇到的问题建立合适的模型,而不是绞尽脑汁地考虑如何将其多线程化。一 旦开发人员建立好了模型,稍做修改总是能够方便地映射到Java提供的多线程编程模型上。

    线程优先级

    现代操作系统基本采用时分的形式调度运行的线程,操作系统会分出一个个时间片,线 程会分配到若干时间片,当线程的时间片用完了就会发生线程调度,并等待着下次分配。线程 分配到的时间片多少也就决定了线程使用处理器资源的多少,而线程优先级就是决定线程需 要多或者少分配一些处理器资源的线程属性。 在Java线程中,通过一个整型成员变量priority来控制优先级,优先级的范围从1~10,在线 程构建的时候可以通过setPriority(int)方法来修改优先级,默认优先级是5,优先级高的线程分 配时间片的数量要多于优先级低的线程。设置线程优先级时,针对频繁阻塞(休眠或者I/O操 作)的线程需要设置较高优先级,而偏重计算(需要较多CPU时间或者偏运算)的线程则设置较 低的优先级,确保处理器不会被独占。在不同的JVM以及操作系统上,线程规划会存在差异, 有些操作系统甚至会忽略对线程优先级的设定,示例如代码如下

    import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.TimeUnit;
    
    public class Priority {
        private static volatile boolean notStart = true;
        private static volatile boolean notEnd = true;
    
        public static void main(String[] args) throws Exception {
            List<Job> jobs = new ArrayList<>();
            for (int i = 0; i < 10; i++) {
                int priority = i < 5 ? Thread.MIN_PRIORITY : Thread.MAX_PRIORITY;
                Job job = new Job(priority);
                jobs.add(job);
                Thread thread = new Thread(job, "Thread:" + i);
                thread.setPriority(priority);
                thread.start();
            }
            notStart = false;
            TimeUnit.SECONDS.sleep(10);
            notEnd = false;
            for (Job job : jobs) {
                System.out.println("Job Priority : " + job.priority + ", Count : " + job.jobCount);
            }
        }
    
        static class Job implements Runnable {
            private int priority;
            private long jobCount;
    
            public Job(int priority) {
                this.priority = priority;
            }
    
            @Override
            public void run() {
                while (notStart) {
                    Thread.yield();
                }
                while (notEnd) {
                    Thread.yield();
                    jobCount++;
                }
            }
        }
    

    }

    对应的输出如下。

    Job Priority : 1, Count : 47863472
    Job Priority : 1, Count : 70518591
    Job Priority : 1, Count : 49043396
    Job Priority : 1, Count : 62759135
    Job Priority : 1, Count : 36311308
    Job Priority : 10, Count : 43784582
    Job Priority : 10, Count : 86704297
    Job Priority : 10, Count : 75494174
    Job Priority : 10, Count : 30328316
    Job Priority : 10, Count : 59936782
    

    从输出可以看到线程优先级没有生效,优先级1和优先级10的Job计数的结果非常相近, 没有明显差距。这表示程序正确性不能依赖线程的优先级高低。 注意 线程优先级不能作为程序正确性的依赖,因为操作系统可以完全不用理会Java 线程对于优先级的设定。笔者的环境为:Mac OS X 10.10,Java版本为1.7.0_71,经过笔者验证 该环境下所有Java线程优先级均为5(通过jstack查看),对线程优先级的设置会被忽略。另外, 尝试在Ubuntu 14.04环境下运行该示例,输出结果也表示该环境忽略了线程优先级的设置。

    线程的状态

    Java线程在运行的生命周期中可能处于表4-1所示的6种不同的状态,在给定的一个时刻, 线程只能处于其中的一个状态。 Java线程的状态
    在这里插入图片描述
    下面我们使用jstack工具(可以选择打开终端,键入jstack或者到JDK安装目录的bin目录下 执行命令),尝试查看示例代码运行时的线程信息,更加深入地理解线程状态,示例代码如下。

    public class ThreadState {
        public static void main(String[] args) {
            new Thread(new TimeWaiting(), "TimeWaitingThread").start();
            new Thread(new Waiting(), "WaitingThread").start(); // 使用两个Blocked线程,一个获取锁成功,另一个被阻塞 
            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) {
                    SleepUtils.second(100);
                }
            }
        }
    
        // 该线程在Waiting.class实例上等待
        static class Waiting implements Runnable {
            @Override
            public void run() {
                while (true) {
                    synchronized (Waiting.class) {
                        try {
                            Waiting.class.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    
        // 该线程在Blocked.class实例上加锁后,不会释放该锁
        static class Blocked implements Runnable {
            public void run() {
                synchronized (Blocked.class) {
                    while (true) {
                        SleepUtils.second(100);
                    }
                }
            }
        }
    }
    

    上述示例中使用的SleepUtils如代码清单4-4所示。 代码清单4-4

    import java.util.concurrent.TimeUnit;
    
    public class SleepUtils {
        public static final void second(long seconds) {
            try {
                TimeUnit.SECONDS.sleep(seconds);
            } catch (InterruptedException e) {
            }
        }
    }
    

    运行该示例,打开终端或者命令提示符,键入“jps”,输出如下。
    611
    935 Jps
    929 ThreadState
    270

    可以看到运行示例对应的进程ID是929,接着再键入“jstack 929”(这里的进程ID需要和读者自己键入jps得出的ID一致),部分输出如下所示。
    在这里插入图片描述
    通过示例,我们了解到Java程序运行中线程状态的具体含义。线程在自身的生命周期中, 并不是固定地处于某个状态,而是随着代码的执行在不同的状态之间进行切换,Java线程状态 变迁如图4-1示。
    在这里插入图片描述
    由图可以看到,线程创建之后,调用start()方法开始运行。当线程执行wait()方法之 后,线程进入等待状态。进入等待状态的线程需要依靠其他线程的通知才能够返回到运行状 态,而超时等待状态相当于在等待状态的基础上增加了超时限制,也就是超时时间到达时将 会返回到运行状态。当线程调用同步方法时,在没有获取到锁的情况下,线程将会进入到阻塞 状态。线程在执行Runnable的run()方法之后将会进入到终止状态。

    注意 Java将操作系统中的运行和就绪两个状态合并称为运行状态。阻塞状态是线程 阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态,但是阻塞在 java.concurrent包中Lock接口的线程状态却是等待状态,因为java.concurrent包中Lock接口对于 阻塞的实现均使用了LockSupport类中的相关方法。

    Daemon线程

    Daemon线程是一种支持型线程,因为它主要被用作程序中后台调度以及支持性工作。这 意味着,当一个Java虚拟机中不存在非Daemon线程的时候,Java虚拟机将会退出。可以通过调 用Thread.setDaemon(true)将线程设置为Daemon线程。 注意 Daemon属性需要在启动线程之前设置,不能在启动线程之后设置。 Daemon线程被用作完成支持性工作,但是在Java虚拟机退出时Daemon线程中的finally块 并不一定会执行

    public class Daemon {
        public static void main(String[] args) {
            Thread thread = new Thread(new DaemonRunner(), "DaemonRunner");
            thread.setDaemon(true);
            thread.start();
        }
    
        static class DaemonRunner implements Runnable {
            @Override
            public void run() {
                try {
                    SleepUtils.second(10);
                } finally {
                    System.out.println("DaemonThread finally run.");
                }
            }
        }
    }
    

    运行Daemon程序,可以看到在终端或者命令提示符上没有任何输出。main线程(非 Daemon线程)在启动了线程DaemonRunner之后随着main方法执行完毕而终止,而此时Java虚拟 机中已经没有非Daemon线程,虚拟机需要退出。Java虚拟机中的所有Daemon线程都需要立即 终止,因此DaemonRunner立即终止,但是DaemonRunner中的finally块并没有执行。 注意 在构建Daemon线程时,不能依靠finally块中的内容来确保执行关闭或清理资源的逻辑。

    启动和终止线程

    在前面章节的示例中通过调用线程的start()方法进行启动,随着run()方法的执行完毕,线 程也随之终止,大家对此一定不会陌生,下面将详细介绍线程的启动和终止。

    构造线程

    在运行线程之前首先要构造一个线程对象,线程对象在构造的时候需要提供线程所需要 的属性,如线程所属的线程组、线程优先级、是否是Daemon线程等信息。代码清单4-6所示的 代码摘自java.lang.Thread中对线程进行初始化的部分。 代码清单4-6 Thread.java

       private void init(ThreadGroup g, Runnable target, String name, long stackSize, AccessControlContext acc) {
            if (name == null) {
                throw new NullPointerException("name cannot be null");
            }
            // 当前线程就是该线程的父线程
            Thread parent = currentThread();
            this.group = g; 
            // 将daemon、priority属性设置为父线程的对应属性
            this.daemon = parent.isDaemon();
            this.priority = parent.getPriority();
            this.name = name.toCharArray();
            this.target = target;
            setPriority(priority); 
            // 将父线程的InheritableThreadLocal复制过来
            if (parent.inheritableThreadLocals != null)
                this.inheritableThreadLocals = ThreadLocal.createInheritedMap(parent.inheritableThreadLocals); 
            // 分配一个线程ID
            tid = nextThreadID();
        }
    

    在上述过程中,一个新构造的线程对象是由其parent线程来进行空间分配的,而child线程 继承了parent是否为Daemon、优先级和加载资源的contextClassLoader以及可继承的 ThreadLocal,同时还会分配一个唯一的ID来标识这个child线程。至此,一个能够运行的线程对 象就初始化好了,在堆内存中等待着运行。

    启动线程

    线程对象在初始化完成之后,调用start()方法就可以启动这个线程。线程start()方法的含义 是:当前线程(即parent线程)同步告知Java虚拟机,只要线程规划器空闲,应立即启动调用 start()方法的线程。 注意 启动一个线程前,最好为这个线程设置线程名称,因为这样在使用jstack分析程 序或者进行问题排查时,就会给开发人员提供一些提示,自定义的线程最好能够起个名字。

    理解中断

    中断可以理解为线程的一个标识位属性,它表示一个运行中的线程是否被其他线程进行 了中断操作。中断好比其他线程对该线程打了个招呼,其他线程通过调用该线程的interrupt() 方法对其进行中断操作。 线程通过检查自身是否被中断来进行响应,线程通过方法isInterrupted()来进行判断是否 被中断,也可以调用静态方法Thread.interrupted()对当前线程的中断标识位进行复位。如果该 线程已经处于终结状态,即使该线程被中断过,在调用该线程对象的isInterrupted()时依旧会返 回false。 从Java的API中可以看到,许多声明抛出InterruptedException的方法(例如Thread.sleep(long millis)方法)这些方法在抛出InterruptedException之前,Java虚拟机会先将该线程的中断标识位 清除,然后抛出InterruptedException,此时调用isInterrupted()方法将会返回false。 在代码例子中,首先创建了两个线程,SleepThread和BusyThread,前者不停 地睡眠,后者一直运行,然后对这两个线程分别进行中断操作,观察二者的中断标识位。

    import java.util.concurrent.TimeUnit;
    
    public class Interrupted {
        public static void main(String[] args) throws Exception {
            // sleepThread不停的尝试睡眠
            Thread sleepThread = new Thread(new SleepRunner(), "SleepThread");
            sleepThread.setDaemon(true);
            // busyThread不停的运行
            Thread busyThread = new Thread(new BusyRunner(), "BusyThread");
            busyThread.setDaemon(true);
            sleepThread.start();
            busyThread.start();
            // 休眠5秒,让sleepThread和busyThread充分运行
            TimeUnit.SECONDS.sleep(5);
            sleepThread.interrupt();
            busyThread.interrupt();
            System.out.println("SleepThread interrupted is " + sleepThread.isInterrupted());
            System.out.println("BusyThread interrupted is " + busyThread.isInterrupted());
            // 防止sleepThread和busyThread立刻退出
            SleepUtils.second(2);
        }
    
        static class SleepRunner implements Runnable {
            @Override
            public void run() {
                while (true) {
                    SleepUtils.second(10);
                }
            }
        }
    
        static class BusyRunner implements Runnable {
            @Override
            public void run() {
                while (true) {
                }
            }
        }
    }
    

    输出如下。

    SleepThread interrupted is false 
    BusyThread interrupted is true 
    

    从结果可以看出,抛出InterruptedException的线程SleepThread,其中断标识位被清除了, 而一直忙碌运作的线程BusyThread,中断标识位没有被清除。

    过期的suspend()、resume()和stop()

    大家对于CD机肯定不会陌生,如果把它播放音乐比作一个线程的运作,那么对音乐播放 做出的暂停、恢复和停止操作对应在线程Thread的API就是suspend()、resume()和stop()。 在代码清单4-8所示的例子中,创建了一个线程PrintThread,它以1秒的频率进行打印,而 主线程对其进行暂停、恢复和停止操作。 代码如下 Deprecated.java

    import java.text.DateFormat;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.concurrent.TimeUnit;
    
    public class Deprecated {
        public static void main(String[] args) throws Exception {
            DateFormat format = new SimpleDateFormat("HH:mm:ss");
            Thread printThread = new Thread(new Runner(), "PrintThread");
            printThread.setDaemon(true);
            printThread.start();
            TimeUnit.SECONDS.sleep(3);
            // 将PrintThread进行暂停,输出内容工作停止
            printThread.suspend();
            System.out.println("main suspend PrintThread at " + format.format(new Date()));
            TimeUnit.SECONDS.sleep(3);
            // 将PrintThread进行恢复,输出内容继续
            printThread.resume();
            System.out.println("main resume PrintThread at " + format.format(new Date()));
            TimeUnit.SECONDS.sleep(3);
            // 将PrintThread进行终止,输出内容停止
            printThread.stop();
            System.out.println("main stop PrintThread at " + format.format(new Date()));
            TimeUnit.SECONDS.sleep(3);
        }
    
        static class Runner implements Runnable {
            @Override
            public void run() {
                DateFormat format = new SimpleDateFormat("HH:mm:ss");
                while (true) {
                    System.out.println(Thread.currentThread().getName() + " Run at " + format.format(new Date()));
                    SleepUtils.second(1);
                }
            }
        }
    }
    

    输出如下(输出内容中的时间与示例执行的具体时间相关)。

    PrintThread Run at 17:56:36
    PrintThread Run at 17:56:37
    PrintThread Run at 17:56:38
    main suspend PrintThread at 17:56:39
    PrintThread Run at 17:56:42
    main resume PrintThread at 17:56:42
    PrintThread Run at 17:56:43
    PrintThread Run at 17:56:44
    PrintThread Run at 17:56:45
    main stop PrintThread at 17:56:45
    

    在执行过程中,PrintThread运行了3秒,随后被暂停,3秒后恢复,最后经过3秒被终止。 通过示例的输出可以看到,suspend()、resume()和stop()方法完成了线程的暂停、恢复和终 止工作,而且非常“人性化”。但是这些API是过期的,也就是不建议使用的。 不建议使用的原因主要有:以suspend()方法为例,在调用后,线程不会释放已经占有的资 源(比如锁),而是占有着资源进入睡眠状态,这样容易引发死锁问题。同样,stop()方法在终结 一个线程时不会保证线程的资源正常释放,通常是没有给予线程完成资源释放工作的机会, 因此会导致程序可能工作在不确定状态下。 注意 正因为suspend()、resume()和stop()方法带来的副作用,这些方法才被标注为不建 议使用的过期方法,而暂停和恢复操作可以用后面提到的等待/通知机制来替代。

    安全地终止线程

    中断状态是线程的一个标识位,而中断操作是一种简便的线程间交互 方式,而这种交互方式最适合用来取消或停止任务。除了中断以外,还可以利用一个boolean变 量来控制是否需要停止任务并终止该线程。 在如下代码,创建了一个线程CountThread,它不断地进行变量累加,而 主线程尝试对其进行中断操作和停止操作。

    import java.util.concurrent.TimeUnit;
    
    public class Shutdown {
        public static void main(String[] args) throws Exception {
            Runner one = new Runner();
            Thread countThread = new Thread(one, "CountThread");
            countThread.start(); // 睡眠1秒,main线程对CountThread进行中断,使CountThread能够感知中断而结束
            TimeUnit.SECONDS.sleep(1);
            countThread.interrupt();
            Runner two = new Runner();
            countThread = new Thread(two, "CountThread");
            countThread.start(); // 睡眠1秒,main线程对Runner two进行取消,使CountThread能够感知on为false而结束
            TimeUnit.SECONDS.sleep(1);
            two.cancel();
        }
    
        private static class Runner implements Runnable {
            private long i;
            private volatile boolean on = true;
    
            @Override
            public void run() {
                while (on && !Thread.currentThread().isInterrupted()) {
                    i++;
                }
                System.out.println("Count i = " + i);
            }
    
                public void cancel() {
                on = false;
            }
        }
    }
    

    输出结果如下所示(输出内容可能不同)。

    Count i = 543487324
    Count i = 540898082
    

    示例在执行过程中,main线程通过中断操作和cancel()方法均可使CountThread得以终止。 这种通过标识位或者中断操作的方式能够使线程在终止时有机会去清理资源,而不是武断地 将线程停止,因此这种终止线程的做法显得更加安全和优雅。

    线程间通信

    线程开始运行,拥有自己的栈空间,就如同一个脚本一样,按照既定的代码一步一步地执 行,直到终止。但是,每个运行中的线程,如果仅仅是孤立地运行,那么没有一点儿价值,或者 说价值很少,如果多个线程能够相互配合完成工作,这将会带来巨大的价值。

    volatile和synchronized关键字

    Java支持多个线程同时访问一个对象或者对象的成员变量,由于每个线程可以拥有这个 变量的拷贝(虽然对象以及成员变量分配的内存是在共享内存中的,但是每个执行的线程还是 可以拥有一份拷贝,这样做的目的是加速程序的执行,这是现代多核处理器的一个显著特 性),所以程序在执行过程中,一个线程看到的变量并不一定是最新的。

    关键字volatile可以用来修饰字段(成员变量),就是告知程序任何对该变量的访问均需要 从共享内存中获取,而对它的改变必须同步刷新回共享内存,它能保证所有线程对变量访问 的可见性。

    举个例子,定义一个表示程序是否运行的成员变量boolean on=true,那么另一个线程可能 对它执行关闭动作(on=false),这里涉及多个线程对变量的访问,因此需要将其定义成为 volatile boolean on=true,这样其他线程对它进行改变时,可以让所有线程感知到变化,因为所 有对on变量的访问和修改都需要以共享内存为准。但是,过多地使用volatile是不必要的,因为 它会降低程序执行的效率。

    关键字synchronized可以修饰方法或者以同步块的形式来进行使用,它主要确保多个线程 在同一个时刻,只能有一个线程处于方法或者同步块中,它保证了线程对变量访问的可见性 和排他性。 在代码清单4-10所示的例子中,使用了同步块和同步方法,通过使用javap工具查看生成 的class文件信息来分析synchronized关键字的实现细节

    public class Synchronized {
        public static void main(String[] args) {
            // 对Synchronized Class对象进行加锁
            synchronized (Synchronized.class) {
            }
            // 静态同步方法,对Synchronized Class对象进行加锁 
            m();
        }
    
        public static synchronized void m() {
        }
    }
    

    在Synchronized.class同级目录执行javap–v Synchronized.class,部分相关输出如下所示:

      public static void main(java.lang.String[]);
        // 方法修饰符,表示:public staticflags: ACC_PUBLIC, ACC_STATIC
        Code:
                stack=2,locals=1,args_size=1
                0:ldc #1 // class com/murdock/books/multithread/book/Synchronized
                2:dup
                3:monitorenter // monitorenter:监视器进入,获取锁
                4:monitorexit // monitorexit:监视器退出,释放锁
                5:invokestatic #16 // Method m:()V
                8:return
        public static synchronized void m();
            // 方法修饰符,表示: public static synchronized
            flags:ACC_PUBLIC,ACC_STATIC,ACC_SYNCHRONIZED
            Code:stack=0,locals=0,args_size=0
            0:return
    
    Classfile /C:/Users/Administrator/Desktop/Synchronized.class
      Last modified 2020-6-30; size 464 bytes
      MD5 checksum 1a49ec330be96ab5f93ddbc028f3c644
      Compiled from "Synchronized.java"
    public class Synchronized
      minor version: 0
      major version: 52
      flags: ACC_PUBLIC, ACC_SUPER
    Constant pool:
       #1 = Methodref          #4.#18         // java/lang/Object."<init>":()V
       #2 = Class              #19            // Synchronized
       #3 = Methodref          #2.#20         // Synchronized.m:()V
       #4 = Class              #21            // java/lang/Object
       #5 = Utf8               <init>
       #6 = Utf8               ()V
       #7 = Utf8               Code
       #8 = Utf8               LineNumberTable
       #9 = Utf8               main
      #10 = Utf8               ([Ljava/lang/String;)V
      #11 = Utf8               StackMapTable
      #12 = Class              #22            // "[Ljava/lang/String;"
      #13 = Class              #21            // java/lang/Object
      #14 = Class              #23            // java/lang/Throwable
      #15 = Utf8               m
      #16 = Utf8               SourceFile
      #17 = Utf8               Synchronized.java
      #18 = NameAndType        #5:#6          // "<init>":()V
      #19 = Utf8               Synchronized
      #20 = NameAndType        #15:#6         // m:()V
      #21 = Utf8               java/lang/Object
      #22 = Utf8               [Ljava/lang/String;
      #23 = Utf8               java/lang/Throwable
    {
      public Synchronized();
        descriptor: ()V
        flags: ACC_PUBLIC
        Code:
          stack=1, locals=1, args_size=1
             0: aload_0
             1: invokespecial #1                  // Method java/lang/Object."<i
             4: return
          LineNumberTable:
            line 1: 0
    
      public static void main(java.lang.String[]);
        descriptor: ([Ljava/lang/String;)V
        flags: ACC_PUBLIC, ACC_STATIC
        Code:
          stack=2, locals=3, args_size=1
             0: ldc           #2                  // class Synchronized
             2: dup
             3: astore_1
             4: monitorenter
             5: aload_1
             6: monitorexit
             7: goto          15
            10: astore_2
            11: aload_1
            12: monitorexit
            13: aload_2
            14: athrow
            15: invokestatic  #3                  // Method m:()V
            18: return
          Exception table:
             from    to  target type
                 5     7    10   any
                10    13    10   any
          LineNumberTable:
            line 4: 0
            line 5: 5
            line 7: 15
            line 8: 18
          StackMapTable: number_of_entries = 2
            frame_type = 255 /* full_frame */
              offset_delta = 10
              locals = [ class "[Ljava/lang/String;", class java/lang/Object ]
              stack = [ class java/lang/Throwable ]
            frame_type = 250 /* chop */
              offset_delta = 4
    
      public static synchronized void m();
        descriptor: ()V
        flags: ACC_PUBLIC, ACC_STATIC, ACC_SYNCHRONIZED
        Code:
          stack=0, locals=0, args_size=0
             0: return
          LineNumberTable:
            line 11: 0
    }
    SourceFile: "Synchronized.java"
    

    上面class信息中,对于同步块的实现使用了monitorenter和monitorexit指令,而同步方法则 是依靠方法修饰符上的ACC_SYNCHRONIZED来完成的。无论采用哪种方式,其本质是对一 个对象的监视器(monitor)进行获取,而这个获取过程是排他的,也就是同一时刻只能有一个 线程获取到由synchronized所保护对象的监视器。

    任意一个对象都拥有自己的监视器,当这个对象由同步块或者这个对象的同步方法调用 时,执行方法的线程必须先获取到该对象的监视器才能进入同步块或者同步方法,而没有获 取到监视器(执行该方法)的线程将会被阻塞在同步块和同步方法的入口处,进入BLOCKED 状态。

    图4-2描述了对象、对象的监视器、同步队列和执行线程之间的关系。
    在这里插入图片描述
    图4-2 对象、监视器、同步队列和执行线程之间的关系 从图4-2中可以看到,任意线程对Object(Object由synchronized保护)的访问,首先要获得 Object的监视器。如果获取失败,线程进入同步队列,线程状态变为BLOCKED。当访问Object 的前驱(获得了锁的线程)释放了锁,则该释放操作唤醒阻塞在同步队列中的线程,使其重新 尝试对监视器的获取。

    等待/通知机制

    一个线程修改了一个对象的值,而另一个线程感知到了变化,然后进行相应的操作,整个 过程开始于一个线程,而最终执行又是另一个线程。前者是生产者,后者就是消费者,这种模 式隔离了“做什么”(what)和“怎么做”(How),在功能层面上实现了解耦,体系结构上具备了良 好的伸缩性,但是在Java语言中如何实现类似的功能呢?

    简单的办法是让消费者线程不断地循环检查变量是否符合预期,如下面代码所示,在 while循环中设置不满足的条件,如果条件满足则退出while循环,从而完成消费者的工作。

    while(value !=desire) {
            Thread.sleep(1000);
        }
    doSomething();
    

    上面这段伪代码在条件不满足时就睡眠一段时间,这样做的目的是防止过快的“无效”尝 试,这种方式看似能够解实现所需的功能,但是却存在如下问题。

    1)难以确保及时性。在睡眠时,基本不消耗处理器资源,但是如果睡得过久,就不能及时 发现条件已经变化,也就是及时性难以保证。
    2)难以降低开销。如果降低睡眠的时间,比如休眠1毫秒,这样消费者能更加迅速地发现 条件变化,但是却可能消耗更多的处理器资源,造成了无端的浪费。

    以上两个问题,看似矛盾难以调和,但是Java通过内置的等待/通知机制能够很好地解决 这个矛盾并实现所需的功能。 等待/通知的相关方法是任意Java对象都具备的,因为这些方法被定义在所有对象的超类 java.lang.Object上,方法和描述如表4-2所示。 表4-2 等待/通知的相关方法
    在这里插入图片描述
    等待/通知机制,是指一个线程A调用了对象O的wait()方法进入等待状态,而另一个线程B 调用了对象O的notify()或者notifyAll()方法,线程A收到通知后从对象O的wait()方法返回,进而 执行后续操作。上述两个线程通过对象O来完成交互,而对象上的wait()和notify/notifyAll()的 关系就如同开关信号一样,用来完成等待方和通知方之间的交互工作。 在代码清单4-11所示的例子中,创建了两个线程——WaitThread和NotifyThread,前者检查 flag值是否为false,如果符合要求,进行后续操作,否则在lock上等待,后者在睡眠了一段时间 后对lock进行通知,示例如下所示。

    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.concurrent.TimeUnit;
    
    public class WaitNotify {
        static boolean flag = true;
        static Object lock = new Object();
    
        public static void main(String[] args) throws Exception {
            Thread waitThread = new Thread(new Wait(), "WaitThread");
            waitThread.start();
            TimeUnit.SECONDS.sleep(1);
            Thread notifyThread = new Thread(new Notify(), "NotifyThread");
            notifyThread.start();
        }
    
        static class Wait implements Runnable {
            @Override
            public void run() {
                // 加锁,拥有lock的Monitor
                synchronized (lock) {
                    // 当条件不满足时,继续wait,同时释放了lock的锁
                    while (flag) {
                        try {
                            System.out.println(Thread.currentThread() + " flag is true. wait @ " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                            lock.wait();
                        } catch (InterruptedException e) {
                        }
                    }// 条件满足时,完成工作
                    System.out.println(Thread.currentThread() + " flag is false. running @ " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                }
            }
        }
    
        static class Notify implements Runnable {
            @Override
            public void run() {
                // 加锁,拥有lock的Monitor
                synchronized (lock) {
                    // 获取lock的锁,然后进行通知,通知时不会释放lock的锁,
                    // 直到当前线程释放了lock后,WaitThread才能从wait方法中返回
                    System.out.println(Thread.currentThread() + " hold lock. notify @ " + new SimpleDateFormat("HH:mm:ss").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").format(new Date()));
                    SleepUtils.second(5);
                }
            }
        }
    }
    

    输出如下(输出内容可能不同,主要区别在时间上)。

    Thread[WaitThread,5,main] flag is true. wait @ 20:35:28
    Thread[NotifyThread,5,main] hold lock. notify @ 20:35:29
    Thread[NotifyThread,5,main] hold lock again. sleep @ 20:35:34
    Thread[WaitThread,5,main] flag is false. running @ 20:35:39
    

    上述第3行和第4行输出的顺序可能会互换,而上述例子主要说明了调用wait()、notify()以 及notifyAll()时需要注意的细节,如下。

    1)使用wait()、notify()和notifyAll()时需要先对调用对象加锁。
    2)调用wait()方法后,线程状态由RUNNING变为WAITING,并将当前线程放置到对象的 等待队列。
    3)notify()或notifyAll()方法调用后,等待线程依旧不会从wait()返回,需要调用notify()或notifAll()的线程释放锁之后,等待线程才有机会从wait()返回。
    4)notify()方法将等待队列中的一个等待线程从等待队列中移到同步队列中,而notifyAll()
    方法则是将等待队列中所有的线程全部移到同步队列,被移动的线程状态由WAITING变为 BLOCKED。
    5)从wait()方法返回的前提是获得了调用对象的锁。

    从上述细节中可以看到,等待/通知机制依托于同步机制,其目的就是确保等待线程从 wait()方法返回时能够感知到通知线程对变量做出的修改。 图4-3描述了上述示例的过程。
    在这里插入图片描述
    WaitThread首先获取了对象的锁,然后调用对象的wait()方法,从而放弃了锁 并进入了对象的等待队列WaitQueue中,进入等待状态。由于WaitThread释放了对象的锁,NotifyThread随后获取了对象的锁,并调用对象的notify()方法,将WaitThread从WaitQueue移到 SynchronizedQueue中,此时WaitThread的状态变为阻塞状态。NotifyThread释放了锁之后, WaitThread再次获取到锁并从wait()方法返回继续执行。

    等待/通知的经典范式

    WaitNotify示例中可以提炼出等待/通知的经典范式,该范式分为两部分,分 别针对等待方(消费者)和通知方(生产者)。 等待方遵循如下原则。

    1)获取对象的锁。
    2)如果条件不满足,那么调用对象的wait()方法,被通知后仍要检查条件。
    3)条件满足则执行对应的逻辑。

    对应的伪代码如下。

     synchronized(对象) { 
     	while(条件不满足) { 
     	对象.wait(); 
     	}
     	对应的处理逻辑 
     }
    

    通知方遵循如下原则。 `

    1)获得对象的锁。
    2)改变条件。
    3)通知所有等待在对象上的线程。

    对应的伪代码如下。

    synchronized(对象) { 
    改变条件 
    对象.notifyAll();
    }
    

    管道输入/输出流

    管道输入/输出流和普通的文件输入/输出流或者网络输入/输出流不同之处在于,它主要 用于线程之间的数据传输,而传输的媒介为内存。 管道输入/输出流主要包括了如下4种具体实现:PipedOutputStream、PipedInputStream、 PipedReader和PipedWriter,前两种面向字节,而后两种面向字符。 如下代码创建了printThread,它用来接受main线程的输入,任何 main线程的输入均通过PipedWriter写入,而printThread在另一端通过PipedReader将内容读出 并打印。

    import java.io.IOException;
    import java.io.PipedReader;
    import java.io.PipedWriter;
    
    public class Piped {
        public static void main(String[] args) throws Exception {
            PipedWriter out = new PipedWriter();
            PipedReader in = new PipedReader();
            // 将输出流和输入流进行连接,否则在使用时会抛出IOException
            out.connect(in);
            Thread printThread = new Thread(new Print(in), "PrintThread");
            printThread.start();
            int receive = 0;
            try {
                while ((receive = System.in.read()) != -1) {
                    out.write(receive);
                }
            } finally {
                out.close();
            }
        }
    
        static class Print implements Runnable {
            private PipedReader in;
    
            public Print(PipedReader in) {
                this.in = in;
            }
    
            @Override
            public void run() {
                int receive = 0;
                try {
                    while ((receive = in.read()) != -1) {
                        System.out.print((char) receive);
                    }
                } catch (IOException ex) {
                }
            }
        }
    }
    

    运行该示例,输入一组字符串,可以看到被printThread进行了原样输出。

     Repeat my words.
     Repeat my words. 
    

    对于Piped类型的流,必须先要进行绑定,也就是调用connect()方法,如果没有将输入/输 出流绑定起来,对于该流的访问将会抛出异常。

    Thread.join()的使用

    如果一个线程A执行了thread.join()语句,其含义是:当前线程A等待thread线程终止之后才 从thread.join()返回。线程Thread除了提供join()方法之外,还提供了join(long millis)和join(long millis,int nanos)两个具备超时特性的方法。这两个超时方法表示,如果线程thread在给定的超时 时间里没有终止,那么将会从该超时方法中返回。 在代码清单4-13所示的例子中,创建了10个线程,编号0~9,每个线程调用前一个线程的 join()方法,也就是线程0结束了,线程1才能从join()方法中返回,而线程0需要等待main线程结 束。

    import java.util.concurrent.TimeUnit;
    
    public class Join {
        public static void main(String[] args) throws Exception {
            Thread previous = Thread.currentThread();
            for (int i = 0; i < 10; i++) {
                // 每个线程拥有前一个线程的引用,需要等待前一个线程终止,才能从等待中返回
                Thread thread = new Thread(new Domino(previous), String.valueOf(i));
                thread.start();
                previous = thread;
            }
            TimeUnit.SECONDS.sleep(5);
            System.out.println(Thread.currentThread().getName() + " terminate.");
        }
    
        static class Domino implements Runnable {
            private Thread thread;
    
            public Domino(Thread thread) {
                this.thread = thread;
            }
    
            @Override
            public void run() {
                try {
                    thread.join();
                } catch (InterruptedException e) {
                }
                System.out.println(Thread.currentThread().getName() + " terminate.");
            }
        }
    }
    

    输出如下。

    main terminate.
    0 terminate.
    1 terminate.
    2 terminate.
    3 terminate.
    4 terminate.
    5 terminate.
    6 terminate.
    7 terminate.
    8 terminate.
    9 terminate.
    

    从上述输出可以看到,每个线程终止的前提是前驱线程的终止,每个线程等待前驱线程 终止后,才从join()方法返回,这里涉及了等待/通知机制(等待前驱线程结束,接收前驱线程结 束通知)。
    Thread.java

    // 加锁当前线程对象 
    public final synchronized void join() throws InterruptedException {
    	// 条件不满足,继续等待
        while (isAlive()) {
            wait(0);
        }
        // 条件符合,方法返回 
    }
    

    当线程终止时,会调用线程自身的notifyAll()方法,会通知所有等待在该线程对象上的线 程。可以看到join()方法的逻辑结构与等待/通知经典范式一致,即加锁、循环 和处理逻辑3个步骤。

    ThreadLocal的使用

    ThreadLocal,即线程变量,是一个以ThreadLocal对象为键、任意对象为值的存储结构。这 个结构被附带在线程上,也就是说一个线程可以根据一个ThreadLocal对象查询到绑定在这个 线程上的一个值。 可以通过set(T)方法来设置一个值,在当前线程下再通过get()方法获取到原先设置的值。 在代码清单4-15所示的例子中,构建了一个常用的Profiler类,它具有begin()和end()两个 方法,而end()方法返回从begin()方法调用开始到end()方法被调用时的时间差,单位是毫秒。

    import java.util.concurrent.TimeUnit;
    
    public class Profiler {
        // 第一次get()方法调用时会进行初始化(如果set方法没有调用),每个线程会调用一次
        private static final ThreadLocal<Long> TIME_THREADLOCAL = ThreadLocal.withInitial(() -> System.currentTimeMillis());
    
        public static final void begin() {
            TIME_THREADLOCAL.set(System.currentTimeMillis());
        }
    
        public static final long end() {
            return System.currentTimeMillis() - TIME_THREADLOCAL.get();
        }
    
        public static void main(String[] args) throws Exception {
            Profiler.begin();
            TimeUnit.SECONDS.sleep(1);
            System.out.println("Cost: " + Profiler.end() + " mills");
        }
    }
    

    输出结果如下所示。 Cost: 1001 mills
    Profiler可以被复用在方法调用耗时统计的功能上,在方法的入口前执行begin()方法,在
    方法调用后执行end()方法,好处是两个方法的调用不用在一个方法或者类中,比如在AOP(面 向方面编程)中,可以在方法调用前的切入点执行begin()方法,而在方法调用后的切入点执行 end()方法,这样依旧可以获得方法的执行耗时。

    线程应用实例

    等待超时模式

    开发人员经常会遇到这样的方法调用场景:调用一个方法时等待一段时间(一般来说是给 定一个时间段),如果该方法能够在给定的时间段之内得到结果,那么将结果立刻返回,反之, 超时返回默认结果。

    前面的章节介绍了等待/通知的经典范式,即加锁、条件循环和处理逻辑3个步骤,而这种 范式无法做到超时等待。而超时等待的加入,只需要对经典范式做出非常小的改动,改动内容 如下所示。

    假设超时时间段是T,那么可以推断出在当前时间now+T之后就会超时。 定义如下变量。

    ·等待持续时间:REMAINING=T。
    ·超时时间:FUTURE=now+T。

    这时仅需要wait(REMAINING)即可,在wait(REMAINING)返回之后会将执行: REMAINING=FUTURE–now。如果REMAINING小于等于0,表示已经超时,直接退出,否则将 继续执行wait(REMAINING)。

    上述描述等待超时模式的伪代码如下。

    // 对当前对象加锁 
    public synchronized Object get(long mills) throws InterruptedException {
        long future = System.currentTimeMillis() + mills;
        long remaining = mills;
        // 当超时大于0并且result返回值不满足要求
        while ((result == null) && remaining > 0) {
            wait(remaining);
            remaining = future - System.currentTimeMillis();
        }
        return result;
    }
    

    可以看出,等待超时模式就是在等待/通知范式基础上增加了超时控制,这使得该模式相 比原有范式更具有灵活性,因为即使方法执行时间过长,也不会“永久”阻塞调用者,而是会按 照调用者的要求“按时”返回。

    一个简单的数据库连接池示例

    我们使用等待超时模式来构造一个简单的数据库连接池,在示例中模拟从连接池中获 取、使用和释放连接的过程,而客户端获取连接的过程被设定为等待超时的模式,也就是在 1000毫秒内如果无法获取到可用连接,将会返回给客户端一个null。设定连接池的大小为10 个,然后通过调节客户端的线程数来模拟无法获取连接的场景。

    首先看一下连接池的定义。它通过构造函数初始化连接的最大上限,通过一个双向队列 来维护连接,调用方需要先调用fetchConnection(long)方法来指定在多少毫秒内超时获取连接, 当连接使用完成后,需要调用releaseConnection(Connection)方法将连接放回线程池

    import java.sql.Connection;
    import java.util.LinkedList;
    
    public class ConnectionPool {
        private LinkedList<Connection> pool = new LinkedList<Connection>();
    
        public ConnectionPool(int initialSize) {
            if (initialSize > 0) {
                for (int i = 0; i < initialSize; i++) {
                    pool.addLast(ConnectionDriver.createConnection());
                }
            }
        }
    
        public void releaseConnection(Connection connection) {
            if (connection != null) {
                synchronized (pool) {
                    // 连接释放后需要进行通知,这样其他消费者能够感知到连接池中已经归还了一个连接
                    pool.addLast(connection);
                    pool.notifyAll();
                }
            }
        }
    
        // 在mills内无法获取到连接,将会返回null
        public Connection fetchConnection(long mills) throws InterruptedException {
            synchronized (pool) {
             	// 完全超时
                if (mills <= 0) {
                    while (pool.isEmpty()) {
                        pool.wait();
                    }
                    return pool.removeFirst();
                } else {
    
                    long future = System.currentTimeMillis() + mills;
                    long remaining = mills;
                    while (pool.isEmpty() && remaining > 0)
    
                    {
                        pool.wait(remaining);
                        remaining = future - System.currentTimeMillis();
                    }
    
                    Connection result = null;
                    if (!pool.isEmpty())
    
                    {
                        result = pool.removeFirst();
                    }
                    return result;
                }
            }
        }
    }
    

    由于java.sql.Connection是一个接口,最终的实现是由数据库驱动提供方来实现的,考虑到 只是个示例,我们通过动态代理构造了一个Connection,该Connection的代理实现仅仅是在 commit()方法调用时休眠100毫秒

    ConnectionDriver.java

    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    import java.sql.Connection;
    import java.util.concurrent.TimeUnit;
    
    public class ConnectionDriver {
        static class ConnectionHandler implements InvocationHandler {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                if (method.getName().equals("commit")) {
                    TimeUnit.MILLISECONDS.sleep(100);
                }
                return null;
            }
        }
    
        // 创建一个Connection的代理,在commit时休眠100毫秒
        public static final Connection createConnection() {
            return (Connection) Proxy.newProxyInstance(ConnectionDriver.class.getClassLoader(), new Class[]{Connection.class}, new ConnectionHandler());
        }
    }
    

    下面通过一个示例来测试简易数据库连接池的工作情况,模拟客户端ConnectionRunner获 取、使用、最后释放连接的过程,当它使用时连接将会增加获取到连接的数量,反之,将会增 加未获取到连接的数量
    ConnectionPoolTest.java

    import java.sql.Connection;
    import java.util.concurrent.CountDownLatch;
    import java.util.concurrent.atomic.AtomicInteger;
    
    public class ConnectionPoolTest {
        static ConnectionPool pool = new ConnectionPool(10);
        // 保证所有ConnectionRunner能够同时开始
        static CountDownLatch start = new CountDownLatch(1);
        // main线程将会等待所有ConnectionRunner结束后才能继续执行
        static CountDownLatch end;
    
        public static void main(String[] args) throws Exception { // 线程数量,可以修改线程数量进行观察
            int threadCount = 10;
            end = new CountDownLatch(threadCount);
            int count = 20;
            AtomicInteger got = new AtomicInteger();
            AtomicInteger notGot = new AtomicInteger();
            for (int i = 0; i < threadCount; i++) {
                Thread thread = new Thread(new ConnetionRunner(count, got, notGot), "ConnectionRunnerThread");
                thread.start();
            }
            start.countDown();
            end.await();
            System.out.println("total invoke: " + (threadCount * count));
            System.out.println("got connection: " + got);
            System.out.println("not got connection " + notGot);
        }
    
        static class ConnetionRunner implements Runnable {
            int count;
            AtomicInteger got;
            AtomicInteger notGot;
    
            public ConnetionRunner(int count, AtomicInteger got, AtomicInteger notGot) {
                this.count = count;
                this.got = got;
                this.notGot = notGot;
            }
    
            public void run() {
                try {
                    start.await();
                } catch (Exception ex) {
                }
                while (count > 0) {
                    try {
                        // 从线程池中获取连接,如果1000ms内无法获取到,将会返回null
                        // 分别统计连接获取的数量got和未获取到的数量notGot
                        Connection connection = pool.fetchConnection(1000);
                        if (connection != null) {
                            try {
                                connection.createStatement();
                                connection.commit();
                            } finally {
                                pool.releaseConnection(connection);
                                got.incrementAndGet();
                            }
                        } else {
                            notGot.incrementAndGet();
                        }
                    } catch (Exception ex) {
                    } finally {
                        count--;
                    }
                }
                end.countDown();
            }
        }
    }
    

    上述示例中使用了CountDownLatch来确保ConnectionRunnerThread能够同时开始执行,并 且在全部结束之后,才使main线程从等待状态中返回。当前设定的场景是10个线程同时运行 获取连接池(10个连接)中的连接,通过调节线程数量来观察未获取到连接的情况。线程数、总 获取次数、获取到的数量、未获取到的数量以及未获取到的比率。 CPU: i7-3635QM,内存为8GB,实际输出可能与此表不同。
    在这里插入图片描述
    表4-3 线程数量与连接获取的关系 从表中的数据统计可以看出,在资源一定的情况下(连接池中的10个连接),随着客户端 线程的逐步增加,客户端出现超时无法获取连接的比率不断升高。虽然客户端线程在这种超 时获取的模式下会出现连接无法获取的情况,但是它能够保证客户端线程不会一直挂在连接 获取的操作上,而是“按时”返回,并告知客户端连接获取出现问题,是系统的一种自我保护机 制。数据库连接池的设计也可以复用到其他的资源获取的场景,针对昂贵资源(比如数据库连 接)的获取都应该加以超时限制。

    线程池技术及其示例

    对于服务端的程序,经常面对的是客户端传入的短小(执行时间短、工作内容较为单一) 任务,需要服务端快速处理并返回结果。如果服务端每次接受到一个任务,创建一个线程,然 后进行执行,这在原型阶段是个不错的选择,但是面对成千上万的任务递交进服务器时,如果 还是采用一个任务一个线程的方式,那么将会创建数以万记的线程,这不是一个好的选择。因 为这会使操作系统频繁的进行线程上下文切换,无故增加系统的负载,而线程的创建和消亡 都是需要耗费系统资源的,也无疑浪费了系统资源。

    线程池技术能够很好地解决这个问题,它预先创建了若干数量的线程,并且不能由用户 直接对线程的创建进行控制,在这个前提下重复使用固定或较为固定数目的线程来完成任务 的执行。这样做的好处是,一方面,消除了频繁创建和消亡线程的系统资源开销,另一方面, 面对过量任务的提交能够平缓的劣化。 下面先看一个简单的线程池接口定义

    public interface ThreadPool<Job extends Runnable> {
        // 执行一个Job,这个Job需要实现Runnable
        void execute(Job job);
    
        // 关闭线程池
        void shutdown();
    
        // 增加工作者线程 
        void addWorkers(int num);
    
        // 减少工作者线程 
        void removeWorker(int num);
    
        // 得到正在等待执行的任务数量
        int getJobSize();
    }
    

    客户端可以通过execute(Job)方法将Job提交入线程池执行,而客户端自身不用等待Job的 执行完成。除了execute(Job)方法以外,线程池接口提供了增大/减少工作者线程以及关闭线程 池的方法。这里工作者线程代表着一个重复执行Job的线程,而每个由客户端提交的Job都将进入到一个工作队列中等待工作者线程的处理。 接下来是线程池接口的默认实现
    DefaultThreadPool.java

    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.LinkedList;
    import java.util.List;
    import java.util.concurrent.atomic.AtomicLong;
    
    public class DefaultThreadPool<Job extends Runnable> implements ThreadPool<Job> {
    
        // 线程池最大限制数
        private static final int MAX_WORKER_NUMBERS = 10;
    
        // 线程池默认的数量
        private static final int DEFAULT_WORKER_NUMBERS = 5;
    
        // 线程池最小的数量
        private static final int MIN_WORKER_NUMBERS = 1;
    
        // 这是一个工作列表,将会向里面插入工作
        private final LinkedList<Job> jobs = new LinkedList<>();
    
        // 工作者列表
        private final List<Worker> workers = Collections.synchronizedList(new ArrayList<>());
    
        // 工作者线程的数量
        private int workerNum = DEFAULT_WORKER_NUMBERS;
        
        // 线程编号生成
        private AtomicLong threadNum = new AtomicLong();
    
        public DefaultThreadPool() {
            initializeWokers(DEFAULT_WORKER_NUMBERS);
        }
    
        public DefaultThreadPool(int num) {
            workerNum = num > MAX_WORKER_NUMBERS ? MAX_WORKER_NUMBERS : num < MIN_WORKER_NUMBERS ? MIN_WORKER_NUMBERS :
                    num;
            initializeWokers(workerNum);
        }
    
        @Override
        public void execute(Job job) {
            if (job != null) {
                // 添加一个工作,然后进行通知
                synchronized (jobs) {
                    jobs.addLast(job);
                    jobs.notify();
                }
            }
        }
    
        @Override
        public void shutdown() {
            for (Worker worker : workers) {
                worker.shutdown();
            }
        }
    
        @Override
        public void addWorkers(int num) {
            synchronized (jobs) {
                // 限制新增的Worker数量不能超过最大值
                if (num + this.workerNum > MAX_WORKER_NUMBERS) {
                    num = MAX_WORKER_NUMBERS - this.workerNum;
                }
                initializeWokers(num);
                this.workerNum += num;
            }
        }
    
        @Override
        public void removeWorker(int num) {
            synchronized (jobs) {
                if (num >= this.workerNum) {
                    throw new IllegalArgumentException("beyond workNum");
                }
                // 按照给定的数量停止Worker
                int count = 0;
                while (count < num) {
                    Worker worker = workers.get(count) if (workers.remove(worker)) {
                        worker.shutdown();
                        count++;
                    }
                } this.workerNum -= count;
            }
        }
    
        @Override
        public int getJobSize() {
            return jobs.size();
        }
    
        // 初始化线程工作者
        private void initializeWokers(int num) {
            for (int i = 0; i < num; i++) {
                Worker worker = new Worker();
                workers.add(worker);
                Thread thread = new Thread(worker, "ThreadPool-Worker-" + threadNum.incrementAndGet());
                thread.start();
            }
        }
    
        // 工作者,负责消费任务
        class Worker implements Runnable {
            // 是否工作
            private volatile boolean running = true;
    
            @Override
            public void run() {
                while (running) {
                    Job job = null;
                    synchronized (jobs) {
                        // 如果工作者列表是空的,那么就wait
                        while (jobs.isEmpty()) {
                            try {
                                jobs.wait();
                            } catch (InterruptedException ex) {
                                // 感知到外部对WorkerThread的中断操作,返回
                                Thread.currentThread().interrupt();
                                return;
                            }
                        }
                        // 取出一个
                        job = jobs.removeFirst();
                    }
                    if (job != null) {
                        try {
                            job.run();
                        } catch (Exception ex) {
                            // 忽略Job执行中的Exception
                        }
                    }
                }
            }
    
            public void shutdown() {
                running = false;
            }
        }
    }
    

    从线程池的实现可以看到,当客户端调用execute(Job)方法时,会不断地向任务列表jobs中 添加Job,而每个工作者线程会不断地从jobs上取出一个Job进行执行,当jobs为空时,工作者线 程进入等待状态。

    添加一个Job后,对工作队列jobs调用了其notify()方法,而不是notifyAll()方法,因为能够 确定有工作者线程被唤醒,这时使用notify()方法将会比notifyAll()方法获得更小的开销(避免 将等待队列中的线程全部移动到阻塞队列中)。

    可以看到,线程池的本质就是使用了一个线程安全的工作队列连接工作者线程和客户端 线程,客户端线程将任务放入工作队列后便返回,而工作者线程则不断地从工作队列上取出 工作并执行。当工作队列为空时,所有的工作者线程均等待在工作队列上,当有客户端提交了 一个任务之后会通知任意一个工作者线程,随着大量的任务被提交,更多的工作者线程会被 唤醒。

    一个基于线程池技术的简单Web服务器

    目前的浏览器都支持多线程访问,比如说在请求一个HTML页面的时候,页面中包含的图 片资源、样式资源会被浏览器发起并发的获取,这样用户就不会遇到一直等到一个图片完全 下载完成才能继续查看文字内容的尴尬情况。

    如果Web服务器是单线程的,多线程的浏览器也没有用武之地,因为服务端还是一个请求 一个请求的顺序处理。因此,大部分Web服务器都是支持并发访问的。常用的Java Web服务器, 如Tomcat、Jetty,在其处理请求的过程中都使用到了线程池技术。

    下面通过使用前一节中的线程池来构造一个简单的Web服务器,这个Web服务器用来处理 HTTP请求,目前只能处理简单的文本和JPG图片内容。这个Web服务器使用main线程不断地接 受客户端Socket的连接,将连接以及请求提交给线程池处理,这样使得Web服务器能够同时处 理多个客户端请求

    import java.io.*;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    public class SimpleHttpServer {
    
        // 处理HttpRequest的线程池 
        static ThreadPool<HttpRequestHandler> threadPool = new DefaultThreadPool<>(1);
        
        // SimpleHttpServer的根路径 
        static String basePath;
        
        static ServerSocket serverSocket;
        
        // 服务监听端口 
        static int port = 8080;
    
        public static void setPort(int port) {
            if (port > 0) {
                SimpleHttpServer.port = port;
            }
        }
    
        public static void setBasePath(String basePath) {
            if (basePath != null && new File(basePath).exists() && new File(basePath).isDirectory()) {
                SimpleHttpServer.basePath = basePath;
            }
        }// 启动SimpleHttpServer 
    
        public static void start() throws Exception {
            serverSocket = new ServerSocket(port);
    
            Socket socket = null;
            while ((socket = serverSocket.accept()) != null)
    
            { // 接收一个客户端Socket,生成一个HttpRequestHandler,放入线程池执行 
                threadPool.execute(new HttpRequestHandler(socket));
            }
            serverSocket.close();
        }
    
        static class HttpRequestHandler implements Runnable {
            private Socket socket;
    
            public HttpRequestHandler(Socket socket) {
                this.socket = socket;
            }
    
            @Override
            public void run() {
                String line = null;
                BufferedReader br = null;
                BufferedReader reader = null;
                PrintWriter out = null;
                InputStream in = null;
                try {
                    reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                    String header = reader.readLine();
                    // 由相对路径计算出绝对路径
                    String filePath = basePath + header.split(" ")[1];
                    out = new PrintWriter(socket.getOutputStream());
                    // 如果请求资源的后缀为jpg或者ico,则读取资源并输出 
                    if (filePath.endsWith("jpg") || filePath.endsWith("ico")) {
                        in = new FileInputStream(filePath);
                        ByteArrayOutputStream baos = new ByteArrayOutputStream();
                        int i = 0;
                        while ((i = in.read()) != -1) {
                            baos.write(i);
                        }
                        byte[] array = baos.toByteArray();
                        out.println("HTTP/1.1 200 OK");
                        out.println("Server: Molly");
                        out.println("Content-Type: image/jpeg");
                        out.println("Content-Length: " + array.length);
                        out.println("");
                        socket.getOutputStream().write(array, 0, array.length);
                    } else {
                        br = new BufferedReader(new InputStreamReader(new FileInputStream(filePath)));
                        out = new PrintWriter(socket.getOutputStream());
                        out.println("HTTP/1.1 200 OK");
                        out.println("Server: Molly");
                        out.println("Content-Type: text/html; charset=UTF-8");
                        out.println("");
                        while ((line = br.readLine()) != null) {
                            out.println(line);
                        }
                    }
                    out.flush();
                } catch (Exception ex) {
                    out.println("HTTP/1.1 500");
                    out.println("");
                    out.flush();
                } finally {
                    close(br, in, reader, out, socket);
                }
            }
        }
    
        // 关闭流或者Socket 
        private static void close(Closeable... closeables) {
            if (closeables != null) {
                for (Closeable closeable : closeables) {
                    try {
                        closeable.close();
                    } catch (Exception ex) {
                    }
                }
            }
        }
    }
    

    该Web服务器处理用户请求的时序图,SimpleHttpServer在建立了与客户端的连接之后,并不会处理客户端的请求, 而是将其包装成HttpRequestHandler并交由线程池处理。在线程池中的Worker处理客户端请求 的同时,SimpleHttpServer能够继续完成后续客户端连接的建立,不会阻塞后续客户端的请求。 接下来,通过一个测试对比来认识线程池技术带来服务器吞吐量的提高。我们准备了一 个简单的HTML页面
    在这里插入图片描述
    Index.html

    <html>
    <head><title>测试页面</title></head>
    <body><h1>第一张图片</h1> <img src="1.jpg"/>
    <h1>第二张图片</h1> <img src="2.jpg"/>
    <h1>第三张图片</h1> <img src="3.jpg"/></body>
    </html>
    

    将SimpleHttpServer的根目录设定到该HTML页面所在目录,并启动SimpleHttpServer,通 过Apache HTTP server benchmarking tool(版本2.3)来测试不同线程数下,SimpleHttpServer的吞 吐量表现。 测试场景是5000次请求,分10个线程并发执行,测试内容主要考察响应时间(越小越好) 和每秒查询的数量(越高越好),测试结果如表所示(CPU:i7-3635QM,内存为 8GB,实际输出可能与此表不同)。测试结果 可以看到,随着线程池中线程数量的增加,SimpleHttpServer的吞吐量不断增大,响应时间 不断变小,线程池的作用非常明显。 但是,线程池中线程数量并不是越多越好,具体的数量需要评估每个任务的处理时间,以 及当前计算机的处理器能力和数量。使用的线程过少,无法发挥处理器的性能;使用的线程过 多,将会增加系统的无故开销,起到相反的作用。

    本章小结

    本章从介绍多线程技术带来的好处开始,讲述了如何启动和终止线程以及线程的状态, 详细阐述了多线程之间进行通信的基本方式和等待/通知经典范式。在线程应用示例中,使用 了等待超时、数据库连接池以及简单线程池3个不同的示例巩固本章前面章节所介绍的Java多 线程基础知识。最后通过一个简单的Web服务器将上述知识点串联起来,加深我们对这些知识 点的理解。


    先赞后看,养成习惯。欢迎收看7me,关注我,跑的更慢一点

    关注
    文章持续更新,可以微信搜索「 熊猫程序猿a 」第一时间催更
    公众号

    展开全文
  • 关于线程和多进程编程,下面描述正确的是(): 正确答案: A C D 多进程里,子进程可获得父进程的所有堆和栈的数据;而线程会与同进程的其他线程共享数据,拥有自己的栈空间 线程因为有自己的...

    关于多线程和多进程编程,下面描述正确的是():

    正确答案: A C D

    多进程里,子进程可获得父进程的所有堆和栈的数据;而线程会与同进程的其他线程共享数据,拥有自己的栈空间
    线程因为有自己的独立栈空间且共享数据,所有执行的开销相对较大,同时不利于资源管理和保护
    线程的通信速度更快,切换更快,因为他们在同一地址空间内
    线程使用公共变量/内存时需要使用同步机制,因为他们在同一地址空间内
    因多线程里,每个子进程有自己的地址空间,因此相互之间通信时,线程不如进程灵活和方便



    线程和进程的区别联系:
    1,进程:子进程是父进程的复制品。子进程获得父进程数据空间、堆和栈的复制品。
    2,线程:相对与进程而言,线程是一个更加接近与执行体的概念,它可以与同进程的其他线程共享数据,但拥有自己的栈空间,拥有独立的执行序列。 
    两者都可以提高程序的并发度,提高程序运行效率和响应时间。 
    线程和进程在使用上各有优缺点:线程执行开销小,但不利于资源管理和保护;而进程正相反。同时,线程适合于在SMP机器上运行,而进程则可以跨机器迁移。
    根本区别就一点:用多进程每个进程有自己的地址空间(address space),线程则共享地址空间。所有其它区别都是由此而来的: 
    1、速度:线程产生的速度快,线程间的通讯快、切换快等,因为他们在同一个地址空间内。 
    2、资源利用率:线程的资源利用率比较好也是因为他们在同一个地址空间内。 
    3、同步问题:线程使用公共变量/内存时需要使用同步机制还是因为他们在同一个地址空间内

    展开全文
  • 实现多线程正确姿势

    千次阅读 2020-03-09 18:20:15
    /** * 描述: 用Runnable方式创建线程 */ public class RunnableStyle implements Runnable{ public static void main(String[] args) { Thread thread = new Thread(new RunnableStyle()); thread.start(); } @...

    网上和书籍的各种说法:鱼龙混杂

    在这里插入图片描述

    正确的说法

    在这里插入图片描述

    方法一:实现Runnable接口

    package threadcoreknowledge.createthreads;
    
    /**
     * 描述:     用Runnable方式创建线程
     */
    public class RunnableStyle implements Runnable{
    
        public static void main(String[] args) {
            Thread thread = new Thread(new RunnableStyle());
            thread.start();
        }
    
        @Override
        public void run() {
            System.out.println("用Runnable方法实现线程");
        }
    }
    
    

    方法二:继承Thread

    package threadcoreknowledge.createthreads;
    
    /**
     * 描述:     用Thread方式实现线程
     */
    public class ThreadStyle extends Thread{
    
        @Override
        public void run() {
            System.out.println("用Thread类实现线程");
        }
    
        public static void main(String[] args) {
            new ThreadStyle().start();
        }
    }
    

    实现Runnable接口更好一些原因如下:

    run方法源码解析:

        /* What will be run. */
        private Runnable target;
    
        @Override
        public void run() {
            if (target != null) {
                target.run();
            }
        }
    


    实现Runnable接口最终会调用 target.run() 但是继承Thread类的run方法整个都被重写。

    继承Thread有如下缺点:

    1、从代码的架构考虑的话:run方法里面的内容(对应我们具体执行的任务),它应该和我们和线程的创建、运行等机制也就是Thread类是解耦的,所以不应该把这两个事情混为一谈,从解耦的角度是有缺点的。
    2、如果说继承了Thread类,用这种方法的话,每次如果我们需要新建一个任务,只能去新建一个独立的线程,而新建一个独立的线程这样的损耗是比较大的,需要创建、执行、销毁等,而如果使用Runnable接口的话,后面就会使用线程池等一些工具,就可以大大减小创建线程带来的损耗,从资源节约的角度上也是优缺点的。
    3、Java不支持多继承,如果继承了Thread类就不可以再去继承其他的类,大大限制了可扩展性。

    同时使用这两种方法会怎么样:

    /**
     * 描述:     同时使用Runnable和Thread两种实现线程的方式
     */
    public class BothRunnableThread {
    
        public static void main(String[] args) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("我来自Runnable");
                }
            }) {
                @Override
                public void run() {
                    System.out.println("我来自Thread");
                }
            }.start();
        }
    }
    

    运行之后:
    在这里插入图片描述
    分析:这是因为run方法被重写了,这是target.run就不会执行了。

    在这里插入图片描述

    常见错误观点:

    1、“线程池创建线程也是一种新建线程的方式”
    虽然利用线程成可以创建线程,但是这只是表象,不属于创建线程的本质。通过深入Executors的源码可以看到,在线程池的内部,也是新建了Thread类来执行这些任务的。
    在这里插入图片描述
    2、“通过Callable和FutureTAsk创建线程,也算是一种新建线程的方式。”
    3、“无返回值是实现runnable接口,有返回值是实现callable接口,所以callable是新的实现线程的方式”
    4、“匿名内部类”
    5、“Lambda表达式”

    综上所述,这些错误观点的本质都是离不开Runnable接口和Thread类的。都属于表明现象。多线程的实现方式,在代码中写法千变万化,但本质不变。

    常见面试题。

    在这里插入图片描述

    在这里插入图片描述

    展开全文
  • ``` public class Test { List list= new java.util.ArrayList(); public void test() { synchronized ( list) { // --A list.add( String.valueOf(System.currentTimeMillis())); } } ...A. test方法中必须增加...
  • 1、进程退出  exit(); 2、线程退出  pthread_exit();
  • 如何正确停止线程

    2019-11-10 12:19:05
    在Java中,最好的停止线程的方式是使用中断 Interrupt,但是这仅仅是会通知到被终止的线程“你该停止运行了”,被终止的线程自身拥有决定权(决定是否、以及何时停止),这依赖于请求停止方和被停止方都遵守一种约定...
  • Java多线程初探——正确停止线程

    千次阅读 2016-06-04 15:18:49
    在Java中还提供了一个方法,interrupt()方法,在jdk文档中这样描述:中断线程,这个方法真的能将线程停止吗?现在用一个实例尝试一下。 先写一个线程YieldRunnable.java public class YieldRunnable ...
  • java 如何正确的停止线程

    千次阅读 2018-10-24 17:11:48
    目录java 如何正确的停止线程错误方式一:使用stop()代码示例:正确方式:使用退出标记另一种错误方式:interrupt() java 如何正确的停止线程 错误方式一:使用stop() stop()方法在jdk中被标记为@deprecated,并...
  • [转] Qt多线程正确用法

    千次阅读 2016-12-27 16:50:07
    QThread的常见特性: run()是线程的入口,就像main()对于应用程序的作用。QThread中对run()的默认实现调用了exec(),从而创建一个QEventLoop对象,由其处理该线程事件队列(每一个线程都有一个...简单用代码描述
  • 正确使用Qt多线程

    千次阅读 2016-05-11 22:11:10
    QThread的常见特性: 转自 - braverong的个人空间 - 开源中国社区 run()是线程的入口,就像main()对于应用程序的作用。QThread中对run()的默认实现调用了...简单用代码描述如下: 1 2 3 4 5
  • 本文将讲解Java中三种场景下如何正确的停止线程,分别是普通情况、堵塞状态、循环中堵塞状态,三种情况下如何正确的停止线程线程在三种场景下的停止方式,都是通过`interrupt()`方法来停止的,但特殊的是停止循环...
  • 下列关于线程调度的叙述中,错误的是()。 正确答案: B E 你的答案: A E F (错误) 调用线程的sleep()方法,可以使比当前线程优先级低的线程获得运行机会 调用线程的yeild()方法,只会使与当前...
  • 在上一篇文章中,笔者分享并用“学生上课回答问题”的情景解释了Java线程的几个常用方法以及它们的作用。那么,很自然地,我们就会想到线程启动并执行之后,什么时候才能停止或者什么时候让它停止呢?这就是笔者想在...
  • 关于线程的经典解答

    千次阅读 2016-04-22 20:58:10
    理解线程是非常关键的,因为每个进程至少需要一个线程。本章将更加详细地介绍线程的知识。尤其是要讲述进程与线程之间存在多大的差别,它们各自具有什么作用。还要介绍系统如何使用线程内核对象来管理线程。与进程...
  • 我们前面所讲的一切其实都只是为了一个目标那就是能正确发布一个线程安全的对象。 一:线程封闭 这个很好理解如果一个变量是在一个线程中完成的状态改变,那么这个变量肯定是线程安全的。 我们常使用的是栈封闭和...
  • 线程

    千次阅读 2017-01-09 16:22:26
    在传统操作系统中,每个进程有一个地址空间和一个控制线程,这是进程的定义,经常存在在一个地址空间中准并行运行多个控制线程的情形,这些线程像分离的进程。
  • 关于线程渲染

    千次阅读 2012-09-12 10:20:29
    困扰了一个多月的问题,今天终于有个阶段性的了结了,虽然不知道算不算真正的了结. 多核的cpu现在是...引擎一开始没有在多线程方面作任何的考虑,因为我从来就不喜欢多线程,这方面的思考能力不强,而且一开始写
  • 尽管OS X利用这些核心可以随时执行系统相关任务,你自己的应用也可以通过线程利用他们。 什么是线程线程是一个相对轻量级的方法在应用内部实现多路径执行。在系统层面上,程序一起运行,系统为每个程序发放执行...
  • Redis到底是单线程还是多线程

    千次阅读 2020-05-18 15:28:54
    一、Redis到底有多快 Redis采用的是基于内存的采用的是单进程单线程模型的 KV 数据库,由C语言编写,官方提供的数据是可以达到100000+的... 此时,这张图反映了一个数量级,希望大家在面试的时候可以正确描述出来,不
  • 线程中断到底是什么

    千次阅读 2020-03-27 09:28:41
    我们如何让线程安全的...stop(),resume(),suspend()已不建议使用,stop()会导致线程不会正确释放资源,suspend()容易导致死锁。 停止多线程: public void stop(); 销毁多线程: public void destory(); 挂起...
  • 下列关于线程调度的叙述中,错误的是()。 正确答案: B E 你的答案: A E F (错误) 调用线程的sleep()方法,可以使比当前线程优先级低的线程获得运行机会 调用线程的yeild()方法,只会使与当前...
  • 关于线程阻塞的问题,留着看了

    千次阅读 2016-06-06 19:10:51
    线程在执行中如果遇到(I/O 操作)如磁盘读写或网络通信,通常要耗费较长的时间,这时操作系统会剥夺这个线程的 CPU 控制权,使其暂停执行,同时将资源让给其他的工作线程,这种线程调度方式称为 阻塞。...
  • 为了描述方便,这里假设主线程调用Send()往通信口发送一个数据包,然后阻塞等待回包才继续往下执行。另一个线程(通信线程)不断从通信口中接收数据并解析成数据包,然后唤醒主线程。下面是按网上给的最简单的方法:...
  • Windows 下进程和线程描述,哪些是对的:C A 操作系统的一个程序必须有一个进程,但是不必须有一个线程 B 进程有自己的栈空间,而线程只共享父进程的栈空间 C 线程必从属于一个进程 D 线程可以更改从属的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 195,482
精华内容 78,192
关键字:

关于线程的描述正确的是