2019年java中高级java面试题（七）多线程

待我称王封你为后i 2022-01-21 11:21 227阅读 0赞

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

Thread t1 = new Thread(() -> System.out.println("t1执行"));
            Thread t2 = new Thread(() -> System.out.println("t2执行"));
            Thread t3 = new Thread(() -> System.out.println("t3执行"));
            try {
                // t1先启动
                t1.start();
                t1.join();
                // t2
                t2.start();
                t2.join();
                // t3
                t3.start();
                t3.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

上述主要是利用join方法  等待该线程终止。主线程等待t1执行完     再开启t2线程，等待t2线程执行完再执行线程t3

join方法源码分析

public final synchronized void join(long millis)throws InterruptedException {
            long base = System.currentTimeMillis();
            long now = 0;
     
            if (millis < 0) {
                throw new IllegalArgumentException("timeout value is negative");
            }
     
            if (millis == 0) {
                while (isAlive()) {
                    wait(0);
                }
            } else {
                while (isAlive()) {
                    long delay = millis - now;
                    if (delay <= 0) {
                        break;
                    }
                    wait(delay);
                    now = System.currentTimeMillis() - base;
                }
            }
        }

###    2、 什么是线程 ###

线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。

### 3、 线程和进程有什么区别？ ###

线程是进程的子集，一个进程可以有很多线程，每条线程并行执行不同的任务。不同的进程使用不同的内存空间，而所有的线程共享一片相同的内存空间

### 4、 Java中Runnable和Callable有什么不同？ ###

Runnable和Callable都代表那些要在不同的线程中执行的任务。Runnable从JDK1.0开始就有了，Callable是在JDK1.5增加的。它们的主要区别是

(1)Callable规定的方法是call()，Runnable规定的方法是run()。其中Runnable可以提交给Thread来包装下，直接启动一个线程来执行，而Callable则一般都是提交给ExecuteService来执行。

(2)Callable的任务执行后可返回值，而Runnable的任务是不能返回值得

(3)call方法可以抛出异常，run方法不可以

(4)运行Callable任务可以拿到一个Future对象，c表示异步计算的结果。

### 5、Java中CountDownLatch 和CyclicBarrier 有什么不同？ ###

CountDownLatch类位于java.util.concurrent包下，利用它可以实现类似计数器的功能，一个线程(或者多个)， 等待另外N个线程完成某个事情之后才能执行

CyclicBarrier通过它可以实现让一组线程等待至某个状态之后再全部同时执行，CyclicBarrier可以被重用

<table> 
 <tbody> 
  <tr> 
   <td> <p>CountDownLatch</p> </td> 
   <td> <p>CyclicBarrier</p> </td> 
  </tr> 
  <tr> 
   <td> <p>减计数方式</p> </td> 
   <td> <p>加计数方式</p> </td> 
  </tr> 
  <tr> 
   <td> <p>计算为0时释放所有等待的线程</p> </td> 
   <td> <p>计数达到指定值时释放所有等待线程</p> </td> 
  </tr> 
  <tr> 
   <td> <p>计数为0时，无法重置</p> </td> 
   <td> <p>计数达到指定值时，计数置为0重新开始</p> </td> 
  </tr> 
  <tr> 
   <td> <p>调用countDown()方法计数减一，调用await()方法只进行阻塞，对计数没任何影响</p> </td> 
   <td> <p>调用await()方法计数加1，若加1后的值不等于构造方法的值，则线程阻塞</p> </td> 
  </tr> 
  <tr> 
   <td> <p>不可重复利用</p> </td> 
   <td> <p>可重复利用</p> </td> 
  </tr> 
 </tbody> 
</table>

### 6、线程运行的多种状态 ###

*           创建  new Thread类或者其子类对象。
 *           运行 start().  具备者CPU的执行资格和CPU的执行权。
 *           冻结 释放了CPU的执行资格和CPU的执行权。比如执行到sleep(time)  wait() 导致线程冻结。
 *           临时阻塞状态： 具备者CPU的执行资格，不具备CPU的执行权。
 *          消亡：线程结束。run方法结束

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6YXVfaXRkb2c_size_16_color_FFFFFF_t_70][]

### 7、Java中的volatile 变量是什么？ ###

volatile是一个特殊的修饰符，只有成员变量才能使用它。　当一个共享变量被volatile修饰时，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，它会去内存中读取新值。

volatile特性一：内存可见性，即线程A对volatile变量的修改，其他线程获取的volatile变量都是最新的。

volatile特性二：可以禁止指令重排序

volatile关键字保证了操作的可见性，但是不能保证对变量的操作是原子性。

### 8、 volatile的原理和实现机制 ###

加入volatile关键字时，生成的汇编代码会多出一个lock前缀指令

lock前缀指令实际上相当于一个内存屏障（也成内存栅栏），内存屏障会提供3个功能：

1）它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成；

2）它会强制将对缓存的修改操作立即写入主存；

3）如果是写操作，它会导致其他CPU中对应的缓存行无效。

### 9、 使用volatile关键字的场景 ###

1、状态标记量

volatile boolean flag= false;
     
    // 线程1
    context = loadContext();
    flag= true;
     
    // 线程2
    while(!flag) {
        sleep();
    }
    doSomethingWithConfig(context);

2、双重检查

所谓双重检查加锁机制，指的是：并不是每次进入getInstance方法都需要同步，而是先不同步，进入方法过后，先检查实例是否存在，如果不存在才进入下面的同步块，这是第一重检查。进入同步块过后，再次检查实例是否存在，如果不存在，就在同步的情况下创建一个实例，这是第二重检查。这样一来，就只需要同步一次了，从而减少了多次在同步情况下进行判断所浪费的时间。

public class Singleton {
        private volatile static Singleton instance = null;
     
        private Singleton() {}
     
        public static Singleton getInstance() {
            if (instance == null) {
                synchronized (Singleton.class) {// 1
                    if (instance == null) {// 2
                        instance = new Singleton();// 3
                    }
                }
            }
            return instance;
        }
    }

3、独立观察（independent observation）

安全使用 volatile 的另一种简单模式是：定期 “发布” 观察结果供程序内部使用。例如，假设有一种环境传感器能够感觉环境温度。一个后台线程可能会每隔几秒读取一次该传感器，并更新包含当前文档的 volatile 变量。然后，其他线程可以读取这个变量，从而随时能够看到最新的温度值。

使用该模式的另一种应用程序就是收集程序的统计信息。下面程序 展示了身份验证机制如何记忆最近一次登录的用户的名字。将反复使用lastUser引用来发布值，以供程序的其他部分使用。

public class UserManager {
        public volatile String lastUser;
     
        public boolean authenticate(String user, String password) {
            boolean valid = passwordIsValid(user, password);
            if (valid) {
                User u = new User();
                activeUsers.add(u);
                lastUser = user;
            }
            return valid;
        }
    }

4、“volatile bean” 模式

volatile bean 模式适用于将 JavaBeans 作为“荣誉结构”使用的框架。在 volatile bean 模式中，JavaBean 被用作一组具有 getter 和/或 setter 方法 的独立属性的容器。volatile bean 模式的基本原理是：很多框架为易变数据的持有者（例如 HttpSession）提供了容器，但是放入这些容器中的对象必须是线程安全的。

在 volatile bean 模式中，JavaBean 的所有数据成员都是 volatile 类型的，并且 getter 和 setter 方法必须非常普通 —— 除了获取或设置相应的属性外，不能包含任何逻辑。此外，对于对象引用的数据成员，引用的对象必须是有效不可变的。（这将禁止具有数组值的属性，因为当数组引用被声明为 volatile 时，只有引用而不是数组本身具有 volatile 语义）。对于任何 volatile 变量，不变式或约束都不能包含 JavaBean 属性。下面代码示例展示了遵守 volatile bean 模式的 JavaBean：

@ThreadSafe
    public class Person {
        private volatile String firstName;
        private volatile String lastName;
        private volatile int age;
     
        public String getFirstName() { return firstName; }
        public String getLastName() { return lastName; }
        public int getAge() { return age; }
     
        public void setFirstName(String firstName) { 
            this.firstName = firstName;
        }
     
        public void setLastName(String lastName) { 
            this.lastName = lastName;
        }
     
        public void setAge(int age) { 
            this.age = age;
        }
    }

5 、开销较低的读－写锁策略

目前为止，您应该了解了 volatile 的功能还不足以实现计数器。因为++x 实际上是三种操作（读、添加、存储）的简单组合，如果多个线程凑巧试图同时对 volatile 计数器执行增量操作，那么它的更新值有可能会丢失。

然而，如果读操作远远超过写操作，您可以结合使用内部锁和 volatile 变量来减少公共代码路径的开销。清单 6 中显示的线程安全的计数器使用synchronized确保增量操作是原子的，并使用volatile 保证当前结果的可见性。如果更新不频繁的话，该方法可实现更好的性能，因为读路径的开销仅仅涉及 volatile 读操作，这通常要优于一个无竞争的锁获取的开销。

@ThreadSafe
    public class CheesyCounter {
        // Employs the cheap read-write lock trick
        // All mutative operations MUST be done with the 'this' lock held
        @GuardedBy("this") private volatile int value;
     
        public int getValue() { return value; }
     
        public synchronized int increment() {
            return value++;
        }
    }

有关volatile 查看[更多][Link 1]

### 10、如何终止一个线程 ###

Java提供了很丰富的API但没有为停止线程提供API。JDK 1.0本来有一些像stop(), suspend() 和 resume()的控制方法但是由于潜在的死锁威胁因此在后续的JDK版本中他们被弃用了，之后Java API的设计者就没有提供一个兼容且线程安全的方法来停止一个线程。当run() 或者 call() 方法执行完的时候线程会自动结束,如果要手动结束一个线程，你可以用volatile 布尔变量来退出run()方法的循环或者是取消任务来中断线程。示例代码

public class StopThreadDemo implements Runnable {
     
        private volatile boolean stopFlag = false;
     
        @Override
        public void run() {
     
            while (!stopFlag) {
                synchronized (StopThreadDemo.class) {
                    System.out.println("我好忙啊，我在做事情！");
                    try {
                        StopThreadDemo.class.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                        this.stopThread();
                    }
                }
            }
        }
     
        private void stopThread() {
            stopFlag = true;
            System.out.println("老子把线程给停了！");
        }
     
        public static void main(String[] args) {
            StopThreadDemo d = new StopThreadDemo();
            Thread t1 = new Thread(d, "旺财");
            Thread t2 = new Thread(d, "小强");
            try {
                t1.start();
                t2.start();
                Thread.sleep(5000);
                t1.interrupt();// 对t1线程对象进行中断状态的清除，强制让其恢复到运行状态。
                t2.interrupt();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

###    11、 生产者消费者模型     ###

class BoundedBuffer {
       final Lock lock = new ReentrantLock();
       final Condition notFull  = lock.newCondition(); 
       final Condition notEmpty = lock.newCondition(); 
     
       final Object[] items = new Object[100];
       int putptr, takeptr, count;
     
       public void put(Object x) throws InterruptedException {
         lock.lock();
         try {
           while (count == items.length) 
             notFull.await();
           items[putptr] = x; 
           if (++putptr == items.length) putptr = 0;
           ++count;
           notEmpty.signal();
         } finally {
           lock.unlock();
         }
       }
     
       public Object take() throws InterruptedException {
         lock.lock();
         try {
           while (count == 0) 
             notEmpty.await();
           Object x = items[takeptr]; 
           if (++takeptr == items.length) takeptr = 0;
           --count;
           notFull.signal();
           return x;
         } finally {
           lock.unlock();
         }
       } 
     }

###    12、 什么是ThreadLocal变量？ ###

ThreadLocal是线程本地的变量，只要是本线程内都可以使用，线程结束了，那么相应的线程本地变量也就跟随着线程消失了。

在Thread类里面有一个ThreadLocalMap，用于存储每一个线程的变量的引用，这个Map中的键为ThreadLocal对象，而值对应的是ThreadLocal通过set放进去的变量引用。

### 13、 什么是FutureTask？ ###

在Java并发程序中FutureTask表示一个可以取消的异步运算。它有启动和取消运算、查询运算是否完成和取回运算结果等方法，此类提供了对 Future 的基本实现。只有当运算完成的时候结果才能取回，如果运算尚未完成get方法将会阻塞。可使用 FutureTask 包装 Callable 或 Runnable 对象。因为 FutureTask 实现了 Runnable，所以可将 FutureTask 提交给 Executor 执行

### 14、 Java中interrupt 、interrupted 和 isInterruptedd方法的区别？ ###

interrupt 中断线程。

如果当前线程没有中断它自己（这在任何情况下都是允许的），则该线程的 checkAccess 方法就会被调用，这可能抛出 SecurityException。

如果线程在调用 Object 类的 wait()、wait(long) 或 wait(long, int) 方法，或者该类的 join()、join(long)、join(long, int)、sleep(long) 或 sleep(long, int) 方法过程中受阻，则其中断状态将被清除，它还将收到一个 InterruptedException。

如果该线程在可中断的通道上的 I/O 操作中受阻，则该通道将被关闭，该线程的中断状态将被设置并且该线程将收到一个 ClosedByInterruptException。

如果该线程在一个 Selector 中受阻，则该线程的中断状态将被设置，它将立即从选择操作返回，并可能带有一个非零值，就好像调用了选择器的 wakeup 方法一样。

如果以前的条件都没有保存，则该线程的中断状态将被设置。

中断一个不处于活动状态的线程不需要任何作用。

interrupted() 和 isInterrupted()的主要区别是前者会将中断状态清除而后者不会。

（1）interrupted 是作用于当前线程，isInterrupted 是作用于调用该方法的线程对象所对应的线程。

（2）这两个方法最终都会调用同一个方法isInterrupted（boolean flag），只不过参数一个是true，一个是false。是前者会将中断状态清除而后者不会。

### 15、Java中的同步集合与并发集合有什么区别？ ###

不管是同步集合还是并发集合他们都支持线程安全，他们之间主要的区别体现在性能和可扩展性，还有他们如何实现的线程安全。同步HashMap, Hashtable, HashSet, Vector, ArrayList 相比他们并发的实现（比如：ConcurrentHashMap, CopyOnWriteArrayList, CopyOnWriteHashSet）会慢得多。造成如此慢的主要原因是锁， 同步集合会把整个Map或List锁起来，而并发集合不会。并发集合实现线程安全是通过使用先进的和成熟的技术像锁剥离。比如ConcurrentHashMap 会把整个Map 划分成几个片段，只对相关的几个片段上锁，同时允许多线程访问其他未上锁的片段。

### 16、 常用的线程池 ###

ThreadPoolExecutor

构造方法：

public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,
    TimeUnit unit,BlockingQueue<Runnable> workQueue,
    ThreadFactory threadFactory,RejectedExecutionHandler handler)

参数：

corePoolSize - 池中所保存的线程数，包括空闲线程。

maximumPoolSize - 池中允许的最大线程数。

keepAliveTime - 当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间。

unit - keepAliveTime 参数的时间单位。

workQueue - 执行前用于保持任务的队列。此队列仅保持由 execute 方法提交的 Runnable 任务。

threadFactory - 执行程序创建新线程时使用的工厂。

handler - 由于超出线程范围和队列容量而使执行被阻塞时所使用的处理程序。

<table>  超出线程范围和队列容量而使执行被阻塞时所使用的处理程序  
 <tbody> 
  <tr> 
   <td>策略</td> 
   <td>含义</td> 
  </tr> 
  <tr> 
   <td><a href="https://blog.csdn.net/java/util/concurrent/ThreadPoolExecutor.AbortPolicy.html" rel="nofollow">ThreadPoolExecutor.AbortPolicy</a></td> 
   <td>&nbsp;&nbsp;用于被拒绝任务的处理程序，它将抛出 RejectedExecutionException</td> 
  </tr> 
  <tr> 
   <td><a href="https://blog.csdn.net/java/util/concurrent/ThreadPoolExecutor.CallerRunsPolicy.html" rel="nofollow">ThreadPoolExecutor.CallerRunsPolicy</a></td> 
   <td>&nbsp;用于被拒绝任务的处理程序，它直接在 execute 方法的调用线程中运行被拒绝的任务；如果执行程序已关闭，则会丢弃该任务。</td> 
  </tr> 
  <tr> 
   <td><a href="https://blog.csdn.net/java/util/concurrent/ThreadPoolExecutor.DiscardOldestPolicy.html" rel="nofollow">ThreadPoolExecutor.DiscardOldestPolicy</a>&nbsp;</td> 
   <td>用于被拒绝任务的处理程序，它放弃最旧的未处理请求，然后重试 execute；如果执行程序已关闭，则会丢弃该任务。</td> 
  </tr> 
  <tr> 
   <td><a href="https://blog.csdn.net/java/util/concurrent/ThreadPoolExecutor.DiscardPolicy.html" rel="nofollow">ThreadPoolExecutor.DiscardPolicy</a>&nbsp;</td> 
   <td>用于被拒绝任务的处理程序，默认情况下它将丢弃被拒绝的任务。</td> 
  </tr> 
 </tbody> 
</table>

*  AbortPolicy 丢弃任务，抛运行时异常
 *  CallerRunsPolicy 执行任务
 *  DiscardPolicy 忽视，什么都不会发生
 *  DiscardOldestPolicy 从队列中踢出最先进入队列（最后一个执行）的任务

线程池工具类 Executors 可以构造常用的线程池

<table> 
 <tbody> 
  <tr> 
   <td style="width:295px;">线程池</td> 
   <td style="width:553px;">&nbsp;</td> 
  </tr> 
  <tr> 
   <td style="width:295px;">newFixedThreadPool(int nThreads)</td> 
   <td style="width:553px;"> <pre><code>
public static ExecutorService newFixedThreadPool(int nThreads){
    return new ThreadPoolExecutor(nThreads, nThreads,
    0L, TimeUnit.MILLISECONDS,
    new LinkedBlockingQueue&lt;Runnable&gt;());

}
</code></pre> 创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程</td> 
  </tr> 
  <tr> 
   <td style="width:295px;">newCachedThreadPool()</td> 
   <td style="width:553px;"> <pre><code>public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue&lt;Runnable&gt;());
}
</code></pre> <p>创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们</p> </td> 
  </tr> 
  <tr> 
   <td style="width:295px;">newScheduledThreadPool(int corePoolSize)</td> 
   <td style="width:553px;">创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。</td> 
  </tr> 
  <tr> 
   <td style="width:295px;">newSingleThreadExecutor()</td> 
   <td style="width:553px;"> <pre><code>public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue&lt;Runnable&gt;()));
}
</code></pre> <p>创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程</p> </td> 
  </tr> 
 </tbody> 
</table>

## ##

### 17、 sleep和wait的区别? ###

sleep和wait都会使线程进入冻结状态，并且都会释放cpu的执行权和cpu的执行资格，不同的是sleep不会释放锁，而wait会连锁一起释放。  
sleep()方法可以在任何地方使用；wait()方法则只能在同步方法或同步块中使用  
sleep方法是Thread类中定义的方法,wait是Object中定义的方法

### 18、  fail-fast和fail-safe机制 ###

fail-fast即快速失败机制，是java集合(Collection)中的一种错误检测机制。当在迭代集合的过程中该集合在结构上发生改变的时候，就有可能会发生fail-fast，即抛出ConcurrentModificationException异常

fail-safe 采用安全失败机制的集合容器，在遍历时不是直接在集合内容上访问的，而是先复制原有集合内容，在拷贝的集合上进行遍历

### 19 、JVM性能调优监控工具jps、jstack、jmap、jhat、jstat、hprof使用 ###

A、 jps(Java Virtual Machine Process Status Tool)

jps主要用来输出JVM中运行的进程状态信息。语法格式如下：

jps [options] [hostid]

如果不指定hostid就默认为当前主机或服务器。

命令行参数选项说明如下：

-q 不输出类名、Jar名和传入main方法的参数
     
    -m 输出传入main方法的参数
     
    -l 输出main类或Jar的全限名
     
    -v 输出传入JVM的参数

比如下面：

![20190218151725956.png][]

B、 jstack

jstack主要用来查看某个Java进程内的线程堆栈信息。语法格式如下：

jstack [option] pid
    jstack [option] executable core
    jstack [option] [server-id@]remote-hostname-or-ip

命令行参数选项说明如下：

-l long listings，会打印出额外的锁信息，在发生死锁时可以用jstack -l pid来观察锁持有情况-m mixed mode，不仅会输出Java堆栈信息，还会输出C/C++堆栈信息（比如Native方法）

jstack可以定位到线程堆栈，根据堆栈信息我们可以定位到具体代码，所以它在JVM性能调优中使用得非常多。下面我们来一个实例找出某个Java进程中最耗费CPU的Java线程并定位堆栈信息，用到的命令有ps、top、printf、jstack、grep。

查找最消耗cpu的java线程

命令：可以使用ps -Lfp pid或者ps -mp pid -o THREAD, tid, time或者top -Hp pid

![170402_A57i_111708.png][]

TIME列就是各个Java线程耗费的CPU时间，CPU时间最长的是线程ID为21742的线程，用

printf "%x\n" 21742

得到21742的十六进制值为54ee，下面会用到。

OK，下一步终于轮到jstack上场了，它用来输出进程21711的堆栈信息，然后根据线程ID的十六进制值grep，如下：

root@ubuntu:/# jstack 21711 | grep 54ee
    "PollIntervalRetrySchedulerThread" prio=10 tid=0x00007f950043e000 nid=0x54ee in Object.wait() [0x00007f94c6eda000

C、 jmap（Memory Map）和jhat（Java Heap Analysis Tool）

jmap用来查看堆内存使用状况，一般结合jhat使用。

jmap语法格式如下：

jmap [option] pid
    jmap [option] executable core
    jmap [option] [server-id@]remote-hostname-or-ip

D、jstat（JVM统计监测工具）

语法格式如下：

jstat [ generalOption | outputOptions vmid [interval[s|ms] [count]] ]

vmid是Java虚拟机ID，在Linux/Unix系统上一般就是进程ID。interval是采样时间间隔。count是采样数目。比如下面输出的是GC信息，采样时间间隔为250ms，采样数为4：

![20190218155734807.png][]

![20160220110058880 (558Ã231)][20160220110058880 _558_231]

可以看出：

堆内存 = 年轻代 + 年老代 
    年轻代 = Eden区 + 两个Survivor区（From和To）

现在来解释各列含义：

S0C、S1C、S0U、S1U：Survivor 0/1区容量（Capacity）和使用量（Used）
    EC、EU：Eden区容量和使用量
    OC、OU：年老代容量和使用量
    MC、MU：元数据空间容量和使用量
    CCSC、CCSU
    YGC、YGT：年轻代GC次数和GC耗时
    FGC、FGCT：Full GC次数和Full GC耗时
    GCT：GC总耗时

E、hprof（Heap/CPU Profiling Tool）

hprof能够展现CPU使用率，统计堆内存使用情况。

语法格式如下：

java -agentlib:hprof[=options] ToBeProfiledClass
    java -Xrunprof[:options] ToBeProfiledClass
    javac -J-agentlib:hprof[=options] ToBeProfiledClass

###    20、  Java中的同步集合与并发集合有什么区别 ###

同样的，CopyOnWriteArrayList 允许多个线程以非同步的方式读，当有线程写的时候它会将整个List复制一个副本给它。

如果在读多写少这种对并发集合有利的条件下使用并发集合，这会比使用同步集合更具有可伸缩性。

同步集合与并发集合都为多线程和并发提供了合适的线程安全的集合，不过并发集合的可扩展性更高。在Java1.5之前程序员们只有同步集合来用且在多线程并发的时候会导致争用，阻碍了系统的扩展性。Java5介绍了并发集合像ConcurrentHashMap，不仅提供线程安全还用锁分离和内部分区等现代技术提高了可扩展性。

### 21、 Java中synchronized 和 ReentrantLock 有什么不同 ###

这两种方式最大区别就是对于Synchronized来说，它是java语言的关键字，是原生语法层面的互斥，需要jvm实现。而ReentrantLock它是JDK 1.5之后提供的API层面的互斥锁，需要lock()和unlock()方法配合try/finally语句块来完成。

Synchronized进过编译，会在同步块的前后分别形成monitorenter和monitorexit这个两个字节码指令。在执行monitorenter指令时，首先要尝试获取对象锁。如果这个对象没被锁定，或者当前线程已经拥有了那个对象锁，把锁的计算器加1，相应的，在执行monitorexit指令时会将锁计算器就减1，当计算器为0时，锁就被释放了。如果获取对象锁失败，那当前线程就要阻塞，直到对象锁被另一个线程释放为止。

### 22、 Java中的fork join框架是什么？ ###

Fork/Join框架是Java 7提供的一个用于并行执行任务的框架，是一个把大任务分割成若干个小任务，最终汇总每个小任务结果后得到大任务结果的框架。Fork/Join框架要完成两件事情：

1.任务分割：首先Fork/Join框架需要把大的任务分割成足够小的子任务，如果子任务比较大的话还要对子任务进行继续分割

2.执行任务并合并结果：分割的子任务分别放到双端队列里，然后几个启动线程分别从双端队列里获取任务执行。子任务执行完的结果都放在另外一个队列里，启动一个线程从队列里取数据，然后合并这些数据。

在Java的Fork/Join框架中，使用两个类完成上述操作

1.ForkJoinTask:我们要使用Fork/Join框架，首先需要创建一个ForkJoin任务。该类提供了在任务中执行fork和join的机制。通常情况下我们不需要直接集成ForkJoinTask类，只需要继承它的子类，Fork/Join框架提供了两个子类：

a.RecursiveAction：用于没有返回结果的任务

b.RecursiveTask:用于有返回结果的任务

2.ForkJoinPool:ForkJoinTask需要通过ForkJoinPool来执行

任务分割出的子任务会添加到当前工作线程所维护的双端队列中，进入队列的头部。当一个工作线程的队列里暂时没有任务时，它会随机从其他工作线程的队列的尾部获取一个任务(工作窃取算法)。

public class CountTask extends RecursiveTask<Integer>{
     
        private static final int THREAD_HOLD = 2;
     
        private int start;
        private int end;
     
        public CountTask(int start,int end){
            this.start = start;
            this.end = end;
        }
     
        @Override
        protected Integer compute() {
            int sum = 0;
            //如果任务足够小就计算
            boolean canCompute = (end - start) <= THREAD_HOLD;
            if(canCompute){
                for(int i=start;i<=end;i++){
                    sum += i;
                }
            }else{
                int middle = (start + end) / 2;
                CountTask left = new CountTask(start,middle);
                CountTask right = new CountTask(middle+1,end);
                //执行子任务
                left.fork();
                right.fork();
                //获取子任务结果
                int lResult = left.join();
                int rResult = right.join();
                sum = lResult + rResult;
            }
            return sum;
        }
     
        public static void main(String[] args){
            ForkJoinPool pool = new ForkJoinPool();
            CountTask task = new CountTask(1,4);
            Future<Integer> result = pool.submit(task);
            try {
                System.out.println(result.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    }

###    23、 Java中的锁机制  偏向锁 & 轻量级锁 & 重量级锁各自优缺点及场景 ###

<table> 
 <tbody> 
  <tr> 
   <td> <p>锁</p> </td> 
   <td> <p>优点</p> </td> 
   <td> <p>缺点</p> </td> 
   <td> <p>适用场景</p> </td> 
  </tr> 
  <tr> 
   <td> <p>偏向锁</p> </td> 
   <td> <p>加锁和解锁不需要额外的消耗，和执行非同步方法比仅存在纳秒级的差距。</p> </td> 
   <td> <p>如果线程间存在锁竞争，会带来额外的锁撤销的消耗。</p> </td> 
   <td> <p>适用于只有一个线程访问同步块场景。</p> </td> 
  </tr> 
  <tr> 
   <td> <p>轻量级锁</p> </td> 
   <td> <p>竞争的线程不会阻塞，提高了程序的响应速度。</p> </td> 
   <td> <p>如果始终得不到锁竞争的线程使用自旋会消耗CPU。</p> </td> 
   <td> <p>追求响应时间。</p> <p>同步块执行速度非常快。</p> </td> 
  </tr> 
  <tr> 
   <td> <p>重量级锁</p> </td> 
   <td> <p>线程竞争不使用自旋，不会消耗CPU。</p> </td> 
   <td> <p>线程阻塞，响应时间缓慢。</p> </td> 
   <td> <p>追求吞吐量。</p> <p>同步块执行速度较长。</p> </td> 
  </tr> 
 </tbody> 
</table>

### 24 、synchronized修饰代码块、普通方法、静态方法有什么区别。 ###

修饰代码块获取的是指定的对象监视器。

修饰普通代码块并未显示使用monitorenter指令，而是通过标志位ACC\_SYNCHRONIZED标志位来判断是否由synchronized修饰，获取的是该实例对象的监视器。

修饰静态方法同普通方法，不同的是获取的是这个类的监视器

### 25、 synchronized 和 lock 有什么区别？ ###

1.首先synchronized是java内置关键字，在jvm层面，Lock是个java类；

2.synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁；

3.synchronized会自动释放锁(a 线程执行完同步代码会释放锁 ；b 线程执行过程中发生异常会释放锁)，Lock需在finally中手工释放锁（unlock()方法释放锁），否则容易造成线程死锁；

4.Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；

5.synchronized的锁可重入、不可中断、非公平，而Lock锁可重入、可判断、可公平（两者皆可）

6.Lock锁适合大量同步的代码的同步问题，synchronized锁适合代码少量的同步问题。

### 26、 什么是CAS? ###

使用锁时，线程获取锁是一种悲观锁策略，即假设每一次执行临界区代码都会产生冲突，所以当前线程获取到锁的时候同时也会阻塞其他线程获取该锁。而CAS操作（又称为无锁操作）是一种乐观锁策略，它假设所有线程访问共享资源的时候不会出现冲突，既然不会出现冲突自然而然就不会阻塞其他线程的操作。因此，线程就不会出现阻塞停顿的状态。那么，如果出现冲突了怎么办？无锁操作是使用CAS(compare and swap)又叫做比较交换来鉴别线程是否出现冲突，出现冲突就重试当前操作直到没有冲突为止。

CAS比较交换的过程可以通俗的理解为CAS(V,O,N)，包含三个值分别为：V 内存地址存放的实际值；O 预期的值（旧值）；N 更新的新值

### 27、 Synchronized 和 CAS ###

这是两者主要的区别是Synchronized在存在线程竞争的情况下会出现线程阻塞和唤醒锁带来的性能问题，因为这是一种互斥同步（阻塞同步）。

而CAS并不是武断的间线程挂起，当CAS操作失败后会进行一定的尝试，而非进行耗时的挂起唤醒的操作，因此也叫做非阻塞同步。

CAS的问题

ABA问题  
因为CAS会检查旧值有没有变化，这里存在这样一个有意思的问题。比如一个旧值A变为了成B，然后再变成A，刚好在做CAS时检查发现旧值并没有变化依然为A，但是实际上的确发生了变化。解决方案可以沿袭数据库中常用的乐观锁方式，添加一个版本号可以解决。原来的变化路径A->B->A就变成了1A->2B->3C。为了解决ABA问题，伟大的java为我们提供了AtomicMarkableReference和AtomicStampedReference类，为我们解决了问题

自旋时间过长

### 28、 java中原子操作 ###

（1）原子更新基本类型

atomic包提高原子更新基本类型的工具类，主要有这些：

AtomicBoolean：以原子更新的方式更新boolean；  
AtomicInteger：以原子更新的方式更新Integer;  
AtomicLong：以原子更新的方式更新Long  
（2）原子更新数组类型

atomic包下提供能原子更新数组中元素的类有：

AtomicIntegerArray：原子更新整型数组中的元素；  
AtomicLongArray：原子更新长整型数组中的元素；  
AtomicReferenceArray：原子更新引用类型数组中的元素  
（3）原子更新引用类型

如果需要原子更新引用类型变量的话，为了保证线程安全，atomic也提供了相关的类：

AtomicReference：原子更新引用类型；  
AtomicReferenceFieldUpdater：原子更新引用类型里的字段；  
AtomicMarkableReference：原子更新带有标记位的引用类型；  
（4）原子更新字段类型

如果需要更新对象的某个字段，并在多线程的情况下，能够保证线程安全，atomic同样也提供了相应的原子操作类：

AtomicIntegeFieldUpdater：原子更新整型字段类；  
AtomicLongFieldUpdater：原子更新长整型字段类；  
AtomicStampedReference：原子更新引用类型，这种更新方式会带有版本号。而为什么在更新的时候会带有版本号，是为了解决CAS的ABA问题；  
要想使用原子更新字段需要两步操作：

原子更新字段类都是抽象类，只能通过静态方法newUpdater来创建一个更新器，并且需要设置想要更新的类和属性；  
更新类的属性必须使用public volatile进行修饰；

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6YXVfaXRkb2c_size_16_color_FFFFFF_t_70]: /images/20220121/65d67f89562f4f43b804d9463178b202.png
[Link 1]: https://www.ibm.com/developerworks/cn/java/j-jtp06197.html
[20190218151725956.png]: /images/20220121/08837773b5cc4317bde578fc1988593d.png
[170402_A57i_111708.png]: /images/20220121/f8a51b6f590141b093e40e0908553913.png
[20190218155734807.png]: /images/20220121/bb83125f39d948d39703c67184de660e.png
[20160220110058880 _558_231]: /images/20220121/ec66e862de5d4c59ba06366cf618f6b8.png