Java并发操作的一些知识

电玩女神 2022-08-05 13:15 127阅读 0赞

### 什么是原子操作？ Java Concurrency API中有哪些原子操作类？ ###

原子操作是执行单个任务单元的操作，这个操作不需要干扰其他操作，可以理解为当前情况下不可再分的操作，远在操作是多线程环境下避免数据不一致而存在的必需品。

int++就不是原子操作，如果一个线程读取它的值并行+1操作，而另外一个线程读取了旧的值，则会导致错误的结果。

为了解决这个问题，我们需要确保递增操作是原子的，可以使用同步原语（synchronization），也可以使用Java5 包装的`AtomicInteger`直接完成原子操作。在包`java.util.concurrent.atomic`下面的一Atomic开头的类都是原子类。例如`AtomicInteger`，`AtomicReference`等

### 什么是`Java Cuncurrency API`中Lock 接口？相对于同步（`synchronization`）有什么优势？ ###

首先我们看下Lock接口的定义：  
![Lock接口定义][Lock] ![lock-implement.jpg][]  
Lock是一个控制多线程访问共享资源的工具类，比使用synchronized方法或者语句有了更加扩展性的操作，结构灵活，可以有完全不同的属性，也可以支持多个相关类的条件对象。使用方法如下：

{@code
       Lock l = ...;
       l.lock();
       try {
       // 访问锁保护的共享资源
        } finally {
       l.unlock();
      }}

*  相对于synchronization 有如下优点：
 *  可以使锁更公平
 *  可以使线程在等待锁的时候响应中断
 *  可以让线程尝试获取锁，并在无法获取锁的时候立即返回或者等待一段时间
 *  可以在不同的作用域，以不同的顺序获取和释放锁

### 什么是Executors框架？ ###

在Java5中，Executor框架随同`java.util.concurrent.Executor`接口一同被引入，Executor框架标准化了线程的调用，调度，执行以及异步任务的控制。  
无节制的线程创建会引起内存溢出，创建有限线程数的线程池（ThreadPool）是一个好的选择，线程可以预先创建，回收再利用。Executor框架促进了Java中线程池的创建，示例代码如下：

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class SimpleThreadPool {
    
        public static void main(String[] args) {
            ExecutorService executor = Executors.newFixedThreadPool(5);
            for (int i = 0; i < 10; i++) {
                Runnable worker = new WorkerThread("" + i);
                executor.execute(worker);
              }
            executor.shutdown();
            while (!executor.isTerminated()) {
            }
            System.out.println("Finished all threads");
        }
    
    }

### 什么是阻塞队列（BlockingQueue）?如何使用阻塞队列实现生产者—消费者问题？ ###

BlockingQueue是一个阻塞队列，顾名思义，当进行检索和删除的时候，如果队列为空，则阻塞等待直至队列非空，当添加元素到队列的时候，如果没有空间会阻塞等待到队列有空间为止。接口定义如下图所示：  
![BlockingQueue.jpg][]  
BlockingQueue不接受Null值，如果存储Null会抛出空指针异常。BlocingQueue的实现都是线程安全的，使用内部锁或者其他的并发控制方法。

**BlockingQueue定义的常用方法如下：**

*  add(anObject)：把anObject加到BlockingQueue里，如果BlockingQueue可以容纳，则返回true，否则抛出异常。
 *  offer(anObject)：表示如果可能的话，将anObject加到BlockingQueue里，即如果BlockingQueue可以容纳，则返回true，否则返回false。
 *  put(anObject)：把anObject加到BlockingQueue里，如果BlockingQueue没有空间，则调用此方法的线程被阻断直到BlockingQueue里有空间再继续。
 *  poll(time)：取走BlockingQueue里排在首位的对象，若不能立即取出，则可以等time参数规定的时间，取不到时返回null。
 *  take()：取走BlockingQueue里排在首位的对象，若BlockingQueue为空，阻断进入等待状态直到BlockingQueue有新的对象被加入为止。

**BlockingQueue有四个具体的实现类，根据不同需求，选择不同的实现类：**

*  ArrayBlockingQueue：规定大小的BlockingQueue，其构造函数必须带一个int参数来指明其大小。其所含的对象是以FIFO（先入先出）顺序排序的。
 *  LinkedBlockingQueue：大小不定的BlockingQueue，若其构造函数带一个规定大小的参数，生成的BlockingQueue有大小限制，若不带大小参数，所生成的BlockingQueue的大小由Integer.MAX\_VALUE来决定。其所含的对象是以FIFO顺序排序的。
 *  PriorityBlockingQueue：类似于LinkedBlockingQueue,但其所含对象的排序不是FIFO，而是依据对象的自然排序顺序或者是构造函数所带的Comparator决定的顺序。
 *  SynchronousQueue：特殊的BlockingQueue，对其的操作必须是放和取交替完成的。

`LinkedBlockingQueue`和`ArrayBlockingQueue`比较起来，它们背后所用的数据结构不一样，导致LinkedBlockingQueue的数据吞吐量要大于ArrayBlockingQueue，但在线程数量很大时其性能的可预见性低于ArrayBlockingQueue。  
实现生产者—消费者代码如下：Message.java

public class Message {
        private String msg ;
    
        public String getMsg() {
            return msg;
        }
    
        public void setMsg(final String msg) {
            this.msg = msg;
        }
    
        public Message(final String msg) {
            this.msg = msg;
        }
    }

Producer.java

import java.util.concurrent.BlockingQueue;
    
    public class Producer implements Runnable {
        private BlockingQueue<Message> messageBlockingDeque;
    
        public Producer(final BlockingQueue<Message> messageBlockingDeque) {
            this.messageBlockingDeque = messageBlockingDeque;
        }
    
        @Override
        public void run() {
            for (int i = 0; i <100 ; i++) {
               Message msg = new Message(" "+i);
                try {
                    Thread.sleep(i);
                    messageBlockingDeque.put(msg);
                    System.out.println("Produced:"+msg.getMsg());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            Message msg = new Message("exit");
            try {
                messageBlockingDeque.put(msg);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

Consumer.java

public class Consumer implements Runnable {
        private BlockingQueue<Message> blockingDeque;
    
        public Consumer(final BlockingQueue<Message> blockingDeque) {
            this.blockingDeque = blockingDeque;
        }
    
        @Override
        public void run() {
             Message message;
            try {
                while((message= blockingDeque.take()).getMsg()!="exit"){
                    Thread.sleep(10);
                    System.out.println("Consumed:"+message.getMsg());
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

ProductConsumerService.java

public class ProductConsumerService {
        public static void main(String[] args) {
            BlockingQueue<Message> queue = new ArrayBlockingQueue<Message>(10);
            Producer producer = new Producer(queue);
            Consumer consumer = new Consumer((queue));
    
            ExecutorService executorService = Executors.newCachedThreadPool();
            executorService.submit(producer);
            executorService.submit(consumer);
    
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            executorService.shutdown();
        }
    }

### 什么是Callable和Future？ ###

Java 5在concurrency包中引入了java.util.concurrent.Callable 接口，它和Runnable接口很相似，但它可以返回任何一个对象或者抛出一个异常。

Callable接口使用泛型去定义它的返回类型。Executors类提供了一些有用的方法去在线程池中执行Callable内的任务。由于Callable任务是并行的，我们必须等待它返回的结果。java.util.concurrent.Future应运而生。在线程池提交Callable任务后返回了一个Future对象，使用它我们可以知道Callable任务的状态和得到Callable返回的执行结果。Future提供了get()方法让我们可以等待Callable结束并获取它的执行结果，示例代码如下：

public class MyCallable implements Callable<String> {
        @Override
        public String call() throws Exception {
            Thread.sleep(1000);
            return Thread.currentThread().getName();
        }
    
        public static void main(String[] args) {
            ExecutorService service = Executors.newFixedThreadPool(10);
            List<Future<String>> list = new ArrayList<Future<String>>();
            Callable<String> callable = new MyCallable();
            for (int i = 0; i < 10; i++) {
                Future<String> future = service.submit(callable);
                list.add(future);
            }
    
            for (Future<String> fut : list) {
                try {
                    System.out.println(new Date() + "::" + fut.get());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (ExecutionException e) {
                    e.printStackTrace();
                }
            }
    
            service.shutdown();
        }
    }

运行结果：

Mon Oct 06 17:24:52 CST 2014::pool-1-thread-1
    Mon Oct 06 17:24:53 CST 2014::pool-1-thread-2
    Mon Oct 06 17:24:53 CST 2014::pool-1-thread-3
    Mon Oct 06 17:24:53 CST 2014::pool-1-thread-4
    Mon Oct 06 17:24:53 CST 2014::pool-1-thread-5
    Mon Oct 06 17:24:53 CST 2014::pool-1-thread-6
    Mon Oct 06 17:24:53 CST 2014::pool-1-thread-7
    Mon Oct 06 17:24:53 CST 2014::pool-1-thread-8
    Mon Oct 06 17:24:53 CST 2014::pool-1-thread-9
    Mon Oct 06 17:24:53 CST 2014::pool-1-thread-10

### 什么是FutureTask 类？ ###

FutureTask是一个可取消的异步计算类，它实现了Future接口，因为可以在Executors中使用，执行异步处理操作，大多数情况下，我们不需要FutureTask类。  
仅仅当我们打算重写Future接口的一些方法并保持原来基础的实现是，它就变得非常有用。我们可以仅仅继承于它并重写我们需要的方法。

### 什么是并发集合类？ ###

Java集合类都是快速失效的，这就意味着当集合被改变且一个线程在使用迭代器遍历集合的时候，迭代器的next()方法将抛出`ConcurrentModificationException`异常。  
并发容器支持并发的遍历和并发的更新。主要的类有`ConcurrentHashMap`, `CopyOnWriteArrayList` 和`CopyOnWriteArraySet`

### 什么是Executors类？ ###

Executors为Executor，ExecutorService，ScheduledExecutorService，ThreadFactory和Callable类提供了一些工具方法。Executors可以用于方便的创建线程池。

### Java 8中，Concurrency API有哪些改进？ ###

一些改进如下：  
`ConcurrentHashMap` 改进了compute(), forEach(), forEachEntry(), forEachKey(), forEachValue(), merge(), reduce() 和 search() 方法.  
CompletableFuture that may be explicitly completed (setting its value and status).  
`Executors` 的newWorkStealingPool() 方法创建一个 work-stealing 线程池，使用目前机器上可用的处理器作为它的并行级别。

#  #

### Java 多线程面试问题 ###

1. 进程和线程之间有什么不同？

一个进程是一个独立(self contained)的运行环境，它可以被看作一个程序或者一个应用。而线程是在进程中执行的一个任务。Java运行环境是一个包含了不同的类和程序的单一进程。线程可以被称为轻量级进程。线程需要较少的资源来创建和驻留在进程中，并且可以共享进程中的资源。

2. 多线程编程的好处是什么？

在多线程程序中，多个线程被并发的执行以提高程序的效率，CPU不会因为某个线程需要等待资源而进入空闲状态。多个线程共享堆内存(heap memory)，因此创建多个线程去执行一些任务会比创建多个进程更好。举个例子，Servlets比CGI更好，是因为Servlets支持多线程而CGI不支持。

3. 用户线程和守护线程有什么区别？

当我们在Java程序中创建一个线程，它就被称为用户线程。一个守护线程是在后台执行并且不会阻止JVM终止的线程。当没有用户线程在运行的时候，JVM关闭程序并且退出。一个守护线程创建的子线程依然是守护线程。

4. 我们如何创建一个线程？

有两种创建线程的方法：一是实现Runnable接口，然后将它传递给Thread的构造函数，创建一个Thread对象；二是直接继承Thread类。若想了解更多可以阅读这篇关于如何在Java中创建线程的文章。

5. 有哪些不同的线程生命周期？

当我们在Java程序中新建一个线程时，它的状态是New。当我们调用线程的start()方法时，状态被改变为Runnable。线程调度器会为Runnable线程池中的线程分配CPU时间并且讲它们的状态改变为Running。其他的线程状态还有Waiting，Blocked 和Dead。读这篇文章可以了解更多关于线程生命周期的知识。

6. 可以直接调用Thread类的run ()方法么？

当然可以，但是如果我们调用了Thread的run()方法，它的行为就会和普通的方法一样，为了在新的线程中执行我们的代码，必须使用Thread.start()方法。

7. 如何让正在运行的线程暂停一段时间？

我们可以使用Thread类的Sleep()方法让线程暂停一段时间。需要注意的是，这并不会让线程终止，一旦从休眠中唤醒线程，线程的状态将会被改变为Runnable，并且根据线程调度，它将得到执行。

8. 你对线程优先级的理解是什么？

每一个线程都是有优先级的，一般来说，高优先级的线程在运行时会具有优先权，但这依赖于线程调度的实现，这个实现是和操作系统相关的(OS dependent)。我们可以定义线程的优先级，但是这并不能保证高优先级的线程会在低优先级的线程前执行。线程优先级是一个int变量(从1-10)，1代表最低优先级，10代表最高优先级。

9. 什么是线程调度器(Thread Scheduler)和时间分片(Time Slicing )？

线程调度器是一个操作系统服务，它负责为Runnable状态的线程分配CPU时间。一旦我们创建一个线程并启动它，它的执行便依赖于线程调度器的实现。时间分片是指将可用的CPU时间分配给可用的Runnable线程的过程。分配CPU时间可以基于线程优先级或者线程等待的时间。线程调度并不受到Java虚拟机控制，所以由应用程序来控制它是更好的选择（也就是说不要让你的程序依赖于线程的优先级）。

10. 在多线程中，什么是上下文切换(context-switching )？

上下文切换是存储和恢复CPU状态的过程，它使得线程执行能够从中断点恢复执行。上下文切换是多任务操作系统和多线程环境的基本特征。

11. 你如何确保main()方法所在的线程是Java 程序最后结束的线程？

我们可以使用Thread类的joint()方法来确保所有程序创建的线程在main()方法退出前结束。这里有一篇文章关于Thread类的joint()方法 。

12. 线程之间是如何通信的？

当线程间是可以共享资源时，线程间通信是协调它们的重要的手段。Object类中wait()\\notify()\\notifyAll()方法可以用于线程间通信关于资源的锁的状态。点击这里有更多关于线程wait, notify和notifyAll.

13. 为什么线程通信的方法wait(), notify()和notifyAll()被定义在Object 类里？

Java的每个对象中都有一个锁(monitor，也可以成为监视器) 并且wait()，notify()等方法用于等待对象的锁或者通知其他线程对象的监视器可用。在Java的线程中并没有可供任何对象使用的锁和同步器。这就是为什么这些方法是Object类的一部分，这样Java的每一个类都有用于线程间通信的基本方法

14. 为什么wait(), notify()和notifyAll ()必须在同步方法或者同步块中被调用？

当一个线程需要调用对象的wait()方法的时候，这个线程必须拥有该对象的锁，接着它就会释放这个对象锁并进入等待状态直到其他线程调用这个对象上的notify()方法。同样的，当一个线程需要调用对象的notify()方法时，它会释放这个对象的锁，以便其他在等待的线程就可以得到这个对象锁。由于所有的这些方法都需要线程持有对象的锁，这样就只能通过同步来实现，所以他们只能在同步方法或者同步块中被调用。

15. 为什么Thread类的sleep()和yield ()方法是静态的？

Thread类的sleep()和yield()方法将在当前正在执行的线程上运行。所以在其他处于等待状态的线程上调用这些方法是没有意义的。这就是为什么这些方法是静态的。它们可以在当前正在执行的线程中工作，并避免程序员错误的认为可以在其他非运行线程调用这些方法。

16 .如何确保线程安全？

在Java中可以有很多方法来保证线程安全——同步，使用原子类(atomic concurrent classes)，实现并发锁，使用volatile关键字，使用不变类和线程安全类。在线程安全教程中，你可以学到更多。

17. volatile关键字在Java 中有什么作用？

当我们使用volatile关键字去修饰变量的时候，所以线程都会直接读取该变量并且不缓存它。这就确保了线程读取到的变量是同内存中是一致的。

18. 同步方法和同步块，哪个是更好的选择？

同步块是更好的选择，因为它不会锁住整个对象（当然你也可以让它锁住整个对象）。同步方法会锁住整个对象，哪怕这个类中有多个不相关联的同步块，这通常会导致他们停止执行并需要等待获得这个对象上的锁。

19. 如何创建守护线程？

使用Thread类的setDaemon(true)方法可以将线程设置为守护线程，需要注意的是，需要在调用start()方法前调用这个方法，否则会抛出IllegalThreadStateException异常。

20. 什么是ThreadLocal?

ThreadLocal用于创建线程的本地变量，我们知道一个对象的所有线程会共享它的全局变量，所以这些变量不是线程安全的，我们可以使用同步技术。但是当我们不想使用同步的时候，我们可以选择ThreadLocal变量。  
每个线程都会拥有他们自己的Thread变量，它们可以使用get()\\set()方法去获取他们的默认值或者在线程内部改变他们的值。ThreadLocal实例通常是希望它们同线程状态关联起来是private static属性。在ThreadLocal例子这篇文章中你可以看到一个关于ThreadLocal的小程序。

21. 什么是Thread Group ？为什么建议使用它？

ThreadGroup是一个类，它的目的是提供关于线程组的信息。  
ThreadGroup API比较薄弱，它并没有比Thread提供了更多的功能。它有两个主要的功能：一是获取线程组中处于活跃状态线程的列表；二是设置为线程设置未捕获异常处理器(ncaught exception handler)。但在Java 1.5中Thread类也添加了setUncaughtExceptionHandler(UncaughtExceptionHandler eh) 方法，所以ThreadGroup是已经过时的，不建议继续使用。

t1.setUncaughtExceptionHandler(new UncaughtExceptionHandler(){
    
    @Override
    public void uncaughtException(Thread t, Throwable e) {
    System.out.println("exception occured:"+e.getMessage());
    }
    
    });

22. 什么是Java线程转储(Thread Dump )，如何得到它？

线程转储是一个JVM活动线程的列表，它对于分析系统瓶颈和死锁非常有用。有很多方法可以获取线程转储——使用Profiler，Kill -3命令，jstack工具等等。我更喜欢jstack工具，因为它容易使用并且是JDK自带的。由于它是一个基于终端的工具，所以我们可以编写一些脚本去定时的产生线程转储以待分析。读这篇文档可以了解更多关于产生线程转储的知识。

23. 什么是死锁(Deadlock )？如何分析和避免死锁？

死锁是指两个以上的线程永远阻塞的情况，这种情况产生至少需要两个以上的线程和两个以上的资源。

分析死锁，我们需要查看Java应用程序的线程转储。我们需要找出那些状态为BLOCKED的线程和他们等待的资源。每个资源都有一个唯一的id，用这个id我们可以找出哪些线程已经拥有了它的对象锁。

避免嵌套锁，只在需要的地方使用锁和避免无限期等待是避免死锁的通常办法，阅读这篇文章去学习如何分析死锁。

24. 什么是Java Timer 类？如何创建一个有特定时间间隔的任务？

java.util.Timer是一个工具类，可以用于安排一个线程在未来的某个特定时间执行。Timer类可以用安排一次性任务或者周期任务。

java.util.TimerTask是一个实现了Runnable接口的抽象类，我们需要去继承这个类来创建我们自己的定时任务并使用Timer去安排它的执行。

这里有关于java Timer的例子。

25. 什么是线程池？如何创建一个Java 线程池？

一个线程池管理了一组工作线程，同时它还包括了一个用于放置等待执行的任务的队列。

java.util.concurrent.Executors提供了一个 java.util.concurrent.Executor接口的实现用于创建线程池。线程池例子 展现了如何创建和使用线程池，或者阅读 ScheduledThreadPoolExecutor 例子，了解如何创建一个周期任务。

26.现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行？

这个多线程问题比较简单，可以用join方法实现。

27. 在Java中Lock接口比synchronized块的优势是什么？你需要实现一个高效的缓存，它允许多个用户读，但只允许一个用户写，以此来保持它的完整性，你会怎样去实现它？

lock接口在多线程和并发编程中最大的优势是它们为读和写分别提供了锁，它能满足你写像ConcurrentHashMap这样的高性能数据结构和有条件的阻塞。Java线程面试的问题越来越会根据面试者的回答来提问。我强烈建议在你去参加多线程的面试之前认真读一下Locks，因为当前其大量用于构建电子交易终统的客户端缓存和交易连接空间。

28.在java中wait和sleep方法的不同？

通常会在电话面试中经常被问到的Java线程面试问题。最大的不同是在等待时wait会释放锁，而sleep一直持有锁。Wait通常被用于线程间交互，sleep通常被用于暂停执行。

[Lock]: http://www.yuanmianshi.com/wp-content/uploads/2014/10/lock.jpg
[lock-implement.jpg]: http://www.yuanmianshi.com/wp-content/uploads/2014/10/lock-implement.jpg
[BlockingQueue.jpg]: http://www.yuanmianshi.com/wp-content/uploads/2014/10/BlockingQueue.jpg