关于多线程的问题（II）

21.FutureTask是什么

这个其实前面有提到过，FutureTask表示一个异步运算的任务。FutureTask里面可以传入一个Callable的具体实现类，可以对这个异步运算的任务的结果进行等待获取，判断是否已经完成，取消任务等操作。当然，由于FutureTask也是Runnable接口的实现类，所以FutureTask也可以放入线程池中。

22、Linux环境下如何查找哪个线程使用CPU最长

这是一个比较偏实践的问题，这种问题我觉得挺有意义的。可以这么做：

（1）获取项目的pid,jps或者ps - ef| grep java ，这个前面有讲过

（2）top - H - p pid,顺序不能改变

这样就可以打印出当前的项目，每条线程占用CPU时间的百分比。注意这里打出的是LWP,也就是操作系统原生线程的线程号

s使用“top -h -p pid” + "jps  pid "可以很容易地找到某条占用CPU高的线程的线程堆栈，从而定位占用CPU高的原因，一般是因为不当的代码操作导致了死循环。

最后提一点,"top- h - p pid" 打出来的LWP是十进制的，“jps pid” 打出来的本地线程号是十六进制的，转换一下，就能定位到占用CPU高的线程的当前线程堆栈了。

23、java编程写一个会导致死锁的程序

第一次看到这个题目，觉得这是一个非常好的问题，很多人都知道死锁是怎么一回事，线程A和线程B相互等待对方持有的锁导致程序无限死循环下去。当然也仅限于此了，问一下怎么写一个死锁的程序就不知道了，这种情况说白了就是不懂什么是死锁，懂一个理论就完事儿了，实践中碰到死锁的问题基本上是看不出来的。

真正理解什么是死锁，这个问题其实不难，几个步骤

两个线程里面分别持有两个object对象：lock1和lock2 这两个lock作为同步代码块的锁；

（2）线程1的方法同步代码块先获取lock1的对象锁，Thread.sleep(***)，时间不要太多，50毫秒差不多了，接着获取lock2的对象锁，便被阻塞，此时一个死锁就形成了。代码就不写了，站占的篇幅有点多，java多线程7：

（3）线程2的run()方法中同步代码块先获取lock2的对象锁，接着获取lock1的对象锁，此时lock1被线程1所持有，线程2肯定是要等待线程1释放lock1的对象锁的

这样，线程1“sleep()”完后，线程2已经获取到lock2的对象锁了，线程1此时尝试获取lock2的对象锁，便被阻塞，此时一个死锁就形成了

24、怎么唤醒一个阻塞的线程

如果线程是因为调用了wait(),sleep()或者方法而导致的阻塞，可以中断线程，并且通过抛出InterruptedException来唤醒它；如果线线程遇到了IO阻塞，无能为力，因为IO是操作系统实现的，java代码并没有办法直接接触到操作系统。

25、不可变对象对多线程有什么帮助

前面有提到过的一个问题，不可变对象保证了对象的内存可见性，对不可变现象的读取不需要进行额外的同步手段，提升了代码执行效率。

26、什么是多线程的上下文切换

多线程的上下文切换是指CPU控制权由一个已经正在运行的线程切换到另外一个就绪并等待获取CPU执行权的线程的过程。

27、如果你提交任务时，线程池队列已满，这时会发生什么

这里区分一下：

1、如果使用的时无界队列LinkedBlockingQueue,也就是无界队列的话，没关系，继续添加任务到阻塞队列中等待执行，因为LinkedBlockingQueue可以近乎认为是一个无穷大的队列，可以无限存放任务

2、如果使用的时有界队列比如arrayBlockingqueue,任务首先会被添加到arrayBlockingQueue中，并且只要不超过最大线程数，如果超过了最大线程数，会使用拒绝策略，

28、java中用到的线程调度算法是什么

抢占式，一个线程用完cpu之后，操作系统会根据线程优先级、线程饥饿情况等数据算出一个总的优先级并分配下一个时间片给某个线程执行。

29、Thread.sleep(0)的作用是什么

这个问题和上面的问题是相关的，我就连在一起了，由于java采用抢占式的线程调度算法，因此可能会出现某条线程常常获取到cpu控制权的情况，为了让某些优先级比较低的线程也能获取到cpu控制权，可以使用Thread.sleep(0)手动触发一次操作系统分配时间片的操作，这也是平衡cpu控制权的一种操作。

30、什么是自旋

很多synchronized里面的代码只是一些很简单的代码，执行时间非常块，此时等待的线程都枷锁可能是一种不太值得的操作，因为线程阻塞涉及到用户态和内核态切换的问题。既然synchornized里面的代码执行的非常之快，不妨让等待锁的线程不要被阻塞，而是在synchronized的边界做忙循环，这就是自旋，如果做了多次忙循环发现还没有获得锁，再阻塞，这样可能是一种更好的策略。

31、什么是java内存模型

java内存模型定义了一种多线程访问java内存的规范，java内存模型要完整讲不是这里几句话就能说清楚的，我简单总结一下java内存模型的几部分内容：

（1）java内存模型将内存分为主内存和工作内存。类的状态，也就是类之间共享的变量，是存储在主内存中的，每次java线程用到这些主内存中的变量的时候，会读一次主内存中的变量，并让这些内存中在自己的工作内存中有一份拷贝，运行自己线程代码的时候，用到这些变量，操作的都是自己工作内存中的那一份。在线程代码执行完毕之后，会将最新的值更新到主内存中去

（2）定义了几个原子操作，用于操作主内存和工作内存中的变量

（3）定义了volatile变量的使用规则

（4）happen-before,即先行发生原则，定义了操作A必须先行发生于操作B的一些规则，比如在同一个线程内控制流前面的代码一定先行于控制流后面的代码、一个释放锁unlock的动作一定先行发生于后面对于同一个锁进行锁定lock的动作等等，只要符合这些规则，则不需要额外做同步措施，如果某段代码不符合所有的happen-before规则，则这段代码一定是线程非安全的

32、什么是cas

cas，全称为compare AND swAp,即比较-替换。假设有三个操作数：内存值V、旧的预期值A、要修改的值B,当且仅当预期值A和内存值V相同时，才会将内存值修改为B并返回true,否则什么都不做并返回false。当然CAS一定要Volatile变量配合，这样才能保证每次拿到的变量时主内存中最新的那个值，否则旧的预期值A对某条线程来说，永远是一个不会变的值A,只要某次CAS操作失败，永远都不可能成功。

33、什么是乐观锁和悲观锁

（1）乐观锁:就像它的名字一样，对于并发间操作产生的线程安全问题持乐观状态，乐观锁认为竞争不总会发生，因此它不需要持有锁，将比较-替换这两个动作作为一个操作去尝试修改内存中的变量，如果失败则表示发生冲突，那么就应该有相应的重试逻辑。

（2）悲观锁 ：也像它的名字一样，对于并发间操作产生的线程安全问题持悲观状态，悲观锁认为竞争总是会发生，因此每次对某资源进行操作时，都会持有一个独占的锁，就像synchoronized,不管三七二十一，直接上了锁就操作资源了。

34、什么是AQs

简单说一下AQS，AQS全称为AbstractQueuedSychronizer,翻译过来应该是抽象队列同步器。

如果说java.util.concurrent的基础是CaS的话，那么AQS就是整个java并发包的核心了，ReentrantLock、CountDownLatch 

Semaphore等等都用到了它。AQS实际上以双向队列的形式连接所有的entry,比方说ReentrantLock,所有等待的线程都被放在一个Entry中并连成双向队列，前面一个线程使用ReentrantLock好了，则双向队列实际上的第一个Entry开始运行。

AQS定义了对双向队列所有的操作，而只开放了trylock和tryRelease方法给开发者使用，开发者可 以根据自己的实现重写trylock和tryrelease方法，以实现自己的并发功能。

35、单例模式的线程安全性

老生常谈的问题了，首先要说的是单例模式的线程安全意味着：某个类的实例在多线程环境下只会被创建一次出来。单例模式有很多种的写法，我总结一下：

（1）饿汉单例模式：线程安全

（2）懒汉单例模式：线程不安全

（3）双检索单例模式：线程安全

36、Semphore就是

是一个信号量，它的作用是限制某段代码块的并发数。Semphore有一个构造函数，可以传入一个Int型整数n,表示某段代码最多只有一个n个线程可以访问，如果超出了 n  那么请等待，等到某个线程执行完毕这段代码块，下一个线程再进入。由此可以看出如果Semphore构造函数中传入的int型整数n=1,相当于编程一个synchronized了。

37、hashtable的size（）方法中明明只有一条语句“return count”,为什么还要做同步？

这是我之前的一个困惑，不知道大家有没有想过这个问题。某个方法中如果有多条语句，并且都在操作同一类变量，那么在多线程环境下不加锁，势必会引发线程安全问题，这很好理解，但是size()方法明明只有一条语句，为啥还要枷锁？

关于这个问题,在慢慢地工作、学习中、有了理解，主要原因有两点：

（1）同一时间只能有一条线程执行固定类的同步方法，但是对于类的非同步方法，可以多条线程同时访问。所以,这样就有问题了，可能线程A在执行hashtable的put方法添加数据，线程B则可以正常调用size()方法读取hashtable中的元素个数，那读取到值可能不是最新的，可能线程A添加完了数据，但是没有对size进行加加，线程B就已经获取到size了，那读出来的值一定是不准确的，加了线程同步后，意味着线程B调用size()方法只有在线程a调用put方法完毕之后，才可以调用，这样就保证了线程安全性

（2）cpu执行代码，执行的不是java代码，这点很关键，一定得记住。java代码最终是被翻译成机器码执行得，机器码才是真正可以和硬件电路交互得diamo，即使你看到javadiamo只有一行，甚至你看到java代码编译之后生成得字节码也只有一行，也不意味着对于底层来说这句语句得操作只有一个。一句“return count”  或许会翻译成三句汇编语句执行，一句汇编语句和其机器码做对应，完全可能执行完第一句，线程就切换了。

38、线程类得构造方法，静态块是被哪个线程调用得

这是一个非常刁钻和狡猾的问题i，请记住：线程类的构造方法\、静态块是被new这个线程类所在的线程所调用的，而run方法里面的代码才是被线程自身所调用的e.

举个列子假设Thread2中new 了Thread1,main方法中new了一个Thread2

那么

Thread2的构造函数，静态块是main函数调用的，run()方法是Thread2自己调用的;

Thread1的构造函数，静态块是Thread2调用的，run()方法是Thread1自己调用的。

39、同步方法和同步块，哪个是更好的选择

同步块称为同步块，意味着同步块之外的代码时异步执行的，这比同步整个方法更提升代码的效率，请知道一条原则：同步的范围越小越好。

借着这一条，我额外提一点，虽说同步的范围越少越好，但是在java虚拟机中还是存在着一种叫做锁粗化的优化方法，这种方法就是把同步范围变大。这是有用的，比方说StringBuffer，它是一个线程安全的类，自然最常用的append()方法是一个同步方法，我们写代码的时候会反复append字符串，这意味着要进行反复的加锁--.>解锁，这对性能不利，因为这意味着java虚拟机在这条线程上要反复地在内核态和用户态之间进行切换，因此java虚拟机会将多次append方法调用的代码进行一个锁粗化的操作，将多次的append的操作扩展到append方法的头尾，变成一个大的同步块，这样就减少了加锁-->解锁的次数，有效地提升了代码执行的效率。

40、高并发、任务执行时间短的业务怎样使用线程池？并发不高、任务执行时间长的业务怎样使用线程池？并发高、业务执行时间长的业务怎样使用线程池？

这是我在并发编程网上看到一个问题，把这个问题放在最后一个，希望每个人都能看到并且思考一下，因为这个问题非常好、非常实际、非常专业。关于这个问题，个人看法是：

（1）高并发、任务执行时间短的业务，线程池线程数可以设置为cpu核数+1，减少线程上下文的切换

（2）并发不够，任务执行时间长的业务要分开看：

a）假如是业务时间长集中在io操作上，也就是io密集型得任务，因为io操作并不占用cpu,所以不要让所有得cpu闲下来，可以加大线程中的线程数目，让cpu处理更多的业务

b）假如是业务时间长集中在计算操作上，也就是计算机密集型任务，这个就没办法了，和（1）一样吧，线程池中的线程数设置得少一些，减少线程上下文得切换

（3）并发高，执行时间长的，解决这类任务的关键不在于线程池而在于整体架构的设计，看看这些业务里面某些数据是否能做缓存是第一步，增加服务器是第二步，至于线程池的设置，设置参考（2）。最后，业务执行时间长的问题，也可能需要分析一下，看看能不能使用中间件对任务进行拆分和解耦。

==========================================================

原文章地址：

https://www.cnblogs.com/xrq730/p/5060921.html

=========

自己照着原文章手敲版，也是自己的学习，能指正的希望大家不吝指教。