转载

Java基础复习之旅(3)-线程篇

Java基础复习之旅(3)-线程篇

1. 基本概念

1.1 线程、进程、协程是什么？

首先要知道，

一个进程可以有多个线程，一个线程可以有多个协程。

先说说线程跟进程：
  • 进程是资源分配的最小单元，线程是CPU调度的最小单位。所有与进程相关的资源，均被记录在PCB(印刷电路板)中。
  • 线程隶属于某一个进程，共享进程的资源。线程只由堆栈寄存器，程序计数器和栈堆指针组成。
  • 进程有独立的地址空间，彼此之间相互不影响，可以看做一个独立的应用。而线程只是进程的执行路径。
  • 总结成一句话就是： 对操作系统来说，进程是最小的资源管理单元，线程的最小的执行单元。

协程平时听的比较少，所以这里引用维基百科的解释：

  • 协程是计算机程序的一类组件，推广了协作式多任务的子程序，允许执行被挂起与被恢复。
  • 协程是一种比线程更加轻量级的存在，并且协程与线程最大的区别就在于。 线程是抢占式多任务的，协程是协作式多任务的。 这就意味着协程提供并发性而非并行性，所以不需要加锁的操作。
Java基础复习之旅(3)-线程篇

1.2 run()方法与start()方法的区别？

start()方法是运行多线程的主方法，在start()方法内部，通过调用run()方法启动这个线程。run()方法用以启动一个线程，然后主线程立刻返回。该启动的线程不会马上执行，而是在等待队列中等待CPU的调度。

1.3 进程的状态与线程的状态

我们知道在操作系统中，进程有五种状态： 新建、运行、就绪、阻塞、终止。 注意这只是比较广泛的说法，不同的操作系统对进程状态定义也有不同。

Java基础复习之旅(3)-线程篇

但是在Java中，Thread类定义了六种线程状态，千万不要混淆了：

Java基础复习之旅(3)-线程篇
  • 1. 初始(NEW) ：新创建了一个线程对象，但是还没有调用start()方法。
  • 2. 可运行(RUNNABLE)： 分为就绪状态与运行中状态。
    在调用start()方法之后线程就进入就绪状态，等待CPU的调度。注意：线程在睡眠和挂起中恢复的时候也会进入就绪状态。
    就绪状态的线程得到了CPU的时间片，线程被设置为当前线程，开始执行run()方法,线程进入运行中状态。
  • 3. 阻塞(BLOCKED) ：表示线程由于锁的原因造成了阻塞。
  • 4. 等待(WAITING) 比如使用Thread.sleep()方法，CPU不会给线程分配时间，使得线程处于等待状态。处于该状态的线程需要被期待对象所唤醒，否则会处于无限期的等待状态。
  • 5. 超时等待(TIME_WAITTING) ：与等待转态的区别就在于，他不会无限期的等待，当达到一定的时间之后，他们会被自动的唤醒。
  • 6.终止状态(TERMINATED) ：当线程的run()方法执行完毕时，或者主线程的main()执行完毕时，我们就认为这个线程终止了。注意：线程一旦终止了，就不能调用start()方法。

补充： 进入Thread.getState()方法可以发现在JVM中也定义了六种线程的状态：

public State getState() {
        // get current thread state
        return sun.misc.VM.toThreadState(threadStatus);
    }
复制代码

sun.misc包中的VM类中的线程状态：

private static final int JVMTI_THREAD_STATE_ALIVE = 1;
    private static final int JVMTI_THREAD_STATE_TERMINATED = 2;
    private static final int JVMTI_THREAD_STATE_RUNNABLE = 4;
    private static final int JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER = 1024;
    private static final int JVMTI_THREAD_STATE_WAITING_INDEFINITELY = 16;
    private static final int JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT = 32;
复制代码

1.4 Synchronized与ReentrantLock的相同点与不同点

  • 相同点在于，二者都是采用加锁的方式实现同步，而且都是阻塞式的同步。
  • 区别在于，Synchronized是Java的关键字，需要JVM去实现。而ReentrantLock是JDK1.5之后提供的API层面的互斥锁，需要lock()，unlock()方法以及try/catch去实现。

1.5 新建线程的几种方法

  • 通过继承Thread类，重写run()方法。
  • 通过实现Callable接口。
  • 通过实现Runnable接口。

1.6 实现线程安全的方法

  • 使用不可变的类：Integer/String
  • 使用synchronized同步块同步对象

synchronized({Object})可以用以锁住一个对象，同样synchronized还可以用在方法签名上。那么问题来了，对于非静态方法，synchronized很明显是锁住调用这个方法的实体，那么对于静态方法，锁住的是什么？答案是锁住的是类在JVM中所存储的Class对象。

  • 使用ReentrantLock，配合lock(),unLock()使用。相比于synchronized，ReentrantLock更灵活，可以在这个方法中加锁，在其他方法中将锁释放。
  • 使用java.util.concurrent包下面的方法去替换在多线程情况下不安全的实现，比如HashMap可以替换为ConcurrentHashMap。
  • 使用Collections.synchronized{Colleation}
private static List<Integer> list = Collections.synchronizedList(new ArrayList<>());
复制代码
  • 使用原子操作：AtomicInteger/AtomicLong/AtomicBoolean

1.7 wait()，notify()，notifyAll()方法

首先，他们都是Object类中的方法，接下来看下面这个例子：

public static void main(String[] args) {
        new Thread(new Thread1()).start();
        new Thread(new Thread2()).start();
        new Thread(new Thread3()).start();
    }

    static class Thread1 extends Thread {
        @Override
        public void run() {
            System.out.println("Thread1");
        }
    }

    static class Thread2 extends Thread {
        @Override
        public void run() {
            System.out.println("Thread2");
        }
    }

    static class Thread3 extends Thread {
        @Override
        public void run() {
            System.out.println("Thread3");
        }
    }
复制代码

这里我开辟了三个线程，分别去实现自己的方法。结果很明显，就是按顺序打印结果：

Thread1
Thread2
Thread3
复制代码

但是当我对Thread1使用wait()方法时，

static class Thread1 extends Thread {
        @Override
        public void run() {
            synchronized (lock){
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("Thread1");
        }
    }
复制代码

Thread会交出自己所持有的锁，让其他进程去争夺这个锁，而自己就一直等待着其他线程的唤醒。

Java基础复习之旅(3)-线程篇

他就一直在这等啊，直到我们在其他线程中使用notify()方法将其唤醒：

static class Thread3 extends Thread {
        @Override
        public void run() {
            synchronized (lock){
                lock.notify();
            }
            System.out.println("Thread3");
        }
    }
复制代码

这时候，执行的顺序也改变了：

Thread2
Thread3
Thread1
复制代码

那么notifyAll()就是唤醒其他正在等待的线程，然后让他们之间重新去争夺锁：

static class Thread1 extends Thread {
        @Override
        public void run() {
            synchronized (lock){
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("Thread1");
        }
    }

    static class Thread2 extends Thread {
        @Override
        public void run() {
            synchronized (lock){
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("Thread2");
        }
    }

    static class Thread3 extends Thread {
        @Override
        public void run() {
            synchronized (lock){
                lock.notifyAll();
            }
            System.out.println("Thread3");
        }
    }
复制代码

结果：

Thread1
Thread2
Thread3
复制代码

注意：使用Object的wait()，notify()，notifyAll()方法都需要持有这个对象的监视器，就是代码中的synchronized()。java doc中的原话：

* This method should only be called by a thread that is the owner
* of this object's monitor.
复制代码

否则会报出 IllegalMonitorStateException 异常。

8.什么是线程池？

由于Java的线程调度完全依赖于操作系统，所以每个线程都会占用一定的资源，进而我们不可能随心所欲的去开辟线程。所以，这时候就需要线程池了，线程池就是预先在内存中开辟一块资源，专门用于线程的调度。当需要线程执行任务时，就通过线程池管理器来实现线程的分配。

9.有哪些创建线程池的方法，他们之间的区别在哪？

java.util.concurrent包中的Executors类中，封装了四种开辟线程池的方法。

  • newFixedThreadPool—数量固定的线程池
    规定最大的数量，超过这个数量后进来的线程任务放入等待数列中。
  • newSingleThreadExecutor—只有一个线程的线程池
    一次只能执行一个任务。
  • newCachedThreadPool-缓存型线程池
    缓存型即在核心线程达到最大值之前，有新的任务就在线程池中加入新的线程，即使有空闲的线程也不复用。达到最大线程后，再复用空闲的线程。没有空余的线程则新建临时线程，用于处理大量短时间工作的线程池。
  • new ScheduledThreadPool—计划型线程池
    可以设置指定的眼时或定期执行任务。

10.Runnable()与Callable()的区别？

  • Runnable()是没有返回值的，而Callable()允许有返回值。
  • Runnable()不能声明异常，Callable()可以。 代码演示：
ExecutorService executorService = Executors.newFixedThreadPool(10);
        executorService.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                return 1;
            }
        });
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println(" ");
            }
        });
        System.out.println(submit.get());
        //线程池使用完毕后，必须关闭
        executorService.shutdown();
复制代码

11. 守护线程与非守护线程的区别？

程序允许完毕，jvm会等待非守护线程完成后关闭，但是jvm不会等待守护线程关闭，守护线程最典型的例子就是GC进程。

12. 什么是乐观锁？什么是悲观锁？

  • 乐观锁：乐观锁认为竞争不总是会发生，因此它不需要持有锁，将比较-替换这两个动作作为一个原子操作尝试去修改内存中的变量，如果失败则表示发生冲突，那么就应该有相应的重试逻辑。
  • 悲观锁：悲观锁认为竞争总是会发生，因此每次对某资源进行操作时，都会持有一个独占的锁，就像synchronized，不管三七二十一，直接上了锁就操作资源了。

2. 死锁问题

2.1 如何产生死锁？

像下面这种情况锁与锁之间相互竞争的情况：

public class MultiplyThreadTest {
    private static final Object lock = new Object();
    private static final Object lock1 = new Object();

    public static void main(String[] args) {
        new ThreadClass1().start();
        new ThreadClass2().start();
    }

    static class ThreadClass1 extends Thread {
        @Override
        public void run() {
            synchronized (lock) {
                try {
                    Thread.sleep(0);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock1) {
                    System.out.println("Thread1");
                }
            }
        }
    }

    static class ThreadClass2 extends Thread {
        @Override
        public void run() {
            synchronized (lock1) {
                synchronized (lock) {
                    System.out.println("Thread2");
                }
            }
        }
    }
}
复制代码

其实我刚开始写出的来的时候，我自己都有疑问：

  • 1.不加Thread.sleep(0)这两个线程是不会产生死锁的，为什么？
  • 2.就算加了Thread.sleep(0)，那也只是让线程睡0毫秒，加了跟没加不是一样嘛，为什么加上了就能产生死锁呢？

其实这地方，涉及到一个冷门的知识点，可以参考stackoverflow的 回答 ，那就是绝大部分的操作系统的时间精度都在10ms，所以看上去是sleep(0)，但由于精度问题，实际上不是睡0ms。另外一个，不加 Thread.sleep(0) 就不会产生死锁的原因在于，线程执行这两个简单的方法的过程其实是非常短暂的，所以锁之间根本来不及相互竞争。

2.2 如何排查及预防死锁？

  • 使用 jsp 命令查看哪些进程正在执行：
    Java基础复习之旅(3)-线程篇
  • 找到运行的类对应的进程编号，显示详细的调用栈信息，导出到记事本中：
jstack 17424 > ~/Desktop/1.txt
复制代码
Java基础复习之旅(3)-线程篇

可以看到日志中，有详细的死锁信息。

  • 预防死锁的原则就是： 保证每个线程都已想同的顺序拿到资源的锁。 像这个例子中两个线程拿到锁的顺序就相互矛盾，所以容易产生死锁。

3.三种方式实现生产者，消费者模型

3.1 使用wait()，notify()实现

public class ProducerConsumer1 {

    private static final Object lock = new Object();
    private static Optional<Integer> optional = Optional.empty();

    public static void main(String[] args) throws InterruptedException {
        Container container = new Container(optional);
        Producer producer = new Producer(container);
        Consumer consumer = new Consumer(container);

        producer.start();
        consumer.start();

        producer.join();
        producer.join();
    }

    public static class Producer extends Thread {
        Container container;

        public Producer(Container container) {
            this.container = container;
        }

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                synchronized (lock) {
                    while (container.getOptional().isPresent()) {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    Integer integer = new Random().nextInt();
                    System.out.println("Product:" + integer);
                    container.setOptional(Optional.of(integer));
                    lock.notify();
                }
            }
        }
    }

    public static class Consumer extends Thread {
        Container container;

        public Consumer(Container container) {
            this.container = container;
        }

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                synchronized (lock) {
                    while (!container.getOptional().isPresent()) {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println("Consume:" + container.getOptional().get());
                    container.setOptional(Optional.empty());
                    lock.notify();
                }
            }
        }
    }
}
复制代码

虽然看起来代码挺多的，但其实就是一个思想，就是生产者在生产之前，先检查容器中是否为空，如果不为空就等待，为空才生产。同样，消费者也需要在容器中有值的情况下才会消费，否则就等待。

3.2 使用lock，condition实现

借鉴Condition接口中的提示：

*   public void put(Object x) throws InterruptedException {
 *     <b>lock.lock();
 *     try {</b>
 *       while (count == items.length)
 *         <b>notFull.await();</b>
 *       items[putptr] = x;
 *       if (++putptr == items.length) putptr = 0;
 *       ++count;
 *       <b>notEmpty.signal();</b>
 *     <b>} finally {
 *       lock.unlock();
 *     }</b>
 *   }
复制代码

代码如下：

public class ProducerConsumer2 {
    private static final Lock lock = new ReentrantLock();
    private static final Condition notConsumer = lock.newCondition();
    private static final Condition notProduct = lock.newCondition();

    private static Optional<Integer> optional = Optional.empty();

    public static void main(String[] args) throws InterruptedException {
        Container container = new Container(optional);
        Producer producer = new Producer(container);
        Consumer consumer = new Consumer(container);

        producer.start();
        consumer.start();

        producer.join();
        producer.join();
    }

    public static class Producer extends Thread {
        private Container container;

        public Producer(Container container) {
            this.container = container;
        }

        @Override
        public void run() {
            lock.lock();
            try {
                while (container.getOptional().isPresent()) {
                    try {
                    //注意：是await()而不是wait()
                        notConsumer.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                int random = new Random().nextInt();
                System.out.println("Product" + random);
                container.setOptional(Optional.of(random));
                notProduct.signal();
            } finally {
                lock.unlock();
            }
        }
    }

    public static class Consumer extends Thread {

        private Container container;

        public Consumer(Container container) {
            this.container = container;
        }

        @Override
        public void run() {
            try {
                lock.lock();
                while (!container.getOptional().isPresent()) {
                    try {
                        notProduct.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(container.getOptional().get());
                container.setOptional(Optional.empty());
                notConsumer.notify();
            } finally {
                lock.unlock();
            }
        }
    }
}
复制代码

与第一种方法类似，这里增加了Condition条件判断，并用到了ReentrantLock。

3.3 使用BlockingQueue.take()/put()方法实现

public class ProducerConsumer3 {

    private static final BlockingQueue<Integer> queue = new LinkedBlockingDeque<>(1);
    private static final BlockingQueue<Integer> signal = new LinkedBlockingDeque<>(1);

    public static void main(String[] args) throws InterruptedException {
        Producer producer = new Producer(queue, signal);
        Consumer consumer = new Consumer(queue, signal);

        producer.start();
        consumer.start();

        producer.join();
        producer.join();
    }

    public static class Producer extends Thread {
        BlockingQueue<Integer> queue;
        BlockingQueue<Integer> signal;

        public Producer(BlockingQueue<Integer> queue, BlockingQueue<Integer> signal) {
            this.queue = queue;
            this.signal = signal;
        }

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                int random = new Random().nextInt();
                System.out.println("Product:" + random);
                try {
                    queue.put(random);
                    signal.take();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static class Consumer extends Thread {
        BlockingQueue<Integer> queue;
        BlockingQueue<Integer> signal;

        public Consumer(BlockingQueue<Integer> queue, BlockingQueue<Integer> signal) {
            this.queue = queue;
            this.signal = signal;
        }

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    System.out.println("Consumer:" + queue.take());
                    signal.put(0);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
复制代码

这种方法就比较简单了，不用判断容器是否为空，因为BlockingQueue在内部为我们实现了判断，直接拿来用就可以了。这里需要注意一点，由于take()与put()方法几乎是同时执行的，所有需要加一个signal标志信息，避免乱序。

Container容器：

public class Container {
    Optional<Integer> optional;

    public Container(Optional<Integer> optional) {
        this.optional = optional;
    }

    public Optional<Integer> getOptional() {
        return optional;
    }

    public void setOptional(Optional<Integer> optional) {
        this.optional = optional;
    }
}
复制代码

参考资料

    1. 《漫画：什么是协程》 跳转至源文档
    1. 《协程-维基百科》 跳转至源文档
    1. 《线程的状态转换以及基本操作》跳转至源文档
    1. 《bat等大公司常考java多线程面试题》跳转至源文档
原文  https://juejin.im/post/5dec97d3e51d4557f42b62aa
正文到此结束
所属分类： Java 编程技术

热门推荐

相关文章

阿里云首购8折
说给你听

本文目录
随机标签
书籍教程
springboot-demo Java入门教程 bootstrap3 CSS Apache基础教程 php ionic 教程 Python mysql教程 eclipse Ubuntu VPS系统配置 AngularJS 教程 MongoDB教程 Struts2教程 Redis教程 Spring教程 Git教程 Jenkins进阶系列 openfire参考指南 Java设计模式 HBase教程 Maven教程 hibernate教程 Docker 教程 memcached教程 Quartz指南 Hive教程 Ant教程 ANTLR教程 SpringCloud java实例教程 springcloud-demo XStream教程 Hazelcast教程 Elastic-Job-Lite 深入浅出MyBatis SVN教程 ibaties教程 rabittmq教程 solr教程 Hadoop教程 WebService CXF学习 JPA教程 ActiveMQ中文指南 java-demo Java内存模型 dubbo教程 python3-demo Linux入门视频教程
近期评论
  1. 1 Spring Cloud Consul实现选举机制
  2. 2 Spring Boot集成ShedLock实现分布式定时任务
  3. 3 利用oss进行数据库和网站图片备份
  4. 4 Spring Cloud Stream实现数据流处理
  5. 5 Python3访问MySQL数据库快速入门Demo
  6. 6 Github开源项目作者可以免费申请 JetBrains 全家桶
  7. 7 Spring Cloud Vault快速入门Demo
  8. 8 Spring Cloud Gateway快速入门Demo
  9. 9 Spring Cloud Contract快速入门Demo
  10. 10 Spring Cloud Consul快速入门Demo
网站信息
  • 文章总数：82,714 篇
  • 文件总数：284,287 个
  • 标签总数：2,393 个
  • 分类总数：85 个
  • 留言数量：2,560 条
  • 在线人数：666 人
  • 运行天数：4,409天
  • 最后更新：2024年11月22日03点
Loading...

其他链接

关于本站

本站定位：个人技术类博客

本站作用：写博客、记日志、闲聊扯淡鼓捣技术。

问题交流

[HBLOG]公众号 HBLOG HBLOG