java 面试线程

1、多线程中的i++线程安全吗？为什么？

i++和++i都是i=i+1的意思，但是过程有些许区别：

i++：先赋值再自加。（例如：i=1；a=1+i++；结果为a=1+1=2，语句执行完后i再进行自加为2）

++i：先自加再赋值。（例如：i=1；a=1+++i；结果为a=1+（1+1）=3，i先自加为2再进行运算）

但是在单独使用时没有区别：如for(int i=0;i<10;i++）{ }和for(int i=0;i<10;++i) { }没有区别。


i++和++i的线程安全分为两种情况：

1、如果i是局部变量（在方法里定义的），那么是线程安全的。因为局部变量是线程私有的，别的线程访问不到，其实也可以说没有线程安不
安全之说，因为别的线程对他造不成影响。

2、如果i是全局变量（类的成员变量），那么是线程不安全的。因为如果是全局变量的话，同一进程中的不同线程都有可能访问到。

如果有大量线程同时执行i++操作，i变量的副本拷贝到每个线程的线程栈，当同时有两个线程栈以上的线程读取线程变量，假如此时是1的话，
那么同时执行i++操作，再写入到全局变量，最后两个线程执行完，i会等于3而不会是2，所以，出现不安全性。

2、如何线程安全的实现一个计数器？

可以使用java提供的原子类AtomicInteger或者AtomicLong，底层是使用syncronized

3、多线程同步的方法

https://www.cnblogs.com/XHJT/p/3897440.html

4、介绍一下生产者消费者模式？
生产者消费者模型具体来讲，就是在一个系统中，存在生产者和消费者两种角色，他们通过内存缓冲区进行通信，生产者生产消费者需要的资料，消费者把资料做成产品。生产消费者模式如下图。

5、线程，进程，然后线程创建有很大开销，怎么优化？

线程池    https://www.cnblogs.com/dolphin0520/p/3932921.html

6、线程池运行流程，参数，策略

线程池的工作流程
当一个任务通过execute(Runnable)方法欲添加到线程池时：

如果此时线程池中的数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。
如果此时线程池中的数量等于 corePoolSize，但是缓冲队列 workQueue未满，那么任务被放入缓冲队列。
如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量小于maximumPoolSize，建新的线程来处理被
添加的任务。
如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maximumPoolSize，那么通过 handler所
指定的策略来处理此任务。也就是：处理任务的优先级为：核心线程corePoolSize、任务队列workQueue、最大线程maximumPoolSize，
如果三者都满了，使用handler处理被拒绝的任务。
当线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池可以动态的调整池中
的线程数。

基本参数：
 1. corePoolSize： 线程池维护线程的最少数量（也叫核心线程池数量）
 2. maximumPoolSize：线程池维护线程的最大数量
 3. keepAliveTime： 线程池维护线程所允许的空闲时间
 4. unit： 线程池维护线程所允许的空闲时间的单位
 5. workQueue： 线程池所使用的缓冲队列
 6. threadFactory：线程创建的工厂
 7. handler： 线程池对拒绝任务的处理策略

线程池的拒绝策略

1.AbortPolicy：该策略是线程池默认的策略，使用策略时，如果线程池的线程数满了，如果再有一个的任务进来，那么线程池会丢掉这个任务并且抛出RejectedExecutionException异常。

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            //不做任何处理，直接抛出异常
            throw new RejectedExecutionException("Task " + r.toString() +
                                                 " rejected from " +
                                                 e.toString());
        }

2.DiscardPolicy：这个策略和AbortPolicy的slient版本，如果线程池队列满了，再有新的任务进来，线程池则会直接丢掉这个任务并且不会有任何异常。

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        	//就是一个空的方法
        }

3.DiscardOldestPolicy：这个策略从字面上也很好理解，丢弃最老的。也就是说如果队列满了，会将最早进入队列的任务删掉腾出空间，再尝试加入队列。因为队列是队尾进，队头出，所以队头元素是最老的，因此每次都是移除对头元素后再尝试入队。

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
            	//移除队头元素
                e.getQueue().poll();
                //再尝试入队
                e.execute(r);
            }
        }

4.CallerRunsPolicy：使用此策略，如果添加到线程池失败，那么主线程会自己去执行该任务，不会等待线程池中的线程去执行。就像是个急脾气的人，我等不到别人来做这件事就干脆自己干。

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                //直接执行run方法
                r.run();
            }
        }

5.自定义策略，如果在使用过程中，Java对我们提供给我们的四种策略都不符合我们的要求，那我们可以自定义策略。自定义需要实现RejectedExecutionHandler接口，并重写其rejectedExecution方法，具体的策略代码我们写在rejectedExecution方法中就可以了。

public class MyRejectPolicy implements RejectedExecutionHandler{
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        //Sender是我的Runnable类，里面有message字段
        if (r instanceof Sender) {
            Sender sender = (Sender) r;
            //直接打印
            System.out.println(sender.getMessage());
        }
    }
}

7、讲一下AQS吧。

AQS是AbustactQueuedSynchronizer的简称，它是一个Java提高的底层同步工具类，用一个int类型的变量表示同步状态，并提供了一系列
的CAS操作来管理这个同步状态。AQS的主要作用是为Java中的并发同步组件提供统一的底层支持，例如ReentrantLock，CountdowLatch
就是基于AQS实现的，用法是通过继承AQS实现其模版方法，然后将子类作为同步组件的内部类。

8、创建线程的方法，哪个更好，为什么？

1）继承Thread类创建线程

2）实现Runnable接口创建线程

3）使用Callable和Future创建线程

4）使用线程池例如用Executor框架

实现Runnable和实现Callable接口的方式基本相同，不过是后者执行call()方法有返回值，后者线程执行体run()方法无返回值，因此可以把这两种方式归为一种这种方式与继承Thread类的方法之间的差别如下：

1、线程只是实现Runnable或实现Callable接口，还可以继承其他类。

2、这种方式下，多个线程可以共享一个target对象，非常适合多线程处理同一份资源的情形。

3、但是编程稍微复杂，如果需要访问当前线程，必须调用Thread.currentThread()方法。

4、继承Thread类的线程类不能再继承其他父类（Java单继承决定）。

5、前三种的线程如果创建关闭频繁会消耗系统资源影响性能，而使用线程池可以不用线程的时候放回线程池，用的时候再从线程池取，项目
开发中主要使用线程池

10、Java中有几种线程池？
1 newCachedThreadPool

创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

这种类型的线程池特点是：

工作线程的创建数量几乎没有限制(其实也有限制的,数目为Interger. MAX_VALUE), 这样可灵活的往线程池中添加线程。
如果长时间没有往线程池中提交任务，即如果工作线程空闲了指定的时间(默认为1分钟)，则该工作线程将自动终止。终止后，如果你又提交了
新的任务，则线程池重新创建一个工作线程。
在使用CachedThreadPool时，一定要注意控制任务的数量，否则，由于大量线程同时运行，很有会造成系统瘫痪。

2 newFixedThreadPool

创建一个指定工作线程数量的线程池。每当提交一个任务就创建一个工作线程，如果工作线程数量达到线程池初始的最大数，则将提交的任务存入
到池队列中。

FixedThreadPool是一个典型且优秀的线程池，它具有线程池提高程序效率和节省创建线程时所耗的开销的优点。但是，在线程池空闲时，即
线程池中没有可运行任务时，它不会释放工作线程，还会占用一定的系统资源。

3 newSingleThreadExecutor

创建一个单线程化的Executor，即只创建唯一的工作者线程来执行任务，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序
(FIFO, LIFO, 优先级)执行。如果这个线程异常结束，会有另一个取代它，保证顺序执行。单工作线程最大的特点是可保证顺序地执行各个
任务，并且在任意给定的时间不会有多个线程是活动的。

4 newScheduleThreadPool

创建一个定长的线程池，而且支持定时的以及周期性的任务执行，支持定时及周期性任务执行。

11、线程池有什么好处？

1、线程池的重用

    线程的创建和销毁的开销是巨大的，而通过线程池的重用大大减少了这些不必要的开销，当然既然少了这么多消费内存的开销，其线程执行
    速度也是突飞猛进的提升。

2、控制线程池的并发数

并发：在某个时间段内，多个程序都处在执行和执行完毕之间；但在一个时间点上只有一个程序在运行。头脑风暴：老鹰妈妈喂小雏鹰食物，小雏
鹰很多，而老鹰只有一张嘴，她需要一个个喂过去，到最后每个小雏鹰都可以吃到，但是在一个时间点里只能有一个小雏鹰可以吃到美味的食物。

并行：在某个时间段里，每个程序按照自己独立异步的速度执行，程序之间互不干扰。头脑风暴：这就好似老鹰妈妈决定这样喂食太费劲于是为
每个小雏鹰请了个保姆，这样子在一个时间点里，每个小雏鹰都可以同时吃到食物，而且互相不干扰。

回到线程池，控制线程池的并发数可以有效的避免大量的线程池争夺CPU资源而造成堵塞。头脑风暴：还是拿老鹰的例子来讲，妈妈只有一个，要
这么一个个喂下去，一些饿坏的小雏鹰等不下去了就要破坏规则，抢在靠前喂食的雏鹰面前，而前面的雏鹰也不是吃软饭的，于是打起来了，场面
混乱。老鹰生气了，这么不懂事，谁也别吃了，于是造成了最后谁也没食吃的局面。

3、线程池可以对线程进行管理

    线程池可以提供定时、定期、单线程、并发数控制等功能。比如通过ScheduledThreadPool线程池来执行S秒后，每隔N秒执行一次的任务。

12、cyclicbarrier和countdownlatch的区别

13、如何理解Java多线程回调方法？

https://www.cnblogs.com/puyangsky/p/5581051.html

15、概括的解释下线程的几种可用状态。

1. 新建( new )：新创建了一个线程对象。
2. 可运行( runnable )：线程对象创建后，其他线程(比如 main 线程）调用了该对象 的 start ()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获 取 cpu 的使用权 。

4. 运行( running )：可运行状态( runnable )的线程获得了 cpu 时间片（ timeslice ） ，执行程序代码。
5. 阻塞( block )：阻塞状态是指线程因为某种原因放弃了 cpu 使用权，也即让出了 cpu timeslice ，暂时停止运行。直到线程进入可运行( runnable )状态，才有 机会再次获得 cpu timeslice 转到运行( running )状态。阻塞的情况分三种：
(一). 等待阻塞：运行( running )的线程执行 o . wait ()方法， JVM 会把该线程放 入等待队列( waitting queue )中。
(二). 同步阻塞：运行( running )的线程在获取对象的同步锁时，若该同步锁 被别的线程占用，则 JVM 会把该线程放入锁池( lock pool )中。
(三). 其他阻塞: 运行( running )的线程执行 Thread . sleep ( long ms )或 t . join ()方法，或者发出了 I / O 请求时， JVM 会把该线程置为阻塞状态。            当 sleep ()状态超时、 join ()等待线程终止或者超时、或者 I / O 处理完毕时，线程重新转入可运行( runnable )状态。
6. 死亡( dead )：线程 run ()、 main () 方法执行结束，或者因异常退出了 run ()方法，则该线程结束生命周期。死亡的线程不可再次复生。

16、同步方法和同步代码块的区别是什么？

1.同步方法使用synchronized修饰方法，在调用该方法前，需要获得内置锁（java每个对象都有一个内置锁），否则就处于阻塞状态


代码如： public synchronized void save(){//内容}


2.同步代码块使用synchronized(object){}进行修饰，在调用该代码块时，需要获得内置锁，否则就处于阻塞状态


 代码如： 
  synchronized(object){ 
//内容
    }

18、在监视器(Monitor)内部，是如何做线程同步的？程序应该做哪种级别的同步？

监视器是一种同步机制。
java中提供了这种同步机制的实现
1、Object类中提供的wait notify notifyall方法
2、synchronized关键字隐式锁 或 Lock显示锁
3、每个对象自带一个锁
4、显示锁的Condition条件，用于协作

程序员可以使用显示锁或隐式锁实现互斥，wait notify notifyall condition 实现协作

19、sleep() 和 wait() 有什么区别？

1、这两个方法来自不同的类分别是，sleep来自Thread类，和wait来自Object类。

sleep是Thread的静态类方法，谁调用的谁去睡觉，即使在a线程里调用了b的sleep方法，实际上还是a去睡觉，要让b线程睡觉要在b的代码中
调用sleep。


2、最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。

sleep不出让系统资源；wait是进入线程等待池等待，出让系统资源，其他线程可以占用CPU。一般wait不会加时间限制，因为如果wait线程
的运行资源不够，再出来也没用，要等待其他线程调用notify/notifyAll唤醒等待池中的所有线程，才会进入就绪队列等待OS分配系统资源。
sleep(milliseconds)可以用时间指定使它自动唤醒过来，如果时间不到只能调用interrupt()强行打断。

Thread.Sleep(0)的作用是“触发操作系统立刻重新进行一次CPU竞争”。


3、使用范围：wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用 
   synchronized(x){ 
      x.notify() 
     //或者wait() 
   }


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

20、同步和异步有何异同，在什么情况下分别使用他们？举例说明。

如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共
享数据，必须进行同步存取。

当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用
异步途径往往更有效率。

 
Java中交互方式分为同步和异步两种：

同步交互：指发送一个请求,需要等待返回,然后才能够发送下一个请求，有个等待过程；

异步交互：指发送一个请求,不需要等待返回,随时可以再发送下一个请求，即不需要等待。 
区别：一个需要等待，一个不需要等待，在部分情况下，我们的项目开发中都会优先选择不需要等待的异步交互方式。

哪些情况建议使用同步交互呢？比如银行的转账系统，对数据库的保存操作等等，都会使用同步交互操作，其余情况都优先使用异步交互

21、设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。使用内部类实现线程，对j增减的时候没有考虑顺序问题。

package learning;
 
/**
 * @author john 设计 4 个线程，其中两个线程每次对 j 增加 1 ，另外两个线程对 j 每次减少 1 。写 出程序
 */
public class TestThread {
 
	public static void main(String[] args) {
		for (int i = 0; i < 2; i++) {
			Thread inc = new Thread(new Inc());
			Thread dec = new Thread(new Dec());
			inc.start();
			dec.start();
		}
	}
}
//创建+1线程的类,实现Runnable接口
class Inc implements Runnable {
	private int j;
	//synchronized修饰+1的同步方法,输出线程名称和j的值
	public synchronized void inc() {
		j++;
		System.out.println(Thread.currentThread().getName() + "-inc:" + j);
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		//实现Runnable的run方法,调用inc方法
		this.inc();
		
	}
}
class Dec implements Runnable {
	private int j;
	public synchronized void dec() {
		j--;
		System.out.println(Thread.currentThread().getName() + "-dec:" + j);
	}
	public void run() {
		this.dec();
	}