java中你知道哪些锁？

问题回答：
乐观锁/悲观锁
共享锁/独享锁
公平锁/非公平锁
互斥锁/读写锁
可重入锁
自旋锁
分段锁
偏向锁/轻量级锁/重量级锁

辅助理解：

Java线程的状态或者生命周期？

问题回答：

• Java的线程状态被定义在公共枚举类java.lang.Thread.state中。一种有六种状态
  1.新建（NEW）：表示线程新建出来还没有被启动的状态，比如：Thread t = new MyThread();
  2.就绪/运行（RUNNABLE）：该状态包含了经典线程模型的两种状态：就绪(Ready)、运行(Running)：
  3.阻塞（BLOCKED）：通常与锁有关系，表示线程正在获取有锁控制的资源，比如进入synchronized代码块，获取ReentryLock等；发起阻塞式IO也会阻塞，比如字符流字节流操作。
  4.等待（WAITING）：线程在等待某种资源就绪。
  5.超时等待（TIMED_WAIT）：线程进入条件和等待类似，但是它调用的是带有超时时间的方法。
  6.终止（TERMINATED）：线程正常退出或异常退出后，就处于终结状态。也可以叫线程的死亡。

• 经典线程模型包含5种状态，：新建、就绪、运行、等待、退出

• 经典线程的就绪、运行，在java里面统一叫RUNNABLE

• Java的BLOCKED、WAITING、TIMED_WAITING都属于传统模型的等待状态

synchronized 与lock区别？

问题回答
1.lock是一个接口，而synchronized是java的一个关键字
2.synchronized异常会释放锁，lock异常不会释放，所以一般try catch包起来，finally中写入unlock，避免死锁。
3.Lock可以提高多个线程进行读操作的效率
4.synchronized关键字，可以放代码块，实例方法，静态方法，类上
5.lock一般使用ReentrantLock类做为锁，配合lock()和unlock()方法。在finally块中写unlock()以防死锁。
6.jdk1.6之前synchronized低效。jdk1.6之后synchronized高效。

synchronized 与ReentrantLock区别？

问题回答
1.synchronized依赖JVM实现，ReentrantLock是JDK实现的。synchronized是内置锁，只要在代码开始的地方加synchronized，代码结束会自动释放。Lock必须手动加锁，手动释放锁。
2.ReenTrantLock比synchronized增加了一些高级功能。synchronized代码量少，自动化，但扩展性低，不够灵活；ReentrantLock扩展性好，灵活，但代码量相对多。
3.两者都是可重入锁。都是互斥锁。
4.synchronized是非公平锁，ReentrantLock可以指定是公平锁还是非公平锁。

synchronized 与ThreadLocal区别？

1.都是为了解决多线程中相同变量的访问冲突问题。
2.Synchronized同步机制，提供一份变量，让不同的线程排队访问。
3.ThreadLocal关键字，为每一个线程都提供了一份变量，因此可以同时访问而互不影响。
4.ThreadLocal比直接使用synchronized同步机制解决线程安全问题更简单，更方便，且结果程序拥有更高的并发性。

synchronized 与volatile区别？

1.volatile是一个类型修饰符（type specifier）。
2.volatile，它能够使变量在值发生改变时能尽快地让其他线程知道。
3.关键字volatile是线程同步的轻量级实现，所以volatile性能肯定比synchronized要好，并且只能修改变量，而synchronized可以修饰方法，以及代码块。
4.多线程访问volatile不会发生阻塞，而synchronized会出现阻塞
volatile能保证数据的可见性，但不能保证原子性；而synchronized可以保证原子性，也可以间接保证可见性，因为它会将私有内存和公共内存中的数据做同步
5.关键字volatile解决的下变量在多线程之间的可见性；而synchronized解决的是多线程之间资源同步问题

Thread类中的start()和run()方法有什么区别?

1.通过调用线程类的start()方法来启动一个线程，使线程处于就绪状态，即可以被JVM来调度执行，在调度过程中，JVM通过调用线程类的run()方法来完成实际的业务逻辑，当run()方法结束后，此线程就会终止。
2.如果直接调用线程类的run()方法，会被当作一个普通的函数调用，程序中仍然只有主线程这一个线程。即start()方法能够异步的调用run()方法，但是直接调用run()方法却是同步的，无法达到多线程的目的。
3.因此，只用通过调用线程类的start()方法才能达到多线程的目的。

事务的隔离级别及引发的问题

• 4个隔离级别
• 读未提交、读已提交、可重复读、串行化
• 分别怎么理解呢？
  读未提交（READ UNCOMMITTED），事务中的修改，即使没有提交，对其它事务也是可见的。
  读已提交（READ COMMITTED），一个事务能读取已经提交的事务所做的修改，不能读取未提交的事务所做的修改。也就是事务未提交之前，对其他事务不可见。
  可重复读（REPEATABLE READ），保证在同一个事务中多次读取同样数据的结果是一样的。
  串行化（SERIALIZABLE），强制事务串行执行。
• 读已提交是sql server的默认隔离级别。
• 可重复读是mysql的默认隔离级别。
• 多个事务，各个隔离级别引起的问题
  读未提交：可能出现脏读、不可重复度、幻读；
  读已提交：可能出现不可重复度、幻读；
  可重复读：可能出现幻读；
  串行化：都没问题；

什么是线程安全，java如何保证线程安全？

• 在多线程环境中，能永远保证程序的正确性。执行结果不存在二义性。说白了，运行多少次结果都是一致的。
• 换种说法，当多个线程访问某一个类（对象或方法）时，这个类始终都能表现心正确的行为，那么这个类（对象或方法）就是线程安全的。
• 使用synchronized关键字和使用锁。

介绍一下线程池？

• 线程池就是预先创建一些线程，它们的集合称为线程池。
• 线程池可以很好地提高性能，在系统启动时即创建大量空闲的线程，程序将一个task给到线程池，线程池就会启动一条线程来执行这个任务，执行结束后，该线程不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个任务。
• 线程的创建和销毁比较消耗时间，线程池可以避免这个问题。
• Executors是jdk1.5之后的一个新类，提供了一些静态方法，帮助我们方便的生成一些常见的线程池
  newSingleThreadExecutor：创建一个单线程化的Executor。
  newFixedThreadPool：创建一个固定大小的线程池。
  newCachedThreadPool：创建一个可缓存的线程池
  newScheduleThreadPool：创建一个定长的线程池，可以周期性执行任务。
• 我们还可以使用ThreadPoolExecutor自己定义线程池，弄懂它的构造参数即可
  int corePoolSize，//核心池的大小
  int maximumPoolSize，//线程池最大线程数
  long keepAliveTime，//保持时间/额外线程的存活时间
  TimeUnit unit，//时间单位
  BlockingQueue workQueue，//任务队列
  ThreadFactory threadFactory，//线程工厂
  RejectedExecutionHandler handler //异常的捕捉器

简要回答

• 线程池就是预先创建一些线程
• 线程池可以很好地提高性能
• 线程池可以避免线程的频繁创建和销毁
• Executors可以创建常见的4种线程（单线程池、固定大小的、可缓存的、可周期性执行任务的）。
  可以通过ThreadPoolExecutor自己定义线程池。

同步和异步有何异同？

• 同步发了指令，会等待返回，然后再发送下一个。
• 异步发了指令，不会等待返回，随时可以再发送下一个请求
• 同步可以避免出现死锁，读脏数据的发生
• 异步则是可以提高效率
• 实现同步的机制主要有临界区、互斥、信号量和事件

如何异步获取多线程返回的数据？

问题包含
说一下Callable这个接口的理解？
说一下Future接口的理解？
说一下FutureTask类的理解？
说一下CompletionService接口的理解？

问题回答

• 通过Callable+Future，Callable负责执行返回，Future负责接收。Callable接口对象可以交给ExecutorService的submit方法去执行。
• 通过Callable+FutureTask，Callable负责执行返回，FutureTask负责接收。FutureTask同时实现了Runnable和Callable接口，可以给到ExecutorService的submit方法和Thread去执行。
• 通过CompletionService，jdk1.8之后提供了完成服务CompletionService，可以实现这样的需求。
• 注意，实现Runnable接口任务执行结束后无法获取执行结果。

如何自定义线程池？

问题回答

• 通过ThreadPoolExecutor创建
• 弄懂它的7个构造参数即可
  int corePoolSize，//核心池的大小
  int maximumPoolSize，//线程池最大线程数
  long keepAliveTime，//保持时间/额外线程的存活时间
  TimeUnit unit，//时间单位
  BlockingQueue workQueue，//任务队列
  ThreadFactory threadFactory，//线程工厂
  RejectedExecutionHandler handler //异常的捕捉器

工作中哪些地方使用了多线程？

• 一般业务，web层–> service层 -->dao --> sql基本用不到多线程
• 数据量很大（1000w级别、TB级别）的I/O操作，可以考虑多线程
• 举一些例子
  自己做并发测试的时候，假如想写想模拟3000个并发请求。
  多线程下单抢单，假如支持5000人的并发下单。
  多线程写入mysql，假如有1000w条数据要入库。
  多线程写入redis，假如有1000w的数据要存入redis。
  多线程导入ES索引，假如有1000w的数据要添加到ES索引。
  poi多线程导出，假如xls里面有10w的数据需要导出。
  poi多线程导入，假如有10w条数据需要导入到xls。
  多线程发送邮件，假如有10w用户需要发送邮件。
  多线程发送短信，假如有10w用户需要发送邮件。
  多线程备份日志，假如10tb日志文件要备份。
  多线程验证数据，比如验证url是否存在，假如有100w个url。

 欢迎大家评论区交流

import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;


public class ConcurrentTestUtils {
    /**
     * @param run 要测试的代码
     * @param threadSize 每次并发的线程数
     * @param loop 测试次数
     * @Author AmazingMud
     */
    public static void execute(Runnable  run,int threadSize,int loop){
        AtomicInteger count = new AtomicInteger();
        for (int j = 0; j <loop ; j++) {
            System.out.println("第"+(j+1)+"轮并发测试，每轮并发数"+threadSize);
            CountDownLatch countDownLatch = new CountDownLatch(1);
            Set<Thread> threads = new HashSet<>(threadSize);
            //批量新建线程
            for (int i = 0; i <threadSize ; i++) {
                threads.add(
                        new Thread(()->{
                            try {
                                countDownLatch.await();
                                run.run();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        },"Thread"+count.getAndIncrement()));
            }
            //开启所有线程并确保其进入Waiting状态
            for (Thread thread : threads) {
                thread.start();
                while(thread.getState() != Thread.State.WAITING);
            }
            //唤醒所有在countDownLatch上等待的线程
            countDownLatch.countDown();
            //等待所有线程执行完毕,开启下一轮
            for (Thread thread : threads) {
                try {
                    thread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public static void execute(Runnable  run){
        execute(run,1000,1);
    }
    public static void execute(Runnable  run,int threadSize){
        execute(run,threadSize,1);
    }
    public static void main(String[] args) {
        execute(()->{
            System.out.println(Thread.currentThread());
        },10,10);
    }
}

定义：

      当多个线程同时执行，多个线程之间是相互抢占资源执行，并且抢占是发生在线程的执行的每一步过程中，导致出现非法数据。这种现象就称之为多线程的并发安全问题。

代码案例：

public class SellTicketDemo {
	  public static void main(String[] args) {
		//创建票对象
		Ticket t=new Ticket();
		//给票的count属性赋值为100
		t.setCount(100);
		
		SellSystem s=new SellSystem(t);
		//4个线程对应4个售票窗口
		Thread thread1=new Thread(s);
		Thread thread2=new Thread(s);
		Thread thread3=new Thread(s);
		Thread thread4=new Thread(s);
		thread1.start();
		thread2.start();
		thread3.start();
		thread4.start();
	}
}

//卖票系统
class SellSystem implements Runnable{
	//定义票对象t
	private Ticket t;
	
	public SellSystem(Ticket t) {
		this.t=t;
	}
	@Override
	public void run() {
		while(true){
			try {
				//此处让进来的线程睡一会是为了增加其他线程抢占到执行权的概率
				Thread.sleep(1);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			if (t.getCount()>0) {
				t.setCount(t.getCount()-1);
				//Thread.currentThread()表示获取当前正在执行的线程，t.getCount()是t.setCount设置后的数量
				System.out.println(Thread.currentThread().getName()+"卖了一张票，还剩"+t.getCount());
			}
		}
	}
}

//票
class Ticket{
	//定义票的数量属性
	private int count;

	public int getCount() {
		return count;
	}

	public void setCount(int count) {
		this.count = count;
	}
	
}

执行结果：

异常解析：

 上述出现了三种异常情况：1. 跳过数字  2. 重复数字  3. 出现负数

  1. 跳过数字 ：当票还剩9张时，假设小红线程先抢到执行权，进入第①步，经过getCount得到9，9>0进入第②步，经过计算再用setCount将8设定为结果值，此时小兰抢到了执行权，由于小红已经setCount设定了结果值，小兰进入第①步后通过getCount得到8，8>0进入第②步，经过计算以及setCount将结果值设定为7，进入第③步，打印出7执行完毕。这时小红又抢回执行权，由于总票数是大家共享的，此时的总票数为7，小红前两步已完成，直接进入第③步，经过getCount得到7，然后打印出7执行完毕。因此会出现9 , 7, 7 跳过数字的情况。

2.重复数字：当票还剩4张时，假设小红线程先抢到执行权，进入第①步，经过getCount得到5，5>0进入第②步，经过(t.getCount() - 1)计算变为3，正当小红准备setCount将3设定为结果值时，小兰抢到了执行权，由于小红还没有setCount设定结果值，小兰进入第①步后通过getCount得到的还是4，4>0进入第②步，经过计算再用setCount将结果值设定为3，进入第③步，打印出3执行完毕。这时小红又抢回执行权，由于总票数是大家共享的，此时的总票数为3，小红接着上次未执行完的操作直接setCount，将3设置为结果值，接着进入第③步，打印出3执行完毕。因此会出现3 ,3 重复数字的情况。

3.出现负数：当票还剩1张时，假设小红线程先抢到执行权，进入第①步，经过getCount得到1，1>0准备进入第②步，此时小兰抢到了执行权，进入第①步，经过getCount仍然得到1，1>0准备进入第②步，此时又被小黑抢到了执行权，进入第①步，经过getCount仍然得到1，1>0进入第②步，经过计算以及setCount将0设为结果值，进入第③步，打印出0执行完毕。此时小红又抢到执行权，由于小红上次已经执行完第①步，直接进入第②步，经过getCount得到0，再减1，最后由setCount将-1设置为结果值，进入第③步，打印出-1执行完毕。此时小兰又抢到执行权，由于小兰上次已经执行完第①步，直接进入第②步，经过getCount得到-1，再减1，最后由setCount将-2设置为结果值，进入第③步，打印出-2执行完毕。因此会出现0, -1 , -2 负数的情况。

4. 解决方法：

通过同步代码块的方式将对象锁起来。用synchronized来将代码限制起来，需要锁对象。锁对象要求所有的线程都得认识。锁对象：共享资源、方法区中的数据、this。

正确代码：

修改的代码如下：

synchronized (t) {
    if (t.getCount()>0) {
	    t.setCount(t.getCount()-1);
	    //Thread.currentThread()表示获取当前正在执行的线程，t.getCount()是t.setCount设置后数量
          System.out.println(Thread.currentThread().getName()+"卖了一张票，还剩"+t.getCount());
	}
}

最终代码如下：

public class SellTicketDemo {
	  public static void main(String[] args) {
		//创建票对象
		Ticket t=new Ticket();
		//给票的count属性赋值为100
		t.setCount(100);
		
		SellSystem s=new SellSystem(t);
		
		//4个线程对应4个售票窗口
		Thread thread1=new Thread(s);
		Thread thread2=new Thread(s);
		Thread thread3=new Thread(s);
		Thread thread4=new Thread(s);
		thread1.start();
		thread2.start();
		thread3.start();
		thread4.start();
	}
}

//卖票系统
class SellSystem implements Runnable{
	//定义票对象t
	private Ticket t;
	
	public SellSystem(Ticket t) {
		this.t=t;
	}
	@Override
	public void run() {
		while(true){
			try {
				//此处让进来的线程睡一会是为了增加其他线程抢占到执行权的概率
				Thread.sleep(1);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			synchronized (t) {
				if (t.getCount()>0) {
					t.setCount(t.getCount()-1);
					//Thread.currentThread()表示获取当前正在执行的线程，t.getCount()是t.setCount设置后的数量
					System.out.println(Thread.currentThread().getName()+"卖了一张票，还剩"+t.getCount());
				}
			}
		}
	}
}

//票
class Ticket{
	//定义票的数量属性
	private int count;

	public int getCount() {
		return count;
	}

	public void setCount(int count) {
		this.count = count;
	}
	
}

执行结果：