Java——多线程

最新推荐文章于 2022-11-20 14:58:00 发布

龙腾天下3

最新推荐文章于 2022-11-20 14:58:00 发布

阅读量99

点赞数

分类专栏： Java多线程文章标签：多线程

本文链接：https://blog.csdn.net/u014250663/article/details/114276689

版权

Java多线程专栏收录该内容

1 篇文章 0 订阅

订阅专栏

多线程

一：多线程有什么用？为什么要用多线程？

1：发挥多核CPU的优势

现在的电脑或者服务器都是双核，四核，八核或者16核。如果是单线程的程序，在双核CPU上就浪费了50%，四核，八核浪费的更多。

单核CPU的所谓多线程都是假的多线程，同一时间只会处理一段逻辑，只不过线程之间切换的快，看着像多线程而已。

多核CPU上的多线程才是真正的多线程，它能让你的多段逻辑同时工作，多线程可以发挥多核处理的优势，达到充分利用CPU的目的。

2：防止阻塞

从运行效率来说，单核CPU不但不能发挥多线程的优势，反而会因为在单核CPU上运行多线程导致线程上下文的切换，降低整体效率。但是单核CPU还是要应用多线程，就是为了防止阻塞。

试想：

如果单核CPU使用单线程，那么只要这个线程阻塞了，对整个程序来说就停止运行了，多线程就可以防止这个问题，多条线程同时运行，哪怕有一条线程的阻塞了，并不会影响其他任务的执行。

3：便于建模

假设有一个很大的任务A，如果单线程编程，那么要考虑很多，建立整个程序模型比较麻烦。如果用多线程编程，就可以把这个很大的任务A分解成多个小任务（B、C、D），

分别建立程序模型，并通过多线程运行这几个任务，就简单很多。

二：并行和并发

1：并发：多个任务在同一个 CPU 核上，按细分的时间片轮流(交替)执行，从逻辑上来看那些任务是同时执行。（并发的多个任务之间是互相抢占资源的）

2：并行：多个处理器或多核处理器同时处理多个任务。（并行的多个任务之间是不互相抢占资源的）

解析：并发和并行

并发 = 两个队列和一台咖啡机。

并行 = 两个队列和两台咖啡机。

三：线程和进程的区别

1：一个程序至少有一个进程，一个进程至少有一个线程，一个进程下也可以有多个线程来增加执行速度。

程序：比如QQ，微信，等等这些都是一个个的程序。程序是一个静态的概念。

进程：这些程序如果被运行，这个时候，就叫做一个进程。进程相对程序来说是一个动态的概念。

线程：作为进程里面最小的执行单元就叫线程。

四：守护线程

1：守护线程是运行在后台的一种特殊进程。它独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。在 Java 中垃圾回收线程就是特殊的守护线程。

五：创建线程的几种方式，四种方式

1：继承 Thread 重新 run 方法；

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " run()方法正在执行...");
    }
}

2：实现 Runnable 接口；

public class MyRunnable implements Runnable {
    @Override
    public void run() {
      System.out.println(Thread.currentThread().getName() + " run()方法执行中...");
    }
}

3：实现 Callable 接口。

public class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() {
      System.out.println(Thread.currentThread().getName() + " call()方法执行中...");
      return 1;
    }
}

4：使用匿名内部类。

public class CreateRunnable {
  public static void main(String[] args) {
    //创建多线程创建开始
    Thread thread = new Thread(new Runnable() {
      public void run() {
        for (int i = 0; i < 10; i++) {
          System.out.println("i:" + i);
        }
      }
    });
    thread.start();
  }
}

六：说一下 runnable 和 callable 有什么区别？

相同点：

1：都是接口、都可以编写多线程程序、都采用Thread.start() 启动线程

区别：

1：Runnable 接口的 run() 方法无返回值，Callable 接口的call() 方法有返回值，是泛型，和Future、FutureTask配合可以用来获取异步执行的结果

2：Runnable 接口 run 方法只能抛出运行时异常，且无法捕获处理；Callable 接口 call 方法允许抛出异常，可以获取异常信息。

注：Callalbe接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。

七：线程有哪些状态？

1：NEW 尚未启动。（new）

2：RUNNABLE 正在执行中。（runnable）

3：BLOCKED 阻塞的（被同步锁或者 IO 锁阻塞）。（blocked）

4：WAITING 永久等待状态。（waiting）

5：TIMED_WAITING 等待指定的时间重新被唤醒的状态。（timed_waiting）

6：TERMINATED 执行完成。（terminated）

八：sleep() 和 wait() 有什么区别？

1：类的不同：sleep() 来自 Thread，wait() 来自 Object。

2：释放锁：sleep() 不释放锁；wait() 释放锁，使得其他线程可以使用同步控制块或者方法。

3：用法不同：sleep() 时间到会自动恢复；wait() 可以使用 notify()/notifyAll()直接唤醒。

4： sleep 必须捕获异常，而 wait ， notify 和 notifyAll 不需要捕获异常

九：notify()和 notifyAll()有什么区别？

1：notify()只会唤醒一个线程，具体唤醒哪一个线程由虚拟机控制。

2：notifyAll()会唤醒所有的线程，notifyAll() 调用后，会将全部线程由等待池移到锁池，然后参与锁的竞争，竞争成功则继续执行，如果不成功则留在锁池等待锁被释放后再次参与竞争。

十：线程的 run() 和 start() 有什么区别？

1：start() 方法用于启动线程，run() 方法用于执行线程的运行时代码。run() 可以重复调用，而 start() 只能调用一次。

十一：创建线程池有哪几种方式？（创建线程池有7种方式，最核心的是最后一种）

1：newSingleThreadExecutor()：它的特点在于工作线程数目被限制为 1，操作一个无界的工作队列，所以它保证了所有任务的都是被顺序执行，最多会有一个任务处于活动状态，

并且不允许使用者改动线程池实例，因此可以避免其改变线程数目；

2：newCachedThreadPool()：它是一种用来处理大量短时间工作任务的线程池，具有几个鲜明特点：它会试图缓存线程并重用，当无缓存线程可用时，就会创建新的工作线程；

如果线程闲置的时间超过 60 秒，则被终止并移出缓存；长时间闲置时，这种线程池，不会消耗什么资源。其内部使用 SynchronousQueue 作为工作队列；

3：newFixedThreadPool(int nThreads)：重用指定数目（nThreads）的线程，其背后使用的是无界的工作队列，任何时候最多有 nThreads 个工作线程是活动的。

这意味着，如果任务数量超过了活动队列数目，将在工作队列中等待空闲线程出现；如果有工作线程退出，将会有新的工作线程被创建，以补足指定的数目 nThreads；

4：newSingleThreadScheduledExecutor()：创建单线程池，返回 ScheduledExecutorService，可以进行定时或周期性的工作调度；

5：newScheduledThreadPool(int corePoolSize)：和 newSingleThreadScheduledExecutor()类似，创建的是个 ScheduledExecutorService，可以进行定时或周期性的工作调度，

区别在于单一工作线程还是多个工作线程；

6：newWorkStealingPool(int parallelism)：这是一个经常被人忽略的线程池，Java 8 才加入这个创建方法，其内部会构建 ForkJoinPool，利用 Work-Stealing 算法，并行地处理任务，

不保证处理顺序；

7：ThreadPoolExecutor()：是最原始的线程池创建，上面 1-3 创建方式都是对 ThreadPoolExecutor 的封装。

十二：线程池都有哪些状态？

1：RUNNING：这是最正常的状态，接受新的任务，处理等待队列中的任务。

2：SHUTDOWN：不接受新的任务提交，但是会继续处理等待队列中的任务。

3：STOP：不接受新的任务提交，不再处理等待队列中的任务，中断正在执行任务的线程。

4：TIDYING：所有的任务都销毁了，workCount 为 0，线程池的状态在转换为 TIDYING 状态时，会执行钩子方法 terminated()。

5：TERMINATED：terminated()方法结束后，线程池的状态就会变成这个。

十三：线程池中的submit() 和 execute() 方法有什么区别？

1：execute()：只能执行 Runnable 类型的任务。

2：submit()：可以执行 Runnable 和 Callable 类型的任务。Callable 类型的任务可以获取执行的返回值，而 Runnable 执行无返回值。

十四：在 Java 程序中怎么保证多线程的运行安全？

1：使用安全类，比如 Java.util.concurrent 下的类。

2：使用自动锁 synchronized 。

3：使用手动锁 Lock 。
手动锁 Java 示例代码如下：
Lock lock = new ReentrantLock();
lock. lock();
try {
System. out. println(“获得锁”);
} catch (Exception e) {
// TODO: handle exception
} finally {
System. out. println(“释放锁”);
lock. unlock();
}

十五：多线程中 synchronized 锁升级的原理是什么？

1：synchronized 锁升级原理：在锁对象的对象头里面有一个 threadid 字段，在第一次访问的时候threadid 为空，jvm 让其持有偏向锁，并将 threadid 设置为其线程 id，再次进入的时候会先判断threadid 是否与其线程 id 一致，如果一致则可以直接使用此对象，如果不一致，则升级偏向锁为轻量级锁，通过自旋循环一定次数来获取锁，执行一定次数之后，如果还没有正常获取到要使用的对象，此时就会把锁从轻量级升级为重量级锁，此过程就构成了 synchronized 锁的升级。

2：锁的升级的目的：锁升级是为了减低了锁带来的性能消耗。在 Java 6 之后优化 synchronized 的实现方式，使用了偏向锁升级为轻量级锁再升级到重量级锁的方式，从而减低了锁带来的性能消耗。

十六：什么是死锁？

1：当线程 A 持有独占锁 a，并尝试去获取独占锁 b 的同时，线程 B 持有独占锁 b，并尝试获取独占锁 a的情况下，就会发生 AB 两个线程由于互相持有对方需要的锁，而发生的阻塞现象，我们称为死锁。

十七：怎么防止死锁？

1：尽量使用 tryLock(long timeout, TimeUnit unit)的方法(ReentrantLock、ReentrantReadWriteLock)，设置超时时间，超时可以退出防止死锁。

2：尽量使用 Java. util. concurrent 并发类代替自己手写锁。

3：尽量降低锁的使用粒度，尽量不要几个功能用同一把锁。

4：尽量减少同步的代码块。

十八：ThreadLocal 是什么？有哪些使用场景？

1：ThreadLocal 为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。

2：ThreadLocal 的经典使用场景是数据库连接和 session 管理等。

十九：说一下 synchronized 底层实现原理？

1：synchronized 是由一对 monitorenter/monitorexit 指令实现的，monitor 对象是同步的基本实现单元。

2：在 Java 6 之前，monitor 的实现完全是依靠操作系统内部的互斥锁，因为需要进行用户态到内核态的切换，所以同步操作是一个无差别的重量级操作，性能也很低。

3：但在 Java 6 的时候，Java 虚拟机对此进行了大刀阔斧地改进，提供了三种不同的 monitor 实现，也就是常说的三种不同的锁：偏向锁（Biased Locking）、轻量级锁和重量级锁，

大大改进了其性能。

二十：synchronized 和 volatile 的区别是什么？

1：volatile 是变量修饰符；synchronized 是修饰类、方法、代码段。

2：volatile 仅能实现变量的修改可见性，不能保证原子性；而 synchronized 则可以保证变量的修改可见性和原子性。

3：volatile 不会造成线程的阻塞；synchronized 可能会造成线程的阻塞。

二十一：synchronized 和 Lock 有什么区别？

1：synchronized 可以给类、方法、代码块加锁；而 lock 只能给代码块加锁。

2：synchronized 不需要手动获取锁和释放锁，使用简单，发生异常会自动释放锁，不会造成死锁；而 lock需要自己加锁和释放锁，如果使用不当没有 unLock()去释放锁就会造成死锁。

3：通过 Lock 可以知道有没有成功获取锁，而 synchronized 却无法办到。

二十二：synchronized 和 ReentrantLock 区别是什么？

1：synchronized 早期的实现比较低效，对比 ReentrantLock，大多数场景性能都相差较大，但是在 Java 6中对 synchronized 进行了非常多的改进。

2：ReentrantLock 使用起来比较灵活，但是必须有释放锁的配合动作；

3：ReentrantLock 必须手动获取与释放锁，而 synchronized 不需要手动释放和开启锁；

4：ReentrantLock 只适用于代码块锁，而 synchronized 可用于修饰方法、代码块等。

5：volatile 标记的变量不会被编译器优化；synchronized 标记的变量可以被编译器优化。

二十三：说一下 atomic 的原理？

1：atomic 主要利用 CAS (Compare And Wwap) 和 volatile 和 native 方法来保证原子操作，从而避免synchronized 的高开销，执行效率大为提升。

龙腾天下3

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java——多线程

一：多线程有什么用？为什么要用多线程？1：发挥多核CPU的优势现在的电脑或者服务器都是双核，四核，八核或者16核。如果是单线程的程序，在双核CPU上就浪费了50%，四核，八核浪费的更多。单核CPU的所谓多线程都是假的多线程，同一时间只会处理一段逻辑，只不过线程之间切换的快，看着像多线程而已。多核CPU上的多线程才是真正的多线程，它能让你的多段逻辑同时工作，多线程可以发挥多核处理的优势，达到充分利用CPU的目的。2：防止阻塞从运行效率来说，单核CPU不但不能发挥多线程的优势，反而会因
复制链接

扫一扫