并发编程的优缺点
为什么要使用并发编程（并发编程的优点）
充分利用多核CPU的计算能力：通过并发编程的形式可以将多核CPU 的计算能力发挥到极致，性能得到提升 方便进行业务拆分，提升系统并发能力和性能：在特殊的业务场景 下，先天的就适合于并发编程。现在的系统动不动就要求百万级甚至千万 级的并发量，而多线程并发编程正是开发高并发系统的基础，利用好多线程机制可以大大提高系统整体的并发能力以及性能。面对复杂业务模型， 并行程序会比串行程序更适应业务需求，而并发编程更能吻合这种业务拆分 。
并发编程有什么缺点
并发编程的目的就是为了能提高程序的执行效率，提高程序运行速度，但是并发 编程并不总是能提高程序运行速度的，而且并发编程可能会遇到很多问题，比如 ：内存泄漏、上下文切换、线程安全、死锁等问题。
并发编程三要素是什么？在 Java 程序中怎么保证多线程的运行 安全？
并发编程三要素（线程的安全性问题体现在）：
原子性：原子，即一个不可再被分割的颗粒。原子性指的是一个或多个操作要么 全部执行成功要么全部执行失败。
可见性：一个线程对共享变量的修改,另一个线程能够立刻看到。 （synchronized,volatile）
有序性：程序执行的顺序按照代码的先后顺序执行。（处理器可能会对指令进行 重排序）
出现线程安全问题的原因： 线程切换带来的原子性问题 缓存导致的可见性问题 编译优化带来的有序性问题
解决办法： JDK Atomic开头的原子类、synchronized、LOCK，可以解决原子性问题 synchronized、volatile、LOCK，可以解决可见性问题 Happens-Before 规则可以解决有序性问题
并行和并发有什么区别？
并发：多个任务在同一个 CPU 核上，按细分的时间片轮流(交替)执行，从逻辑上 来看那些任务是同时执行。
并行：单位时间内，多个处理器或多核处理器同时处理多个任务，是真正意义上 的“同时进行”。
串行：有n个任务，由一个线程按顺序执行。由于任务、方法都在一个线程执行所 以不存在线程不安全情况，也就不存在临界区的问题。
做一个形象的比喻：
并发 = 两个队列和一台咖啡机。
并行 = 两个队列和两台咖啡机。
串行 = 一个队列和一台咖啡机。
什么是多线程，多线程的优劣？
多线程：多线程是指程序中包含多个执行流，即在一个程序中可以同时运行多个 不同的线程来执行不同的任务。
多线程的好处： 可以提高 CPU 的利用率。在多线程程序中，一个线程必须等待的时候，CPU 可 以运行其它的线程而不是等待，这样就大大提高了程序的效率。也就是说允许单 个程序创建多个并行执行的线程来完成各自的任务。
多线程的劣势： 线程也是程序，所以线程需要占用内存，线程越多占用内存也越多； 多线程需要协调和管理，所以需要 CPU 时间跟踪线程； 线程之间对共享资源的访问会相互影响，必须解决竞用共享资源的问题。
什么是线程和进程?
进程 一个在内存中运行的应用程序。每个进程都有自己独立的一块内存空间，一个进程可以有多个线程，比如在Windows系统中，一个运行的xx.exe就是一个进程。
线程 进程中的一个执行任务（控制单元），负责当前进程中程序的执行。一个进程至 少有一个线程，一个进程可以运行多个线程，多个线程可共享数据。
进程与线程的区别
线程具有许多传统进程所具有的特征，故又称为轻型进程(Light—Weight Process)或进程元；而把传统的进程称为重型进程(Heavy—Weight Process)， 它相当于只有一个线程的任务。在引入了线程的操作系统中，通常一个进程都有 若干个线程，至少包含一个线程。
根本区别：
进程是操作系统资源分配的基本单位，而线程是处理器任务调度和执 行的基本单位资源开销：每个进程都有独立的代码和数据空间（程序上下文），程序之间的切 换会有较大的开销；
线程可以看做轻量级的进程，同一类线程共享代码和数据空 间，每个线程都有自己独立的运行栈和程序计数器（PC），线程之间切换的开销 小。
包含关系：如果一个进程内有多个线程，则执行过程不是一条线的，而是多条线 （线程）共同完成的；线程是进程的一部分，所以线程也被称为轻权进程或者轻量级进程。
内存分配：同一进程的线程共享本进程的地址空间和资源，而进程之间的地址空 间和资源是相互独立的
影响关系：一个进程崩溃后，在保护模式下不会对其他进程产生影响，但是一个 线程崩溃整个进程都死掉。所以多进程要比多线程健壮。
执行过程：每个独立的进程有程序运行的入口、顺序执行序列和程序出口。但是线程不能独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控 制，两者均可并发执行
什么是上下文切换?
多线程编程中一般线程的个数都大于 CPU 核心的个数，而一个 CPU 核心在任意时刻只能被一个线程使用，为了让这些线程都能得到有效执行，CPU 采取的策略 是为每个线程分配时间片并轮转的形式。
当一个线程的时间片用完的时候就会重 新处于就绪状态让给其他线程使用，这个过程就属于一次上下文切换。
概括来说就是：当前任务在执行完 CPU 时间片切换到另一个任务之前会先保存 自己的状态，以便下次再切换回这个任务时，可以再加载这个任务的状态。任务 从保存到再加载的过程就是一次上下文切换。
上下文切换通常是计算密集型的。也就是说，它需要相当可观的处理器时间，在 每秒几十上百次的切换中，每次切换都需要纳秒量级的时间。所以，上下文切换 对系统来说意味着消耗大量的 CPU 时间，事实上，可能是操作系统中时间消耗 最大的操作。
Linux 相比与其他操作系统（包括其他类 Unix 系统）有很多的优点，其中有一 项就是，其上下文切换和模式切换的时间消耗非常少。
守护线程和用户线程有什么区别呢？
守护线程和用户线程
用户 (User) 线程：运行在前台，执行具体的任务，如程序的主线程、连接网络的子线程等都是用户线程
守护 (Daemon) 线程：运行在后台，为其他前台线程服务。也可以说守护线 程是 JVM 中非守护线程的 “佣人”。一旦所有用户线程都结束运行，守护线程会随 JVM 一起结束工作
main 函数所在的线程就是一个用户线程啊，main 函数启动的同时在 JVM 内部 同时还启动了好多守护线程，比如垃圾回收线程。 比较明显的区别之一是用户线程结束，JVM 退出，不管这个时候有没有守护线程 运行。而守护线程不会影响 JVM 的退出。
注意事项：
1. setDaemon(true)必须在start()方法前执行，否则会抛出 IllegalThreadStateException 异常
2. 在守护线程中产生的新线程也是守护线程
3. 不是所有的任务都可以分配给守护线程来执行，比如读写操作或者计算 逻辑
4. 守护 (Daemon) 线程中不能依靠 finally 块的内容来确保执行关闭或清理 资源的逻辑。
因为我们上面也说过了一旦所有用户线程都结束运行，守护线程会随 JVM 一起结束工作，所以守护 (Daemon) 线程中的 finally 语句 块可能无法被执行。
如何在 Windows 和 Linux 上查找哪个线程cpu利用率最高？
windows上面用任务管理器看，linux下可以用 top 这个工具看。
1. 找出cpu耗用厉害的进程pid， 终端执行top命令，然后按下shift+p 查 找出cpu利用最厉害的pid号
2. 根据上面第一步拿到的pid号，top -H -p pid 。然后按下shift+p，查找 出cpu利用率最厉害的线程号，比如top -H -p 1328
3. 将获取到的线程号转换成16进制，去百度转换一下就行
4. 使用jstack工具将进程信息打印输出，jstack pid号 > /tmp/t.dat，比如 jstack 31365 > /tmp/t.dat
5. 编辑/tmp/t.dat文件，查找线程号对应的信息
什么是线程死锁
百度百科：死锁是指两个或两个以上的进程（线程）在执行过程中，由于竞争资 源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推 进下去。
此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程（线程）称为死锁进程（线程）。 多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线 程被无限期地阻塞，因此程序不可能正常终止。
如下图所示，线程 A 持有资源 2，线程 B 持有资源 1，他们同时都想申请对方的资源，所以这两个线程就会互相等待而进入死锁状态。
下面通过一个例子来说明线程死锁，代码模拟了上图的死锁的情况 (代码来源于 《并发编程之美》)：
publicclassDeadLockDemo{
privatestatic Object resource1 =newObject();//资源 1
privatestatic Object resource2 =newObject();//资源 2
publicstaticvoidmain(String[] args){newThread(()->{synchronized(resource1){ System.out.println(Thread.currentThread()+"get resource1");
try{ Thread.sleep(1000);}catch(InterruptedException e){ e.printStackTrace();} System.out.println(Thread.currentThread()+"waiting get resource2");
synchronized(resource2){
System.out.println(Thread.currentThread()+"get resource2");}}},"线程 1").start();
newThread(()->{synchronized(resource2){
System.out.println(Thread.currentThread()+"get resource2");
try{ Thread.sleep(1000);}catch(InterruptedException e){ e.printStackTrace();} System.out.println(Thread.currentThread()+"waiting getresource1");
synchronized(resource1){
System.out.println(Thread.currentThread()+"get resource1");}}},"线程 2").start();}}
输出结果 Thread[线程 1,5,main]get resource1Thread[线程 2,5,main]get resource2Thread[线程 1,5,main]waiting get resource2Thread[线程 2,5,main]waiting get resource1
线程 A 通过 synchronized (resource1) 获得 resource1 的监视器锁，然后通过 Thread.sleep(1000)；让线程 A 休眠 1s 为的是让线程 B 得到CPU执行权，然后获 取到 resource2 的监视器锁。
线程 A 和线程 B 休眠结束了都开始企图请求获取 对方的资源，然后这两个线程就会陷入互相等待的状态，这也就产生了死锁。上 面的例子符合产生死锁的四个必要条件。
形成死锁的四个必要条件是什么
1.互斥条件：线程(进程)对于所分配到的资源具有排它性，即一个资源只能 被一个线程(进程)占用，直到被该线程(进程)释放
2. 请求与保持条件：一个线程(进程)因请求被占用资源而发生阻塞时，对已 获得的资源保持不放。
3. 不剥夺条件：线程(进程)已获得的资源在末使用完之前不能被其他线程强 行剥夺，只有自己使用完毕后才释放资源。
4. 循环等待条件：当发生死锁时，所等待的线程(进程)必定会形成一个环路 （类似于死循环），造成永久阻塞
如何避免线程死锁
我们只要破坏产生死锁的四个条件中的其中一个就可以了。 破坏互斥条件 java核心技术卷1 基础知识 9这个条件我们没有办法破坏，因为我们用锁本来就是想让他们互斥的（临界资源 需要互斥访问）。 破坏请求与保持条件 一次性申请所有的资源。
破坏不剥夺条件 占用部分资源的线程进一步申请其他资源时，如果申请不到，可以主动释放它占 有的资源。 破坏循环等待条件 靠按序申请资源来预防。按某一顺序申请资源，释放资源则反序释放。破坏循环 等待条件。 我们对线程 2 的代码修改成下面这样就不会产生死锁了。
创建线程的四种方式
创建线程有哪几种方式？
创建线程有四种方式：
继承 Thread 类；
实现 Runnable 接口；
实现 Callable 接口；
使用 Executors 工具类创建线程池
继承 Thread 类
步骤
1. 定义一个Thread类的子类，重写run方法，将相关逻辑实现，run()方法 就是线程要执行的业务逻辑方法
2. 创建自定义的线程子类对象
3. 调用子类实例的star()方法来启动线程
publicclassMyThreadextendsThread{@Overridepublicvoidrun(){ System.out.println(Thread.currentThread().getName()+" run()方法正在执行...");}}
publicclassTheadTest{publicstaticvoidmain(String[] args){
MyThread myThread =newMyThread();
myThread.start();
System.out.println(Thread.currentThread().getName()+" main()方法执行结束");}}
运行结果 main main()方法执行结束Thread-0run()方法正在执行...
实现 Runnable 接口
步骤
1. 定义Runnable接口实现类MyRunnable，并重写run()方法
2. 创建MyRunnable实例myRunnable，以myRunnable作为target创建 Thead对象，该Thread对象才是真正的线程对象
3. 调用线程对象的start()方法
publicclassMyRunnableimplementsRunnable{@Overridepublicvoidrun(){ System.out.println(Thread.currentThread().getName()+" run()方法执行中...");}}
publicclassRunnableTest{publicstaticvoidmain(String[] args){
MyRunnable myRunnable =newMyRunnable();
Thread thread =newThread(myRunnable);
thread.start();
System.out.println(Thread.currentThread().getName()+" main()方 法执行完成");}}
执行结果 main main()方法执行完成Thread-0run()方法执行中...
实现 Callable 接口
步骤
1. 创建实现Callable接口的类myCallable
2. 以myCallable为参数创建FutureTask对象
3. 将FutureTask作为参数创建Thread对象
4. 调用线程对象的start()方法
publicclassMyCallableimplementsCallable<Integer>{@Overridepublic Integer call(){ System.out.println(Thread.currentThread().getName()+" call()方法执行中...");return1;}}
publicclassCallableTest{publicstaticvoidmain(String[] args){
FutureTask<Integer> futureTask =newFutureTask<Integer>(newMyCallable());
Thread thread =newThread(futureTask);
thread.start();
try{ Thread.sleep(1000);
System.out.println("返回结果 "+ futureTask.get());}catch(InterruptedException e){ e.printStackTrace();}catch(ExecutionException e){ e.printStackTrace();} System.out.println(Thread.currentThread().getName()+" main()方法执行完成");}}
执行结果 Thread-0call()方法执行中...返回结果 1main main()方法执行完成
使用 Executors 工具类创建线程池
Executors提供了一系列工厂方法用于创先线程池，返回的线程池都实现了 ExecutorService接口。
主要有newFixedThreadPool，newCachedThreadPool， newSingleThreadExecutor，newScheduledThreadPool，后续详细介绍这四 种线程池 publicclassMyRunnableimplementsRunnable{@Overridepublicvoidrun(){ System.out.println(Thread.currentThread().getName()+" run()方法执行中...");}}
publicclassSingleThreadExecutorTest{publicstaticvoidmain(String[] args){
ExecutorService executorService = Executors.newSingleThreadExecutor();
MyRunnable runnableTest =newMyRunnable();
for(int i =0; i <5; i++){ executorService.execute(runnableTest);}
System.out.println("线程任务开始执行"); executorService.shutdown();}}
执行结果
版权声明：
本文来源网络，所有图片文章版权属于原作者，如有侵权，联系删除。
本文网址：https://www.bianchenghao6.com/h6javajc/1848.html